From 97db96d74540287385fdfac081399cbfa3921d81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ognjen=20Marinkovi=C4=87?=
 <77169894+ognjeeen@users.noreply.github.com>
Date: Sun, 13 Sep 2026 21:39:11 +0200
Subject: [PATCH 01/17] Animate tab and project reordering with shared motion
 settings (#206)

* Animate tab and project reordering with shared motion settings

* Fix scrolling and consecutive gestures during animated reordering

* Use committed props for animated reorder gestures

* Preserve pending tab reorders before close clicks
---
 src/chrome/ProjectRail.tsx                    |  47 +--
 src/chrome/Sidebar.tsx                        |  37 +--
 src/chrome/SurfaceTabs.tsx                    |  27 +-
 src/chrome/TabMiddleClick.test.ts             | 171 ++++++++++-
 src/chrome/TitleBar.tsx                       |  32 +-
 src/hooks/useAnimatedReorder.test.ts          | 274 ++++++++++++++++++
 src/hooks/useAnimatedReorder.ts               | 260 +++++++++++++++++
 .../useAnimatedReorderConcurrency.test.ts     | 122 ++++++++
 src/index.css                                 |  57 ++++
 src/lib/motion.ts                             |  11 +
 10 files changed, 925 insertions(+), 113 deletions(-)
 create mode 100644 src/hooks/useAnimatedReorder.test.ts
 create mode 100644 src/hooks/useAnimatedReorder.ts
 create mode 100644 src/hooks/useAnimatedReorderConcurrency.test.ts
 create mode 100644 src/lib/motion.ts

diff --git a/src/chrome/ProjectRail.tsx b/src/chrome/ProjectRail.tsx
index e690f6e4..6818b586 100644
--- a/src/chrome/ProjectRail.tsx
+++ b/src/chrome/ProjectRail.tsx
@@ -20,7 +20,7 @@ import { useEffect, useMemo, useRef, useState, type MouseEvent } from "react";
 import { useDragResize } from "../hooks/useDragResize";
 import { useLockOverscroll } from "../hooks/useLockOverscroll";
 import { useProjectDiffStats } from "../hooks/useProjectDiffStats";
-import { useSortable } from "../hooks/useSortable";
+import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { useTabGroupLogos } from "../hooks/useTabGroupLogos";
 import {
   loadProjectRailWidth,
@@ -358,14 +358,8 @@ export function ProjectRail({
 
   const pinnedIds = sections.pinned.map((item) => item.path);
   const projectIds = sections.projects.map((item) => item.path);
-  const pinnedSortable = useSortable(pinnedIds, onReorderPinned, {
-    axis: "y",
-    onActivate: onSelectProject,
-  });
-  const projectSortable = useSortable(projectIds, onReorderProjects, {
-    axis: "y",
-    onActivate: onSelectProject,
-  });
+  const pinnedSortable = useAnimatedReorder(pinnedIds, onReorderPinned, "y");
+  const projectSortable = useAnimatedReorder(projectIds, onReorderProjects, "y");
   return (
     <nav
       ref={resize.setPaneRef}
@@ -580,7 +574,7 @@ export function ProjectRail({
   );
 }
 
-type SortableHandle = ReturnType<typeof useSortable>;
+type SortableHandle = ReturnType<typeof useAnimatedReorder>;
 
 const LIVE_AGENT_MIN = 2;
 const LIVE_AGENT_CAP = 4;
@@ -843,7 +837,7 @@ function ProjectSection({
         </p>
       ) : null}
       <div className="flex flex-col gap-px px-2">
-        {items.map((item, index) => (
+        {items.map((item) => (
           <ProjectCard
             key={item.path}
             item={item}
@@ -851,7 +845,6 @@ function ProjectSection({
             busy={isBusyPath(item.path, busy)}
             pinned={pinned}
             sortable={sortable}
-            index={index}
             onSelect={onSelect}
             onTogglePin={onTogglePin}
             onContextMenu={onContextMenu}
@@ -877,7 +870,6 @@ function ProjectCard({
   busy,
   pinned,
   sortable,
-  index,
   onSelect,
   onTogglePin,
   onContextMenu,
@@ -893,7 +885,6 @@ function ProjectCard({
   busy: boolean;
   pinned: boolean;
   sortable: SortableHandle;
-  index: number;
   onSelect: (path: string) => void;
   onTogglePin: (path: string) => void;
   onContextMenu: (path: string, event: MouseEvent<HTMLElement>) => void;
@@ -910,17 +901,6 @@ function ProjectCard({
   const name = resolveTabGroupLabel(key, groupLabels, fallbackName);
   const logoPath = resolveTabGroupLogo(key, groupLogos);
   const color = resolveTabGroupColor(key, groupColors, groupCustomColors, seed);
-  const dragging = sortable.draggingId === item.path;
-  const showStart =
-    sortable.draggingId &&
-    sortable.toIndex === index &&
-    sortable.fromIndex !== null &&
-    sortable.toIndex < sortable.fromIndex;
-  const showEnd =
-    sortable.draggingId &&
-    sortable.toIndex === index &&
-    sortable.fromIndex !== null &&
-    sortable.toIndex > sortable.fromIndex;
   const diffEnabled = Boolean(item.path) && item.path !== "~";
   const stats = useProjectDiffStats(item.path, diffEnabled);
   const files = stats?.files ?? 0;
@@ -933,11 +913,12 @@ function ProjectCard({
   return (
     <div
       ref={(el) => sortable.setItemRef(item.path, el)}
-      className={`group relative flex touch-none items-stretch rounded-md px-2 h-8 ${
+      data-selected={selected || undefined}
+      className={`reorder-item project-reorder-item group relative flex touch-none items-stretch rounded-md px-2 h-8 ${
         selected
           ? "bg-content/12 text-content"
-          : "opacity-65 hover:bg-content/5 hover:text-content"
-      } ${dragging ? "opacity-40" : ""} cursor-default`}
+          : "opacity-65"
+      } cursor-default`}
       onPointerDown={(event) => {
         if (event.button !== 0) return;
         if ((event.target as HTMLElement | null)?.closest("[data-no-drag]")) {
@@ -954,12 +935,6 @@ function ProjectCard({
       }}
       onContextMenu={(event) => onContextMenu(item.path, event)}
     >
-      {showStart ? (
-        <div className="pointer-events-none absolute inset-x-2 top-0 z-20 h-0.5 rounded-full bg-accent" />
-      ) : null}
-      {showEnd ? (
-        <div className="pointer-events-none absolute inset-x-2 bottom-0 z-20 h-0.5 rounded-full bg-accent" />
-      ) : null}
       <button
         type="button"
         title={cardTitle}
@@ -967,7 +942,7 @@ function ProjectCard({
         aria-current={selected ? "true" : undefined}
         className="flex min-w-0 flex-1 cursor-default items-center gap-2 text-left group-hover:pr-6"
       >
-        <div className="grid size-4 shrink-0 place-items-center transition-opacity group-hover:opacity-0">
+        <div className="project-card-logo grid size-4 shrink-0 place-items-center transition-opacity group-hover:opacity-0">
           {logoPath && !busy ? (
             <ProjectLogoIcon
               path={logoPath}
@@ -992,7 +967,7 @@ function ProjectCard({
           <span className={nameClassName}>{name}</span>
         )}
         {hasChanges ? (
-          <span className="shrink-0 group-hover:hidden">
+          <span className="project-card-stats shrink-0 group-hover:hidden">
             <ProjectDiffStat additions={additions} deletions={deletions} />
           </span>
         ) : null}
diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index 2f178f10..c6991095 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -118,6 +118,7 @@ import { useGitFileStatuses } from "../hooks/useGitFileStatuses";
 import { useLockOverscroll } from "../hooks/useLockOverscroll";
 import { useProjectDiffStats } from "../hooks/useProjectDiffStats";
 import { useSortable } from "../hooks/useSortable";
+import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { useTabGroupLogos } from "../hooks/useTabGroupLogos";
 import { normalizeHex } from "../lib/colorUtils";
 import {
@@ -509,11 +510,14 @@ function SidebarComponent({
   const sessionListKey = `${cwd}\0${sessionFilters.showArchived}\0${sessionFilters.time}\0${sessionFilters.hiddenHarnesses.join(",")}\0${sessionFilters.status.working}\0${sessionFilters.status.needsApproval}\0${sessionFilters.status.done}\0${searchQuery}`;
   const sessionHarnesses = harnessesInSessions(sessions);
   const narrowedByUser = searchNarrowed || filtersActive;
-  const sortable = useSortable(tabOrder, (ids) => {
-    const next = ids as SidebarTab[];
+  const visibleTabs = tabOrder.filter((itemId) => itemId !== "inbox");
+  const sortable = useAnimatedReorder(visibleTabs, (ids) => {
+    let index = 0;
+    const next = tabOrder.map((itemId) =>
+      itemId === "inbox" ? itemId : ids[index++],
+    );
     setTabOrder(next);
     saveSidebarTabOrder(next);
-    if (next[0]) onTabChange(next[0]);
   });
   const visibleFolderIds = sessionListEntries.flatMap((entry) =>
     entry.kind === "folder" ? [entry.folder.id] : [],
@@ -530,7 +534,6 @@ function SidebarComponent({
     },
     { axis: "y" },
   );
-  const visibleTabs = tabOrder.filter((itemId) => itemId !== "inbox");
   const canDragTabs = visibleTabs.length > 1;
   const showProjectRail = Boolean(onSelectProject && onOpenProject);
   // Settings live in the rail slot, so they keep it visible even when the
@@ -1088,39 +1091,19 @@ function SidebarComponent({
   const changeDeletions = changeStats?.deletions ?? 0;
   const hasChangeStats = changeAdditions > 0 || changeDeletions > 0;
 
-  const workspaceTabItems = visibleTabs.map((itemId, index) => {
+  const workspaceTabItems = visibleTabs.map((itemId) => {
     const active = tab === itemId;
     const isChangesTab = itemId === "changes";
-    const draggingTab = sortable.draggingId === itemId;
-    const showStart =
-      sortable.draggingId &&
-      sortable.toIndex === index &&
-      sortable.fromIndex !== null &&
-      sortable.toIndex < sortable.fromIndex;
-    const showEnd =
-      sortable.draggingId &&
-      sortable.toIndex === index &&
-      sortable.fromIndex !== null &&
-      sortable.toIndex > sortable.fromIndex;
     return (
       <div
         key={itemId}
         ref={(el) => sortable.setItemRef(itemId, el)}
-        className={`relative flex min-w-0 flex-1 touch-none items-stretch ${
-          draggingTab ? "opacity-40" : ""
-        } ${canDragTabs ? "cursor-grab active:cursor-grabbing" : ""}`}
+        className={`reorder-item workspace-tab relative flex min-w-0 flex-1 touch-none items-stretch ${canDragTabs ? "cursor-grab active:cursor-grabbing" : ""}`}
         onPointerDown={(event) => {
           if (event.button !== 0) return;
-          onTabPick(itemId);
           sortable.onItemPointerDown(itemId, event);
         }}
       >
-        {showStart ? (
-          <div className="pointer-events-none absolute inset-y-0 left-0 z-20 w-0.5 bg-accent" />
-        ) : null}
-        {showEnd ? (
-          <div className="pointer-events-none absolute inset-y-0 right-0 z-20 w-0.5 bg-accent" />
-        ) : null}
         <button
           type="button"
           role="tab"
@@ -1146,7 +1129,7 @@ function SidebarComponent({
           className={`flex h-6 min-w-0 flex-1 items-center justify-center self-center rounded-md px-2 text-[12px] leading-none ${
             active
               ? "bg-content/10 text-content"
-              : "text-content/50 hover:bg-content/5 hover:text-content"
+              : "text-content/50"
           } ${canDragTabs ? "cursor-grab active:cursor-grabbing" : ""}`}
         >
           {isChangesTab && hasChangeStats ? (
diff --git a/src/chrome/SurfaceTabs.tsx b/src/chrome/SurfaceTabs.tsx
index 7f1af6a5..eb42884b 100644
--- a/src/chrome/SurfaceTabs.tsx
+++ b/src/chrome/SurfaceTabs.tsx
@@ -20,7 +20,7 @@ import { IS_MAC, IS_WIN } from "../lib/platform";
 import { releaseNotesTitle } from "../lib/releaseNotes";
 import { terminalTabLabel } from "../lib/terminalTab";
 import { useLockOverscroll } from "../hooks/useLockOverscroll";
-import { useSortable } from "../hooks/useSortable";
+import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { ExplorerMenu, type ExplorerMenuItem } from "./ExplorerMenu";
 import { FileTypeIcon } from "./FileTypeIcon";
 
@@ -178,7 +178,7 @@ export function SurfaceTabs({
   const activeTabRef = useRef<HTMLDivElement | null>(null);
   const [menu, setMenu] = useState<SurfaceTabMenu | null>(null);
   const fileIds = files.map((file) => file.id);
-  const sortable = useSortable(fileIds, onReorder);
+  const sortable = useAnimatedReorder(fileIds, onReorder);
   const canDrag = files.length > 1;
   const menuFile = menu
     ? files.find((file) => file.id === menu.fileId)
@@ -255,7 +255,7 @@ export function SurfaceTabs({
           <GripVertical className="size-3.5" strokeWidth={1.75} />
         </div>
       ) : null}
-      {files.map((file, index) => {
+      {files.map((file) => {
         const active = file.id === activeFileId;
         const dirty = dirtyFileIds.has(file.id);
         const errors = fileErrorCounts.get(file.id) ?? 0;
@@ -264,17 +264,6 @@ export function SurfaceTabs({
         const review = isReviewTab(file) && !changes;
         const terminal = isTerminalTab(file);
         const { label, iconName, tooltip } = surfaceTabPresentation(file);
-        const dragging = sortable.draggingId === file.id;
-        const showStart =
-          sortable.draggingId &&
-          sortable.toIndex === index &&
-          sortable.fromIndex !== null &&
-          sortable.toIndex < sortable.fromIndex;
-        const showEnd =
-          sortable.draggingId &&
-          sortable.toIndex === index &&
-          sortable.fromIndex !== null &&
-          sortable.toIndex > sortable.fromIndex;
         return (
           <div
             key={file.id}
@@ -282,9 +271,9 @@ export function SurfaceTabs({
               sortable.setItemRef(file.id, el);
               if (el && file.id === activeFileId) activeTabRef.current = el;
             }}
-            className={`group relative flex w-52 min-w-28 shrink touch-none items-stretch border-r border-content/10 ${
+            className={`reorder-item tab-motion group relative flex w-52 min-w-28 shrink touch-none items-stretch border-r border-content/10 ${
               active ? "bg-content/8" : "hover:bg-content/5"
-            } ${dragging ? "opacity-40" : ""} ${
+            } ${
               canDrag ? "cursor-grab active:cursor-grabbing" : ""
             }`}
             onMouseDownCapture={(event) => {
@@ -317,12 +306,6 @@ export function SurfaceTabs({
               });
             }}
           >
-            {showStart ? (
-              <div className="pointer-events-none absolute inset-y-0 left-0 z-20 w-0.5 bg-accent" />
-            ) : null}
-            {showEnd ? (
-              <div className="pointer-events-none absolute inset-y-0 right-0 z-20 w-0.5 bg-accent" />
-            ) : null}
             <button
               type="button"
               role="tab"
diff --git a/src/chrome/TabMiddleClick.test.ts b/src/chrome/TabMiddleClick.test.ts
index 892ccb8b..072c0636 100644
--- a/src/chrome/TabMiddleClick.test.ts
+++ b/src/chrome/TabMiddleClick.test.ts
@@ -1,5 +1,5 @@
 // @vitest-environment happy-dom
-import { act, createElement, type ComponentProps } from "react";
+import { act, createElement, useState, type ComponentProps } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { SurfaceTabs } from "./SurfaceTabs";
@@ -12,6 +12,14 @@ let root: Root;
 
 beforeEach(() => {
   vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  document.documentElement.style.setProperty(
+    "--motion-reorder-duration",
+    "160ms",
+  );
+  document.documentElement.style.setProperty(
+    "--motion-ease-out",
+    "cubic-bezier(0.22, 1, 0.36, 1)",
+  );
   container = document.createElement("div");
   document.body.append(container);
   root = createRoot(container);
@@ -20,6 +28,7 @@ beforeEach(() => {
 afterEach(() => {
   act(() => root.unmount());
   container.remove();
+  document.documentElement.removeAttribute("style");
   vi.unstubAllGlobals();
 });
 
@@ -43,6 +52,36 @@ function click(target: Element, button: number) {
   return { down, up };
 }
 
+function pointer(target: EventTarget, type: string, clientX: number) {
+  act(() =>
+    target.dispatchEvent(
+      new PointerEvent(type, {
+        bubbles: true,
+        button: 0,
+        pointerId: 1,
+        clientX,
+        clientY: 16,
+      }),
+    ),
+  );
+}
+
+function layoutTabs(elements: HTMLElement[]) {
+  elements.forEach((element, index) => {
+    vi.spyOn(element, "getBoundingClientRect").mockReturnValue(
+      new DOMRect(index * 100, 0, 100, 32),
+    );
+    const captured = new Set<number>();
+    element.setPointerCapture = (id) => {
+      captured.add(id);
+    };
+    element.hasPointerCapture = (id) => captured.has(id);
+    element.releasePointerCapture = (id) => {
+      captured.delete(id);
+    };
+  });
+}
+
 function workspaceTab(id: string): Tab {
   return {
     id,
@@ -109,6 +148,136 @@ function renderTabs(
 describe.each(["workspace", "file", "terminal"] as const)(
   "%s tab mouse gestures",
   (kind) => {
+    it("moves neighboring tabs during a drag and saves the order after settling", () => {
+      vi.useFakeTimers();
+      const { tab, onReorder } = renderTabs(kind);
+      const second = tab.parentElement!;
+      const first = container.querySelector(
+        '[aria-label="Close first"]',
+      )!.parentElement!;
+      layoutTabs([first, second]);
+      try {
+        pointer(tab, "pointerdown", 150);
+        pointer(window, "pointermove", 30);
+        act(() => vi.advanceTimersByTime(32));
+        expect(first.style.transform).toBe("translate3d(100px, 0, 0)");
+        expect(second.style.transform).toBe("translate3d(-100px, 0, 0)");
+        expect(onReorder).not.toHaveBeenCalled();
+        pointer(window, "pointerup", 30);
+        expect(onReorder).not.toHaveBeenCalled();
+        act(() => vi.runAllTimers());
+        expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+          ["second", "first"],
+          "second",
+        );
+      } finally {
+        act(() => window.dispatchEvent(new Event("blur")));
+        act(() => vi.runAllTimers());
+        vi.useRealTimers();
+      }
+    });
+
+    it.each([
+      ["close button", 60],
+      ["middle click", 60],
+      ["close button", 160],
+      ["middle click", 160],
+    ] as const)(
+      "preserves the reordered tabs when closing another with %s %i ms after drop",
+      (method, delay) => {
+        vi.useFakeTimers();
+        const onReorder = vi.fn();
+        const onClose = vi.fn();
+        function Tabs() {
+          const [ids, setIds] = useState(["first", "second", "third"]);
+          const [activeId, setActiveId] = useState("first");
+          const reorder = (next: string[], movedId?: string) => {
+            onReorder(next, movedId);
+            setIds(next);
+          };
+          const close = (id: string) => {
+            onClose(id);
+            setIds((current) => current.filter((entry) => entry !== id));
+          };
+          return kind === "workspace"
+            ? createElement(TitleBar, {
+                tabs: ids.map(workspaceTab),
+                activeId,
+                cwd: "/project",
+                onToggleSidebar: vi.fn(),
+                onNew: vi.fn(),
+                onSelect: setActiveId,
+                onClose: close,
+                onCloseMany: vi.fn(),
+                onReorder: reorder,
+              })
+            : createElement(SurfaceTabs, {
+                files: ids.map((id) => ({
+                  id,
+                  path: id,
+                  cwd: "/project",
+                  ...(kind === "terminal"
+                    ? { terminal: true, foreground: "vite" }
+                    : {}),
+                })),
+                activeFileId: activeId,
+                dirtyFileIds: new Set<string>(),
+                fileErrorCounts: new Map<string, number>(),
+                onSelectFile: setActiveId,
+                onCloseFile: close,
+                onReorder: reorder,
+              });
+        }
+
+        try {
+          act(() => root.render(createElement(Tabs)));
+          const closeButtons = Array.from(
+            container.querySelectorAll<HTMLButtonElement>(
+              'button[aria-label^="Close "]',
+            ),
+          );
+          layoutTabs(closeButtons.map((button) => button.parentElement!));
+          const second = closeButtons[1].parentElement!.querySelector("button")!;
+          pointer(second, "pointerdown", 150);
+          pointer(window, "pointermove", 30);
+          act(() => vi.advanceTimersByTime(32));
+          pointer(window, "pointerup", 30);
+          expect(onReorder).not.toHaveBeenCalled();
+          act(() => vi.advanceTimersByTime(delay));
+
+          const thirdClose = container.querySelector(
+            '[aria-label="Close third"]',
+          )!;
+          click(
+            method === "close button"
+              ? thirdClose
+              : thirdClose.parentElement!.querySelector("button")!,
+            method === "close button" ? 0 : 1,
+          );
+          expect(onClose).toHaveBeenCalledExactlyOnceWith("third");
+          act(() => vi.runAllTimers());
+
+          expect(
+            Array.from(
+              container.querySelectorAll('button[aria-label^="Close "]'),
+              (button) => button.getAttribute("aria-label"),
+            ),
+          ).toEqual(["Close second", "Close first"]);
+          expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+            ["second", "first", "third"],
+            "second",
+          );
+          expect(onReorder.mock.invocationCallOrder[0]).toBeLessThan(
+            onClose.mock.invocationCallOrder[0],
+          );
+        } finally {
+          act(() => window.dispatchEvent(new Event("blur")));
+          act(() => vi.runAllTimers());
+          vi.useRealTimers();
+        }
+      },
+    );
+
     it.each(["first", "second"])(
       "closes on middle release without selecting, active tab is %s",
       (activeId) => {
diff --git a/src/chrome/TitleBar.tsx b/src/chrome/TitleBar.tsx
index 517fd095..715814ac 100644
--- a/src/chrome/TitleBar.tsx
+++ b/src/chrome/TitleBar.tsx
@@ -26,7 +26,7 @@ import { looksLikeProject } from "../lib/recents";
 import type { HarnessId } from "../lib/session";
 import { CwdPicker } from "./CwdPicker";
 import { useLockOverscroll } from "../hooks/useLockOverscroll";
-import { useSortable } from "../hooks/useSortable";
+import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { FileTypeIcon } from "./FileTypeIcon";
 import { HarnessIcon } from "./HarnessIcon";
 import { getCurrentWindow } from "@tauri-apps/api/window";
@@ -214,11 +214,10 @@ function TabHarnesses({
   );
 }
 
-type SortableApi = ReturnType<typeof useSortable>;
+type SortableApi = ReturnType<typeof useAnimatedReorder>;
 
 function TitleTabItem({
   tab,
-  index,
   active,
   closable,
   canDrag,
@@ -229,7 +228,6 @@ function TitleTabItem({
   itemRef,
 }: {
   tab: Tab;
-  index: number;
   active: boolean;
   closable: boolean;
   canDrag: boolean;
@@ -239,21 +237,8 @@ function TitleTabItem({
   onContextMenu: (id: string, event: ReactMouseEvent<HTMLDivElement>) => void;
   itemRef?: (el: HTMLDivElement | null) => void;
 }) {
-  const dragging = canDrag && sortable.draggingId === tab.id;
   const { headline, meta, tooltip } = tabCopy(tab);
   const fileIcon = tab.files[0];
-  const showStart =
-    canDrag &&
-    sortable.draggingId &&
-    sortable.toIndex === index &&
-    sortable.fromIndex !== null &&
-    sortable.toIndex < sortable.fromIndex;
-  const showEnd =
-    canDrag &&
-    sortable.draggingId &&
-    sortable.toIndex === index &&
-    sortable.fromIndex !== null &&
-    sortable.toIndex > sortable.fromIndex;
 
   return (
     <div
@@ -261,7 +246,7 @@ function TitleTabItem({
         sortable.setItemRef(tab.id, el);
         itemRef?.(el);
       }}
-      className={`group @container relative flex h-full cursor-default touch-none items-center self-stretch min-w-0 w-full ${dragging ? "opacity-40" : ""}`}
+      className="reorder-item tab-motion group @container relative flex h-full cursor-default touch-none items-center self-stretch min-w-0 w-full"
       data-tauri-drag-region="false"
       onContextMenu={(event) => {
         event.preventDefault();
@@ -286,12 +271,6 @@ function TitleTabItem({
         if (canDrag) sortable.onItemPointerDown(tab.id, event);
       }}
     >
-      {showStart ? (
-        <div className="pointer-events-none absolute inset-y-1.5 left-0 z-20 w-0.5 rounded-full bg-accent" />
-      ) : null}
-      {showEnd ? (
-        <div className="pointer-events-none absolute inset-y-1.5 right-0 z-20 w-0.5 rounded-full bg-accent" />
-      ) : null}
       <button
         type="button"
         title={tooltip}
@@ -560,7 +539,7 @@ function TitleBarComponent({
   onSelectProject,
 }: Props) {
   const tabIds = tabs.map((tab) => tab.id);
-  const sortable = useSortable(tabIds, onReorder);
+  const sortable = useAnimatedReorder(tabIds, onReorder);
   const lockOverscroll = useLockOverscroll<HTMLDivElement>();
   const tabStripRef = useRef<HTMLDivElement | null>(null);
   const setTabStripRef = useCallback(
@@ -817,7 +796,7 @@ function TitleBarComponent({
             ref={setTabStripRef}
             className="scrollbar-none flex h-full min-w-0 cursor-default items-center gap-0.5 overflow-x-auto overflow-y-hidden overscroll-none px-1.5"
           >
-            {tabs.map((tab, index) => (
+            {tabs.map((tab) => (
               <div
                 key={tab.id}
                 className="relative flex h-full w-56 min-w-28 shrink cursor-default items-center"
@@ -825,7 +804,6 @@ function TitleBarComponent({
               >
                 <TitleTabItem
                   tab={tab}
-                  index={index}
                   active={tab.id === activeId}
                   closable={titleTabClosable(tab, tabs.length)}
                   canDrag={canDrag}
diff --git a/src/hooks/useAnimatedReorder.test.ts b/src/hooks/useAnimatedReorder.test.ts
new file mode 100644
index 00000000..25bda120
--- /dev/null
+++ b/src/hooks/useAnimatedReorder.test.ts
@@ -0,0 +1,274 @@
+import { createElement, type PointerEvent as ReactPointerEvent } from "react";
+import { renderToString } from "react-dom/server";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useAnimatedReorder } from "./useAnimatedReorder";
+
+const ids = ["sessions", "changes", "explorer"];
+
+function tabAt(left: number, top: number, parentElement: HTMLElement) {
+  const captured = new Set<number>();
+  return {
+    parentElement,
+    getBoundingClientRect: () => ({
+      left,
+      right: left + 100,
+      width: 100,
+      top,
+      bottom: top + 32,
+      height: 32,
+    }),
+    style: {
+      transform: "",
+      transition: "",
+      removeProperty(key: "transform" | "transition") {
+        this[key] = "";
+      },
+    },
+    dataset: {} as Record<string, string>,
+    setPointerCapture: (id: number) => captured.add(id),
+    hasPointerCapture: (id: number) => captured.has(id),
+    releasePointerCapture: (id: number) => captured.delete(id),
+  };
+}
+
+let browser: EventTarget;
+
+function pointer(type: string, clientX: number, pointerId = 1) {
+  browser.dispatchEvent(
+    Object.assign(new Event(type), { clientX, clientY: clientX, pointerId }),
+  );
+}
+
+function setup(reducedMotion = false, axis: "x" | "y" = "x") {
+  Object.assign(browser, { matchMedia: () => ({ matches: reducedMotion }) });
+  const onReorder = vi.fn();
+  let reorder!: ReturnType<typeof useAnimatedReorder<string>>;
+  // Render the real hook to obtain its gesture interface without mocking React.
+  // Mount/unmount effects and native click targeting need a browser check.
+  function Probe() {
+    reorder = useAnimatedReorder(ids, onReorder, axis);
+    return null;
+  }
+  renderToString(createElement(Probe));
+  const scroller = { scrollLeft: 0, scrollTop: 0, parentElement: null };
+  const tabs = [
+    [0, 0],
+    [100, 33],
+    [200, 66],
+  ].map(([left, top]) => tabAt(left, top, scroller as unknown as HTMLElement));
+  tabs.forEach((tab, index) =>
+    reorder.setItemRef(ids[index], tab as unknown as HTMLElement),
+  );
+  const press = (index = 0, pointerId = 1) =>
+    reorder.onItemPointerDown(ids[index], {
+      button: 0,
+      clientX: index * 100 + 50,
+      clientY: index * 33 + 16,
+      pointerId,
+    } as ReactPointerEvent);
+  return { reorder, tabs, onReorder, press, scroller };
+}
+
+beforeEach(() => {
+  vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "performance"] });
+  browser = Object.assign(new EventTarget(), {
+    getComputedStyle: () => ({
+      getPropertyValue: (name: string) =>
+        name === "--motion-reorder-duration"
+          ? "160ms"
+          : "cubic-bezier(0.22, 1, 0.36, 1)",
+    }),
+    getSelection: () => null,
+    clearTimeout,
+    requestAnimationFrame: (callback: () => void) => setTimeout(callback, 16),
+    cancelAnimationFrame: clearTimeout,
+  });
+  const classes = new Set<string>();
+  vi.stubGlobal("window", browser);
+  vi.stubGlobal("document", {
+    body: { style: { cursor: "" } },
+    documentElement: {
+      classList: {
+        add: (name: string) => classes.add(name),
+        remove: (name: string) => classes.delete(name),
+      },
+    },
+  });
+});
+
+afterEach(() => {
+  browser.dispatchEvent(new Event("blur"));
+  vi.runAllTimers();
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+describe("workspace tab gestures", () => {
+  it.each([
+    ["x", 150, 100, "translate3d(200px, 0, 0)"],
+    ["y", 49, 33, "translate3d(0, 66px, 0)"],
+  ] as const)(
+    "keeps the dragged item under the pointer when scrolling on %s",
+    (axis, position, scroll, transform) => {
+      const { press, tabs, scroller, onReorder } = setup(false, axis);
+      press();
+      pointer("pointermove", position);
+      vi.advanceTimersByTime(16);
+      if (axis === "x") scroller.scrollLeft = scroll;
+      else scroller.scrollTop = scroll;
+      browser.dispatchEvent(new Event("scroll"));
+      vi.advanceTimersByTime(16);
+      expect(tabs[0].style.transform).toBe(transform);
+      pointer("pointerup", position);
+      vi.runAllTimers();
+      expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+        ["changes", "explorer", "sessions"],
+        "sessions",
+      );
+    },
+  );
+
+  it("releases drag feedback immediately while the drop animation finishes", () => {
+    const { press, tabs, onReorder } = setup();
+    press();
+    pointer("pointermove", 180);
+    vi.advanceTimersByTime(16);
+    expect(tabs[0].dataset.dragging).toBe("true");
+    pointer("pointerup", 180);
+    expect(tabs[0].dataset.dragging).toBeUndefined();
+    expect(tabs[0].hasPointerCapture(1)).toBe(false);
+    expect(document.body.style.cursor).toBe("");
+    expect(onReorder).not.toHaveBeenCalled();
+    vi.runAllTimers();
+    expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+      ["changes", "sessions", "explorer"],
+      "sessions",
+    );
+  });
+
+  it("previews and reorders vertical project rows", () => {
+    const { press, tabs, onReorder } = setup(false, "y");
+    press();
+    pointer("pointermove", 60);
+    vi.advanceTimersByTime(16);
+    expect(tabs[0].style.transform).toBe("translate3d(0, 44px, 0)");
+    expect(tabs[1].style.transform).toBe("translate3d(0, -33px, 0)");
+    expect(onReorder).not.toHaveBeenCalled();
+    pointer("pointerup", 90);
+    vi.runAllTimers();
+    expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+      ["changes", "explorer", "sessions"],
+      "sessions",
+    );
+  });
+
+  it("preserves button clicks below the drag threshold", () => {
+    const { press, tabs, reorder, onReorder } = setup();
+    press();
+    expect(tabs[0].hasPointerCapture(1)).toBe(false);
+    pointer("pointermove", 53);
+    expect(tabs[0].hasPointerCapture(1)).toBe(false);
+    pointer("pointerup", 53);
+    expect(reorder.consumeClick()).toBe(false);
+    expect(onReorder).not.toHaveBeenCalled();
+  });
+
+  it("reorders on drop and permits a fresh click immediately afterwards", () => {
+    const { press, tabs, reorder, onReorder } = setup();
+    press();
+    pointer("pointermove", 160);
+    expect(tabs[0].hasPointerCapture(1)).toBe(true);
+    expect(onReorder).not.toHaveBeenCalled();
+    pointer("pointerup", 160);
+    expect(reorder.consumeClick()).toBe(true);
+    vi.runAllTimers();
+    expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+      ["changes", "sessions", "explorer"],
+      "sessions",
+    );
+    expect(tabs[0].hasPointerCapture(1)).toBe(false);
+    press(2);
+    pointer("pointerup", 250);
+    expect(reorder.consumeClick()).toBe(false);
+  });
+
+  it.each([20, 140])(
+    "accepts a fresh click started during settling and released after %i ms",
+    (held) => {
+      const { press, reorder, onReorder } = setup();
+      press();
+      pointer("pointermove", 160);
+      pointer("pointerup", 160);
+      expect(reorder.consumeClick()).toBe(true);
+      vi.advanceTimersByTime(60);
+      press(2);
+      vi.advanceTimersByTime(held);
+      pointer("pointerup", 250);
+      expect(reorder.consumeClick()).toBe(false);
+      vi.runAllTimers();
+      expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+        ["changes", "sessions", "explorer"],
+        "sessions",
+      );
+    },
+  );
+
+  it("previews the latest pointer position and makes room before committing", () => {
+    const { press, tabs, onReorder } = setup();
+    press();
+    pointer("pointermove", 100);
+    pointer("pointermove", 180);
+    vi.advanceTimersByTime(16);
+    expect(tabs[0].style.transform).toBe("translate3d(130px, 0, 0)");
+    expect(tabs[1].style.transform).toBe("translate3d(-100px, 0, 0)");
+    expect(tabs[2].style.transform).toBe("translate3d(0px, 0, 0)");
+    expect(onReorder).not.toHaveBeenCalled();
+  });
+
+  it("moves the last tab to the first slot when released beyond the left edge", () => {
+    const { press, onReorder } = setup();
+    press(2);
+    pointer("pointerup", -100);
+    vi.runAllTimers();
+    expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+      ["explorer", "sessions", "changes"],
+      "explorer",
+    );
+  });
+
+  it.each(["Escape", "pointercancel", "blur"])(
+    "cancels a drag on %s",
+    (reason) => {
+      const { press, tabs, onReorder } = setup();
+      press();
+      pointer("pointermove", 250);
+      vi.advanceTimersByTime(16);
+      const event =
+        reason === "Escape"
+          ? Object.assign(new Event("keydown", { cancelable: true }), {
+              key: "Escape",
+            })
+          : new Event(reason);
+      browser.dispatchEvent(event);
+      pointer("pointerup", 250);
+      vi.runAllTimers();
+      expect(onReorder).not.toHaveBeenCalled();
+      expect(tabs.every((tab) => tab.style.transform === "")).toBe(true);
+      expect(tabs[0].hasPointerCapture(1)).toBe(false);
+      expect(document.body.style.cursor).toBe("");
+      if (reason === "Escape") expect(event.defaultPrevented).toBe(true);
+    },
+  );
+
+  it("commits a fast drop without waiting for animation in reduced motion", () => {
+    const { press, tabs, onReorder } = setup(true);
+    press();
+    pointer("pointerup", 250);
+    expect(onReorder).toHaveBeenCalledExactlyOnceWith(
+      ["changes", "explorer", "sessions"],
+      "sessions",
+    );
+    expect(tabs.every((tab) => tab.style.transform === "")).toBe(true);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});
diff --git a/src/hooks/useAnimatedReorder.ts b/src/hooks/useAnimatedReorder.ts
new file mode 100644
index 00000000..2ad0617a
--- /dev/null
+++ b/src/hooks/useAnimatedReorder.ts
@@ -0,0 +1,260 @@
+import {
+  useCallback,
+  useLayoutEffect,
+  useRef,
+  useState,
+  type PointerEvent,
+} from "react";
+import { flushSync } from "react-dom";
+import { setGrabbing, suppressTextSelection } from "../lib/drag";
+import { reorderMotion } from "../lib/motion";
+import { moveItem } from "../lib/reorder";
+
+/** Direct manipulation for a row or column of equal-sized items. */
+export function useAnimatedReorder<T extends string>(
+  ids: T[],
+  onReorder: (ids: T[], movedId: T) => void,
+  axis: "x" | "y" = "x",
+) {
+  const nodes = useRef(new Map<T, HTMLElement>());
+  const [draggingId, setDraggingId] = useState<T | null>(null);
+  const latest = useRef({ ids, onReorder });
+  useLayoutEffect(() => {
+    latest.current = { ids, onReorder };
+  }, [ids, onReorder]);
+  const cleanup = useRef<(() => void) | null>(null);
+  const finishSettling = useRef<(() => void) | null>(null);
+  const suppressClickUntil = useRef(0);
+  const orderKey = ids.join("\0");
+
+  useLayoutEffect(() => () => cleanup.current?.(), [orderKey]);
+
+  const setItemRef = useCallback((id: T, node: HTMLElement | null) => {
+    if (node) nodes.current.set(id, node);
+    else nodes.current.delete(id);
+  }, []);
+
+  const onItemPointerDown = useCallback(
+    (id: T, event: PointerEvent) => {
+      if (event.button !== 0) return;
+      finishSettling.current?.();
+      if (cleanup.current) return;
+      // A new press is a click candidate, even immediately after a previous drag.
+      suppressClickUntil.current = 0;
+      const items = latest.current.ids;
+      const from = items.indexOf(id);
+      if (items.length < 2 || from < 0) return;
+      const elements = items.map((item) => nodes.current.get(item));
+      if (elements.some((element) => !element)) return;
+      const tabs = elements as HTMLElement[];
+      // Measure once: animated positions must not affect the drop calculation.
+      const rects = tabs.map((element) => {
+        const rect = element.getBoundingClientRect();
+        const start = axis === "x" ? rect.left : rect.top;
+        const size = axis === "x" ? rect.width : rect.height;
+        return { start, size, end: start + size };
+      });
+      const transform = (offset: number) =>
+        axis === "x"
+          ? `translate3d(${offset}px, 0, 0)`
+          : `translate3d(0, ${offset}px, 0)`;
+      const coordinate = axis === "x" ? "clientX" : "clientY";
+      const handle = tabs[from];
+      const scrollProperty = axis === "x" ? "scrollLeft" : "scrollTop";
+      const scrollParents: { element: HTMLElement; start: number }[] = [];
+      for (
+        let element = handle.parentElement;
+        element;
+        element = element.parentElement
+      ) {
+        scrollParents.push({ element, start: element[scrollProperty] });
+      }
+      const pointerId = event.pointerId;
+      const startPosition = event[coordinate];
+      const reducedMotion = window.matchMedia(
+        "(prefers-reduced-motion: reduce)",
+      ).matches;
+      const { duration: motionDuration, easing } = reorderMotion();
+      const duration = reducedMotion ? 0 : motionDuration;
+      const transition = `transform ${duration}ms ${easing}`;
+      let restoreSelection: (() => void) | undefined;
+      let active = false;
+      let settling = false;
+      let destination = from;
+      let frame = 0;
+      let pointerPosition = startPosition;
+      let finishTimer: ReturnType<typeof setTimeout> | undefined;
+
+      function releasePointer() {
+        for (const element of tabs) delete element.dataset.reordering;
+        delete handle.dataset.dragging;
+        if (restoreSelection) {
+          restoreSelection();
+          restoreSelection = undefined;
+          setGrabbing(false);
+        }
+        if (handle.hasPointerCapture(pointerId))
+          handle.releasePointerCapture(pointerId);
+      }
+
+      function reset() {
+        window.removeEventListener("pointerdown", onNextPointerDown, true);
+        window.removeEventListener("pointermove", onMove);
+        window.removeEventListener("pointerup", onUp);
+        window.removeEventListener("pointercancel", onCancel);
+        window.removeEventListener("keydown", onKey);
+        window.removeEventListener("blur", onCancel);
+        window.removeEventListener("scroll", onScroll, true);
+        window.clearTimeout(finishTimer);
+        window.cancelAnimationFrame(frame);
+        for (const element of tabs) {
+          element.style.removeProperty("transition");
+          element.style.removeProperty("transform");
+          delete element.dataset.settling;
+        }
+        releasePointer();
+        if (active) suppressClickUntil.current = performance.now() + 400;
+        cleanup.current = null;
+        finishSettling.current = null;
+        setDraggingId(null);
+      }
+
+      function preview(to: number) {
+        const reordered = moveItem(items, from, to);
+        for (let index = 0; index < tabs.length; index++) {
+          if (index === from) continue;
+          const slot = reordered.indexOf(items[index]);
+          tabs[index].style.transform = transform(
+            rects[slot].start - rects[index].start,
+          );
+        }
+      }
+
+      function paint(moveHandle = true) {
+        frame = 0;
+        // Scroll moves the original slots without changing their layout order.
+        const scrollOffset = scrollParents.reduce(
+          (offset, { element, start }) =>
+            offset + element[scrollProperty] - start,
+          0,
+        );
+        const offset = Math.max(
+          rects[0].start - rects[from].start,
+          Math.min(
+            pointerPosition - startPosition + scrollOffset,
+            rects[rects.length - 1].end - rects[from].end,
+          ),
+        );
+        if (moveHandle) {
+          handle.style.transform = transform(offset);
+        }
+        const center = rects[from].start + rects[from].size / 2 + offset;
+        const next = rects.reduce((nearest, rect, index) => {
+          const distance = Math.abs(center - rect.start - rect.size / 2);
+          const previous = rects[nearest];
+          return distance <
+            Math.abs(center - previous.start - previous.size / 2)
+            ? index
+            : nearest;
+        }, from);
+        if (next !== destination) {
+          destination = next;
+          preview(next);
+        }
+      }
+
+      function onScroll() {
+        if (active && !settling && !frame)
+          frame = window.requestAnimationFrame(() => paint());
+      }
+
+      function onMove(ev: globalThis.PointerEvent) {
+        if (ev.pointerId !== pointerId || settling) return;
+        pointerPosition = ev[coordinate];
+        if (!active) {
+          if (Math.abs(pointerPosition - startPosition) < 5) return;
+          active = true;
+          setDraggingId(id);
+          handle.setPointerCapture(pointerId);
+          restoreSelection = suppressTextSelection();
+          setGrabbing(true);
+          for (const element of tabs) {
+            element.style.transition = transition;
+            element.dataset.reordering = "true";
+          }
+          handle.style.transition = "none";
+          handle.dataset.dragging = "true";
+        }
+        // Keep the newest position when several input events arrive in one frame.
+        if (!frame) frame = window.requestAnimationFrame(() => paint());
+      }
+
+      function stop(commit: boolean) {
+        if (settling) return;
+        if (!active) {
+          reset();
+          return;
+        }
+        settling = true;
+        window.cancelAnimationFrame(frame);
+        if (commit) paint(false);
+        handle.dataset.settling = "true";
+        releasePointer();
+        suppressClickUntil.current = performance.now() + duration + 400;
+        const to = commit ? destination : from;
+        preview(to);
+        handle.style.transition = transition;
+        handle.style.transform = transform(rects[to].start - rects[from].start);
+        const finish = () => {
+          // Clear the preview and commit the order before the next browser paint.
+          flushSync(() => {
+            reset();
+            if (commit && to !== from)
+              latest.current.onReorder(moveItem(items, from, to), id);
+          });
+        };
+        finishSettling.current = finish;
+        if (duration === 0) finish();
+        else {
+          // Commit before a new press can change the list, including close buttons.
+          window.addEventListener("pointerdown", onNextPointerDown, true);
+          finishTimer = setTimeout(finish, duration);
+        }
+      }
+
+      function onNextPointerDown() {
+        finishSettling.current?.();
+      }
+
+      function onUp(ev: globalThis.PointerEvent) {
+        if (ev.pointerId !== pointerId) return;
+        onMove(ev);
+        stop(true);
+      }
+      function onCancel() {
+        stop(false);
+      }
+      function onKey(ev: KeyboardEvent) {
+        if (ev.key === "Escape") {
+          ev.preventDefault();
+          stop(false);
+        }
+      }
+
+      cleanup.current = reset;
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("pointerup", onUp);
+      window.addEventListener("pointercancel", onCancel);
+      window.addEventListener("keydown", onKey);
+      window.addEventListener("blur", onCancel);
+      window.addEventListener("scroll", onScroll, true);
+    },
+    [axis],
+  );
+
+  const consumeClick = useCallback(
+    () => performance.now() < suppressClickUntil.current,
+    [],
+  );
+  return { draggingId, setItemRef, onItemPointerDown, consumeClick };
+}
diff --git a/src/hooks/useAnimatedReorderConcurrency.test.ts b/src/hooks/useAnimatedReorderConcurrency.test.ts
new file mode 100644
index 00000000..539a4686
--- /dev/null
+++ b/src/hooks/useAnimatedReorderConcurrency.test.ts
@@ -0,0 +1,122 @@
+// @vitest-environment happy-dom
+import { act, createElement, startTransition, Suspense } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useAnimatedReorder } from "./useAnimatedReorder";
+
+let container: HTMLDivElement;
+let root: Root;
+
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
+  document.documentElement.style.setProperty(
+    "--motion-reorder-duration",
+    "160ms",
+  );
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  document.documentElement.style.removeProperty("--motion-reorder-duration");
+  vi.clearAllTimers();
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+function pointer(target: EventTarget, type: string, clientX: number) {
+  act(() => {
+    target.dispatchEvent(
+      new PointerEvent(type, {
+        bubbles: true,
+        button: 0,
+        pointerId: 1,
+        clientX,
+        clientY: 16,
+      }),
+    );
+  });
+}
+
+describe("reordering during an uncommitted render", () => {
+  it.each(["before the drag", "while settling"])(
+    "uses the committed order and callback when rendering suspends %s",
+    async (timing) => {
+      const onReorder = vi.fn();
+      const pendingOnReorder = vi.fn();
+      const pendingRender = vi.fn();
+      const suspended = new Promise<never>(() => {});
+
+      function List({ pending }: { pending: boolean }) {
+        const ids = pending ? ["a", "b", "c", "pending"] : ["a", "b", "c"];
+        const reorder = useAnimatedReorder(
+          ids,
+          pending ? pendingOnReorder : onReorder,
+        );
+        if (pending) {
+          pendingRender();
+          throw suspended;
+        }
+        return createElement(
+          "div",
+          { "data-list": true },
+          ids.map((id, index) =>
+            createElement(
+              "button",
+              {
+                key: id,
+                ref: (node: HTMLButtonElement | null) => {
+                  if (node) {
+                    node.getBoundingClientRect = () =>
+                      new DOMRect(index * 100, 0, 100, 32);
+                    const captured = new Set<number>();
+                    node.setPointerCapture = (pointerId) => {
+                      captured.add(pointerId);
+                    };
+                    node.hasPointerCapture = (pointerId) =>
+                      captured.has(pointerId);
+                    node.releasePointerCapture = (pointerId) => {
+                      captured.delete(pointerId);
+                    };
+                  }
+                  reorder.setItemRef(id, node);
+                },
+                onPointerDown: (event) => reorder.onItemPointerDown(id, event),
+              },
+              id,
+            ),
+          ),
+        );
+      }
+
+      const render = (pending: boolean) =>
+        root.render(
+          createElement(
+            Suspense,
+            { fallback: "Loading" },
+            createElement(List, { pending }),
+          ),
+        );
+      const drag = () => {
+        pointer(container.querySelector("button")!, "pointerdown", 50);
+        pointer(window, "pointermove", 160);
+        pointer(window, "pointerup", 160);
+      };
+
+      await act(async () => render(false));
+      if (timing === "while settling") drag();
+      await act(async () => startTransition(() => render(true)));
+      expect(pendingRender).toHaveBeenCalled();
+      expect(container.querySelector("[data-list]")?.textContent).toBe("abc");
+      if (timing === "before the drag") drag();
+      act(() => vi.advanceTimersByTime(160));
+
+      expect(onReorder).toHaveBeenCalledExactlyOnceWith(["b", "a", "c"], "a");
+      expect(pendingOnReorder).not.toHaveBeenCalled();
+    },
+  );
+});
diff --git a/src/index.css b/src/index.css
index e196bd89..58c67b03 100644
--- a/src/index.css
+++ b/src/index.css
@@ -26,6 +26,9 @@
 }
 
 :root {
+  --motion-reorder-duration: 160ms;
+  --motion-feedback-duration: 120ms;
+  --motion-ease-out: cubic-bezier(0.22, 1, 0.36, 1);
   --theme-hue: 240;
   --theme-saturation: 0%;
   --sidebar-opacity: 0.85;
@@ -107,6 +110,60 @@ html.has-native-glass:not(.theme-light) #root {
   background: transparent;
 }
 
+.reorder-item {
+  transform: translate3d(0, 0, 0);
+  will-change: transform;
+}
+
+.reorder-item:is([data-dragging], [data-settling]) {
+  z-index: 10;
+}
+
+.tab-motion,
+.tab-motion > button {
+  transition:
+    background-color var(--motion-feedback-duration) var(--motion-ease-out),
+    color var(--motion-feedback-duration) var(--motion-ease-out),
+    opacity var(--motion-feedback-duration) var(--motion-ease-out);
+}
+
+.tab-motion[data-reordering] [data-no-drag] {
+  visibility: hidden;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .tab-motion,
+  .tab-motion > button {
+    transition: none;
+  }
+}
+
+.workspace-tab:not([data-reordering])
+  > button:not([aria-selected="true"]):hover,
+.workspace-tab[data-dragging] > button:not([aria-selected="true"]),
+.project-reorder-item:not([data-reordering], [data-selected]):hover,
+.project-reorder-item[data-dragging]:not([data-selected]) {
+  background: color-mix(in srgb, var(--color-content) 5%, transparent);
+  color: var(--color-content);
+}
+
+/* Keep project controls from appearing as rows pass beneath the pointer. */
+.project-reorder-item[data-reordering] [data-no-drag] {
+  visibility: hidden;
+}
+
+.project-reorder-item[data-reordering] > button:first-of-type {
+  padding-right: 0;
+}
+
+.project-reorder-item[data-reordering] .project-card-logo {
+  opacity: 1;
+}
+
+.project-reorder-item[data-reordering] .project-card-stats {
+  display: flex;
+}
+
 .sidebar-glass {
   background: color-mix(in srgb, var(--color-background-base) 90%, black);
 }
diff --git a/src/lib/motion.ts b/src/lib/motion.ts
new file mode 100644
index 00000000..9057e273
--- /dev/null
+++ b/src/lib/motion.ts
@@ -0,0 +1,11 @@
+/** Read the shared CSS tokens so pointer gestures and CSS use the same timing. */
+export function reorderMotion() {
+  const style = window.getComputedStyle(document.documentElement);
+  const duration = style.getPropertyValue("--motion-reorder-duration").trim();
+  const milliseconds =
+    parseFloat(duration) * (duration.endsWith("ms") ? 1 : 1000);
+  return {
+    duration: Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 0,
+    easing: style.getPropertyValue("--motion-ease-out").trim() || "linear",
+  };
+}

From 945d7050fb7ffb989198794ab9da884d00a145cf Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Sun, 13 Sep 2026 20:53:57 +0100
Subject: [PATCH 02/17] Dismiss session notices when continuing

- Clear due reminders and linked update cards when a session continues
- Add coverage for due and future reminder behavior
---
 src/App.tsx                           | 24 +++++++++++++++++++++++-
 src/hooks/useSessionReminders.test.ts | 21 +++++++++++++++++++++
 src/hooks/useSessionReminders.ts      | 14 ++++++++++++++
 3 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/App.tsx b/src/App.tsx
index 21344575..58c3e338 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -3024,6 +3024,21 @@ export default function App({
     sessions.filter((session) => !session.inboxAsk).map((session) => session.id),
   );
 
+  const dismissNoticesForContinuedSession = useCallback(
+    (sessionId: string) => {
+      void sessionReminders.dismissDue(sessionId);
+      const updatedAt = sessionsRef.current.find(
+        (session) => session.id === sessionId,
+      )?.linkedWorkItemUpdateCard?.updatedAt;
+      if (updatedAt == null) return;
+      markLinkedSessionUpdateSeen(sessionId, updatedAt);
+      setLinkedWorkItemUpdateCard(sessionId, (card) =>
+        card?.updatedAt === updatedAt ? undefined : card,
+      );
+    },
+    [sessionReminders.dismissDue, setLinkedWorkItemUpdateCard],
+  );
+
   const onPlaceSessionOnPane = useCallback(
     async (sessionId: string, targetId: string, edge: PaneEdge) => {
       if (sessionId === targetId) return;
@@ -4010,6 +4025,7 @@ export default function App({
                 : s,
             ),
           );
+          dismissNoticesForContinuedSession(sessionId);
           return;
         }
         if (
@@ -4025,6 +4041,7 @@ export default function App({
           flushHarnessEvents();
           return;
         }
+        dismissNoticesForContinuedSession(sessionId);
         const visible = displayAttachments(attachments);
         const cards = userTurnCards(noteCard);
         setSessions((prev) =>
@@ -4111,6 +4128,7 @@ export default function App({
         void cancelHarnessTurn(pendingSwitch.from, sessionId);
       }
 
+      dismissNoticesForContinuedSession(sessionId);
       setSessions((prev) =>
         prev.map((s) => {
           if (s.id !== sessionId) return s;
@@ -4434,7 +4452,11 @@ export default function App({
         }
       })();
     },
-    [enqueueHarnessEvent, flushHarnessEvents],
+    [
+      dismissNoticesForContinuedSession,
+      enqueueHarnessEvent,
+      flushHarnessEvents,
+    ],
   );
 
   const onUpdatePlan = useCallback(
diff --git a/src/hooks/useSessionReminders.test.ts b/src/hooks/useSessionReminders.test.ts
index e27fb521..4ad25169 100644
--- a/src/hooks/useSessionReminders.test.ts
+++ b/src/hooks/useSessionReminders.test.ts
@@ -165,6 +165,27 @@ describe("saved session reminders", () => {
     expect(api.due).toEqual([]);
   });
 
+  it("dismisses the current due reminder when its session continues", async () => {
+    await mount();
+    await act(async () => api.dismissDue(reminder.sessionId));
+    expect(invoke).toHaveBeenCalledWith("reminder_clear", {
+      sessionIds: [reminder.sessionId],
+      expectedDueAt: reminder.dueAt,
+    });
+    expect(api.due).toEqual([]);
+  });
+
+  it("keeps a future reminder when its session continues early", async () => {
+    stored = [{ ...reminder, dueAt: Date.now() + 60_000 }];
+    await mount();
+    invoke.mockClear();
+    await act(async () => api.dismissDue(reminder.sessionId));
+    expect(
+      invoke.mock.calls.some(([command]) => command === "reminder_clear"),
+    ).toBe(false);
+    expect(api.reminders).toEqual(stored);
+  });
+
   it("handles a notification click queued before the window mounted", async () => {
     pending = reminder;
     await mount();
diff --git a/src/hooks/useSessionReminders.ts b/src/hooks/useSessionReminders.ts
index 76653085..c82a43e9 100644
--- a/src/hooks/useSessionReminders.ts
+++ b/src/hooks/useSessionReminders.ts
@@ -26,6 +26,8 @@ export function useSessionReminders(
   const [now, setNow] = useState(Date.now);
   const [error, setError] = useState<string | null>(null);
   const revision = useRef(0);
+  const remindersRef = useRef(reminders);
+  remindersRef.current = reminders;
   const callbacks = useRef({ onOpenSession, ensureSaved });
   callbacks.current = { onOpenSession, ensureSaved };
 
@@ -71,6 +73,17 @@ export function useSessionReminders(
     [refresh],
   );
 
+  const dismissDue = useCallback(
+    async (sessionId: string) => {
+      const reminder = remindersRef.current.find(
+        (item) => item.sessionId === sessionId && item.dueAt <= Date.now(),
+      );
+      if (!reminder) return;
+      await cancel([sessionId], reminder.dueAt);
+    },
+    [cancel],
+  );
+
   const openHere = useCallback(
     async (reminder: ReminderTarget) => {
       try {
@@ -188,6 +201,7 @@ export function useSessionReminders(
     refresh,
     schedule,
     cancel,
+    dismissDue,
     open,
   };
 }

From 9b404e691addf576c6c59b145479cccbc2c49e90 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Sun, 13 Sep 2026 21:11:37 +0100
Subject: [PATCH 03/17] Remove grab cursors from reorderable sidebar items

- Add regression coverage for tabs and folders retaining the default cursor
---
 src/chrome/Sidebar.tsx           | 14 +++-------
 src/chrome/SidebarRename.test.ts | 47 ++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 10 deletions(-)

diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index c6991095..2599be7b 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -534,7 +534,6 @@ function SidebarComponent({
     },
     { axis: "y" },
   );
-  const canDragTabs = visibleTabs.length > 1;
   const showProjectRail = Boolean(onSelectProject && onOpenProject);
   // Settings live in the rail slot, so they keep it visible even when the
   // project rail itself is collapsed.
@@ -1098,7 +1097,7 @@ function SidebarComponent({
       <div
         key={itemId}
         ref={(el) => sortable.setItemRef(itemId, el)}
-        className={`reorder-item workspace-tab relative flex min-w-0 flex-1 touch-none items-stretch ${canDragTabs ? "cursor-grab active:cursor-grabbing" : ""}`}
+        className="reorder-item workspace-tab relative flex min-w-0 flex-1 touch-none items-stretch"
         onPointerDown={(event) => {
           if (event.button !== 0) return;
           sortable.onItemPointerDown(itemId, event);
@@ -1127,10 +1126,8 @@ function SidebarComponent({
             onTabPick(itemId);
           }}
           className={`flex h-6 min-w-0 flex-1 items-center justify-center self-center rounded-md px-2 text-[12px] leading-none ${
-            active
-              ? "bg-content/10 text-content"
-              : "text-content/50"
-          } ${canDragTabs ? "cursor-grab active:cursor-grabbing" : ""}`}
+            active ? "bg-content/10 text-content" : "text-content/50"
+          }`}
         >
           {isChangesTab && hasChangeStats ? (
             <DiffStat additions={changeAdditions} deletions={changeDeletions} />
@@ -1457,7 +1454,6 @@ function SidebarComponent({
                                   "folder",
                                   entry.folder.id,
                                 )}
-                                canReorder={visibleFolderIds.length > 1}
                                 busy={entry.sessions.some((session) =>
                                   busySessionIds.has(session.id),
                                 )}
@@ -2114,7 +2110,6 @@ function FolderRow({
   sessions,
   expanded,
   dropTarget,
-  canReorder = false,
   busy,
   done,
   needsApproval,
@@ -2128,7 +2123,6 @@ function FolderRow({
   sessions: SessionSummary[];
   expanded: boolean;
   dropTarget: boolean;
-  canReorder?: boolean;
   busy: boolean;
   done: boolean;
   needsApproval: boolean;
@@ -2157,7 +2151,7 @@ function FolderRow({
       }}
       className={`group relative flex w-full touch-none items-center gap-1.5 px-2 h-8 text-left ${
         expanded ? "rounded-md" : ""
-      } ${canReorder ? "cursor-grab active:cursor-grabbing" : ""} ${
+      } ${
         dropTarget
           ? "text-content"
           : expanded
diff --git a/src/chrome/SidebarRename.test.ts b/src/chrome/SidebarRename.test.ts
index 2d1cc553..67806784 100644
--- a/src/chrome/SidebarRename.test.ts
+++ b/src/chrome/SidebarRename.test.ts
@@ -225,6 +225,53 @@ describe("sidebar session rename", () => {
   });
 });
 
+describe("sidebar reorder affordances", () => {
+  it("keeps the default cursor on reorderable tabs and folders", () => {
+    props.sessions = [
+      props.sessions[0],
+      {
+        ...props.sessions[0],
+        id: "session-2",
+        title: formatSessionTitle("codex", "Second conversation"),
+      },
+    ];
+    localStorage.setItem(
+      "monocode.sessionFolders",
+      JSON.stringify({
+        "/workspace/project": [
+          {
+            id: "folder-1",
+            name: "Folder one",
+            sessionIds: ["session-1"],
+            collapsed: false,
+          },
+          {
+            id: "folder-2",
+            name: "Folder two",
+            sessionIds: ["session-2"],
+            collapsed: false,
+          },
+        ],
+      }),
+    );
+
+    act(() => render());
+
+    const tabs = container.querySelectorAll<HTMLElement>('[role="tab"]');
+    expect(tabs).toHaveLength(3);
+    for (const tab of tabs) {
+      expect(tab.className).not.toContain("cursor-grab");
+      expect(tab.parentElement?.className).not.toContain("cursor-grab");
+    }
+    for (const name of ["Folder one", "Folder two"]) {
+      expect(
+        container.querySelector<HTMLButtonElement>(`button[title="${name}"]`)!
+          .className,
+      ).not.toContain("cursor-grab");
+    }
+  });
+});
+
 describe("sidebar pinned sessions", () => {
   it("renders them as a collapsible folder-style group without a divider", () => {
     props.sessions = [

From aa577bcd0e6dc488135b2862c758fc4dee672890 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 06:08:22 +0100
Subject: [PATCH 04/17] Prefetch and cache closed sessions for faster reopening

- Add hover/press prefetching with bounded memory-aware session caching
- Prevent ghost tabs and handle session restore races safely
- Add coverage for prefetch, cache eviction, and tab lookup
---
 src/App.tsx                        | 151 +++++++++++++++++++++++++++--
 src/chrome/Sidebar.tsx             |  34 ++++++-
 src/chrome/SidebarRename.test.ts   |  32 ++++++
 src/lib/sessionCache.test.ts       |  32 +++++-
 src/lib/sessionCache.ts            |  57 ++++++++++-
 src/lib/workspaceTabGroups.test.ts |  15 +++
 src/lib/workspaceTabGroups.ts      |  10 ++
 7 files changed, 317 insertions(+), 14 deletions(-)

diff --git a/src/App.tsx b/src/App.tsx
index 58c3e338..51a9ffff 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -223,6 +223,7 @@ import {
 import {
   applyPlaceSessionOnPane,
   filterTabsForProject,
+  findOpenSessionTab,
   planWorkspaceTabClose,
   workspaceTabCwd,
   focusedWorkspaceTabCwd,
@@ -271,6 +272,7 @@ import {
   upsertSession,
   type SessionSummary,
 } from "./lib/sessionStore";
+import { rememberLoadedSession } from "./lib/sessionCache";
 import { syncDockBadge } from "./lib/dockBadge";
 import { liveAgentsFromSessions } from "./lib/liveAgents";
 import { hiddenApprovalNotices } from "./lib/approvalToast";
@@ -778,6 +780,11 @@ export default function App({
   const observedSessions = useRef(new Map<string, Session>());
   const pendingPersist = useRef(new Map<string, Session>());
   const removingSessionIds = useRef(new Set<string>());
+  const loadedSessionCache = useRef(new Map<string, Session>());
+  const sessionLoads = useRef(new Map<string, Promise<Session | null>>());
+  const sessionLoadEpochs = useRef(new Map<string, number>());
+  const openingSessionIds = useRef(new Set<string>());
+  const activeSessionPrefetch = useRef<Promise<Session | null> | null>(null);
   // Tokens arrive many times per frame; apply them once so React/markdown aren't
   // recomputed for every delta.
   const harnessQueued = useRef(new Map<string, HarnessEvent[]>());
@@ -1378,16 +1385,24 @@ export default function App({
     for (const session of sessions) {
       if (session.inboxAsk) visibleIds.add(session.id);
     }
+    for (const sessionId of visibleIds) {
+      openingSessionIds.current.delete(sessionId);
+      loadedSessionCache.current.delete(sessionId);
+    }
     const keepUnseen = liveAgentsEnabled;
     const idleDetached = sessions.filter(
       (session) =>
         !visibleIds.has(session.id) &&
         !session.busy &&
+        !openingSessionIds.current.has(session.id) &&
         !(keepUnseen && unseenFinishedRef.current.has(session.id)),
     );
     if (idleDetached.length === 0) return;
     for (const session of idleDetached) {
       if (skipForgetSessionIds.current.has(session.id)) continue;
+      if (shouldPersistSession(session)) {
+        rememberLoadedSession(loadedSessionCache.current, session);
+      }
       persistSession(session);
       for (const harness of sessionChildHarnesses(session)) {
         void forgetHarnessSession(harness, session.id);
@@ -1398,6 +1413,7 @@ export default function App({
         (session) =>
           visibleIds.has(session.id) ||
           session.busy ||
+          openingSessionIds.current.has(session.id) ||
           (keepUnseen && unseenFinishedRef.current.has(session.id)) ||
           skipForgetSessionIds.current.has(session.id),
       ),
@@ -2684,10 +2700,13 @@ export default function App({
   );
 
   const focusOpenSession = useCallback((sessionId: string) => {
-    const tab = tabsRef.current.find((entry) =>
-      leafIds(entry.layout).includes(sessionId),
+    const tab = findOpenSessionTab(
+      tabsRef.current,
+      sessionsRef.current,
+      sessionId,
     );
     if (!tab) return false;
+    loadedSessionCache.current.delete(sessionId);
     setActiveTabId(tab.id);
     setTabs((prev) =>
       prev.map((entry) =>
@@ -2740,6 +2759,54 @@ export default function App({
     return true;
   }, []);
 
+  const invalidateLoadedSession = useCallback((sessionId: string) => {
+    openingSessionIds.current.delete(sessionId);
+    loadedSessionCache.current.delete(sessionId);
+    sessionLoads.current.delete(sessionId);
+    sessionLoadEpochs.current.set(
+      sessionId,
+      (sessionLoadEpochs.current.get(sessionId) ?? 0) + 1,
+    );
+  }, []);
+
+  const loadStoredSession = useCallback(
+    (sessionId: string): Promise<Session | null> => {
+      const cached = loadedSessionCache.current.get(sessionId);
+      if (cached) {
+        // The cache owns closed sessions only. Transfer this reference into
+        // live state instead of retaining a stale duplicate while it changes.
+        loadedSessionCache.current.delete(sessionId);
+        return Promise.resolve(cached);
+      }
+
+      const pending = sessionLoads.current.get(sessionId);
+      if (pending) return pending;
+
+      const epoch = sessionLoadEpochs.current.get(sessionId) ?? 0;
+      const loading = getSession(sessionId)
+        .then((loaded) => {
+          if (
+            !loaded ||
+            removingSessionIds.current.has(sessionId) ||
+            (sessionLoadEpochs.current.get(sessionId) ?? 0) !== epoch
+          ) {
+            return null;
+          }
+          const restored = restoreSessionCheckout(loaded);
+          return restored;
+        })
+        .catch(() => null);
+      sessionLoads.current.set(sessionId, loading);
+      void loading.then(() => {
+        if (sessionLoads.current.get(sessionId) === loading) {
+          sessionLoads.current.delete(sessionId);
+        }
+      });
+      return loading;
+    },
+    [],
+  );
+
   const ensureOpenSession = useCallback(
     async (sessionId: string): Promise<Session | null> => {
       const open = sessionsRef.current.find(
@@ -2747,12 +2814,18 @@ export default function App({
       );
       if (open) return open;
 
-      const loaded = await getSession(sessionId).catch(() => null);
-      if (!loaded) {
+      openingSessionIds.current.add(sessionId);
+      const restored = await loadStoredSession(sessionId);
+      if (!restored || removingSessionIds.current.has(sessionId)) {
+        openingSessionIds.current.delete(sessionId);
         void refreshHistory(sidebarCwd);
         return null;
       }
-      const restored = await restoreSessionCheckout(loaded);
+      loadedSessionCache.current.delete(sessionId);
+      const appeared = sessionsRef.current.find(
+        (session) => session.id === sessionId,
+      );
+      if (appeared) return appeared;
       if (restored.providerSessionId && isLiveHarness(restored.harness)) {
         bindHarnessSession(
           restored.harness,
@@ -2769,7 +2842,36 @@ export default function App({
       }
       return restored;
     },
-    [refreshHistory, sidebarCwd],
+    [loadStoredSession, refreshHistory, sidebarCwd],
+  );
+
+  const onPrefetchHistorySession = useCallback(
+    (sessionId: string) => {
+      if (
+        removingSessionIds.current.has(sessionId) ||
+        sessionsRef.current.some((session) => session.id === sessionId) ||
+        loadedSessionCache.current.has(sessionId) ||
+        sessionLoads.current.has(sessionId) ||
+        activeSessionPrefetch.current
+      ) {
+        return;
+      }
+      const loading = loadStoredSession(sessionId);
+      activeSessionPrefetch.current = loading;
+      void loading.then((loaded) => {
+        if (
+          loaded &&
+          !removingSessionIds.current.has(sessionId) &&
+          !sessionsRef.current.some((session) => session.id === sessionId)
+        ) {
+          rememberLoadedSession(loadedSessionCache.current, loaded);
+        }
+        if (activeSessionPrefetch.current === loading) {
+          activeSessionPrefetch.current = null;
+        }
+      });
+    },
+    [loadStoredSession],
   );
 
   const revealLinkedSessionUpdate = useCallback(
@@ -2965,6 +3067,13 @@ export default function App({
       }
       const session = await ensureOpenSession(sessionId);
       if (!session || session.inboxAsk) return;
+      // A previous race may have left this tab pointing at a parked session.
+      // Once the session is restored, reuse that tab instead of creating a
+      // duplicate and leave the broken pane behind.
+      if (focusOpenSession(sessionId)) {
+        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+        return;
+      }
       if (replaceBlankPaneWithSession(session)) {
         if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
         return;
@@ -3101,6 +3210,7 @@ export default function App({
     async (sessionId: string, displayTitle: string) => {
       const trimmed = displayTitle.trim();
       if (!trimmed) return;
+      invalidateLoadedSession(sessionId);
 
       const open = sessionsRef.current.find(
         (session) => session.id === sessionId,
@@ -3111,6 +3221,7 @@ export default function App({
         setSessions((prev) =>
           prev.map((session) => (session.id === sessionId ? updated : session)),
         );
+        loadedSessionCache.current.delete(sessionId);
         persistSession(updated);
       } else {
         const restored = await getSession(sessionId).catch(() => null);
@@ -3122,12 +3233,16 @@ export default function App({
           ...restored,
           title: formatSessionTitle(restored.harness, trimmed),
         };
-        await upsertSession(updated).catch(() => undefined);
-        lastPersisted.current.set(sessionId, persistFingerprint(updated));
+        const saved = await upsertSession(updated).catch(() => null);
+        if (saved) {
+          const cached = restoreSessionCheckout(updated);
+          rememberLoadedSession(loadedSessionCache.current, cached);
+          lastPersisted.current.set(sessionId, persistFingerprint(updated));
+        }
       }
       void refreshHistory(sidebarCwd);
     },
-    [persistSession, refreshHistory, sidebarCwd],
+    [invalidateLoadedSession, persistSession, refreshHistory, sidebarCwd],
   );
 
   const onRemoveHistorySession = useCallback(
@@ -3153,6 +3268,7 @@ export default function App({
         return false;
 
       removingSessionIds.current.add(sessionId);
+      invalidateLoadedSession(sessionId);
       pendingPersist.current.delete(sessionId);
       let savedSummary: SessionSummary | undefined;
       try {
@@ -3249,6 +3365,9 @@ export default function App({
               ),
             );
             if (mode === "archive") {
+              if (latest && shouldPersistSession(latest)) {
+                rememberLoadedSession(loadedSessionCache.current, latest);
+              }
               const archived =
                 savedSummary ??
                 summary ??
@@ -3280,6 +3399,7 @@ export default function App({
     [
       activateTab,
       history,
+      invalidateLoadedSession,
       refreshHistory,
       sidebarCwd,
       stopSessionForRemoval,
@@ -3629,6 +3749,13 @@ export default function App({
       );
 
       if (options.purgeData) {
+        const cachedOrLoading = new Set([
+          ...loadedSessionCache.current.keys(),
+          ...sessionLoads.current.keys(),
+        ]);
+        for (const sessionId of cachedOrLoading) {
+          invalidateLoadedSession(sessionId);
+        }
         for (const session of projectSessions) {
           pendingPersist.current.delete(session.id);
           if (session.busy) {
@@ -3649,6 +3776,9 @@ export default function App({
       } else {
         for (const session of projectSessions) {
           if (session.busy) continue;
+          if (shouldPersistSession(session)) {
+            rememberLoadedSession(loadedSessionCache.current, session);
+          }
           persistSession(session);
           pendingPersist.current.delete(session.id);
           for (const id of sessionChildHarnesses(session)) {
@@ -3710,7 +3840,7 @@ export default function App({
         }
       }
     },
-    [activeTabId, onSelectProject, persistSession],
+    [activeTabId, invalidateLoadedSession, onSelectProject, persistSession],
   );
 
   const onRestoreProject = useCallback(
@@ -5728,6 +5858,7 @@ export default function App({
         status={historyFailed ? "error" : "idle"}
         pending={historyPending}
         onSelectSession={onSelectHistorySession}
+        onPrefetchSession={onPrefetchHistorySession}
         onSessionNavigationOrder={onSessionNavigationOrder}
         onPlaceSessionOnPane={onPlaceSessionOnPane}
         onRenameSession={onRenameHistorySession}
diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index 2599be7b..c23c7a67 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -2290,6 +2290,8 @@ function FolderRenameRow({
   );
 }
 
+const SESSION_PREFETCH_DELAY_MS = 120;
+
 function SessionCard({
   session,
   isActive,
@@ -2334,6 +2336,7 @@ function SessionCard({
   onDelete?: () => void;
 }) {
   const skipClickUntil = useRef(0);
+  const prefetchTimer = useRef<number | null>(null);
   const [dragging, setDragging] = useState(false);
   const title = sessionDisplayTitle(session.title, session.harness);
   const gitLabel = formatGitLabel(session.repo, session.branch);
@@ -2438,6 +2441,10 @@ function SessionCard({
     if (event.button !== 0) return;
     // Warm the transcript during the press. Opening stays on click so a
     // drag-to-pane gesture does not switch conversations.
+    if (prefetchTimer.current != null) {
+      window.clearTimeout(prefetchTimer.current);
+      prefetchTimer.current = null;
+    }
     onPrefetch?.(session.id);
     if (!onPlaceOnPane && !onListDrop) return;
     const handle = event.currentTarget;
@@ -2537,6 +2544,30 @@ function SessionCard({
     window.addEventListener("keydown", onKey);
   };
 
+  useEffect(
+    () => () => {
+      if (prefetchTimer.current != null) {
+        window.clearTimeout(prefetchTimer.current);
+        prefetchTimer.current = null;
+      }
+    },
+    [onPrefetch, session.id],
+  );
+
+  const schedulePrefetch = () => {
+    if (!onPrefetch || prefetchTimer.current != null) return;
+    prefetchTimer.current = window.setTimeout(() => {
+      prefetchTimer.current = null;
+      onPrefetch(session.id);
+    }, SESSION_PREFETCH_DELAY_MS);
+  };
+
+  const cancelScheduledPrefetch = () => {
+    if (prefetchTimer.current == null) return;
+    window.clearTimeout(prefetchTimer.current);
+    prefetchTimer.current = null;
+  };
+
   const archiveLabel = session.archived ? "Unarchive" : "Archive";
 
   return (
@@ -2551,7 +2582,8 @@ function SessionCard({
         data-session-selected={isSelected ? "true" : undefined}
         data-tauri-drag-region="false"
         onPointerDown={onPointerDown}
-        onPointerEnter={() => onPrefetch?.(session.id)}
+        onPointerEnter={schedulePrefetch}
+        onPointerLeave={cancelScheduledPrefetch}
         onClick={(event) => {
           if (performance.now() < skipClickUntil.current) return;
           onSelect(session.id, event);
diff --git a/src/chrome/SidebarRename.test.ts b/src/chrome/SidebarRename.test.ts
index 67806784..06247a3b 100644
--- a/src/chrome/SidebarRename.test.ts
+++ b/src/chrome/SidebarRename.test.ts
@@ -124,6 +124,7 @@ afterEach(() => {
   act(() => root.unmount());
   container.remove();
   localStorage.clear();
+  vi.useRealTimers();
   vi.unstubAllGlobals();
 });
 
@@ -170,6 +171,37 @@ describe("sidebar session rename", () => {
     );
   });
 
+  it("prefetches after a deliberate hover and immediately on press", () => {
+    vi.useFakeTimers();
+    props.onPrefetchSession = vi.fn();
+    act(() => render());
+
+    act(() => {
+      card().dispatchEvent(new MouseEvent("pointerover", { bubbles: true }));
+      vi.advanceTimersByTime(119);
+    });
+    expect(props.onPrefetchSession).not.toHaveBeenCalled();
+
+    act(() => vi.advanceTimersByTime(1));
+    expect(props.onPrefetchSession).toHaveBeenCalledExactlyOnceWith(
+      "session-1",
+    );
+
+    act(() => {
+      card().dispatchEvent(new MouseEvent("pointerover", { bubbles: true }));
+      card().dispatchEvent(new MouseEvent("pointerout", { bubbles: true }));
+      vi.advanceTimersByTime(120);
+    });
+    expect(props.onPrefetchSession).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      card().dispatchEvent(
+        new MouseEvent("pointerdown", { bubbles: true, button: 0 }),
+      );
+    });
+    expect(props.onPrefetchSession).toHaveBeenCalledTimes(2);
+  });
+
   it("cancels with Escape while the agent is working", () => {
     act(() => render());
     const input = startRename();
diff --git a/src/lib/sessionCache.test.ts b/src/lib/sessionCache.test.ts
index d86d15ed..2c9dcf0c 100644
--- a/src/lib/sessionCache.test.ts
+++ b/src/lib/sessionCache.test.ts
@@ -1,6 +1,9 @@
 import { describe, expect, it } from "vitest";
 import { newSession } from "./session";
-import { rememberLoadedSession } from "./sessionCache";
+import {
+  estimateSessionCacheBytes,
+  rememberLoadedSession,
+} from "./sessionCache";
 
 function chat(id: string): ReturnType<typeof newSession> {
   const session = newSession("cursor", "/tmp/project");
@@ -25,4 +28,31 @@ describe("rememberLoadedSession", () => {
     rememberLoadedSession(cache, chat("c"), 2);
     expect([...cache.keys()]).toEqual(["a", "c"]);
   });
+
+  it("evicts by estimated memory as well as entry count", () => {
+    const cache = new Map();
+    const a = chat("a");
+    const b = chat("b");
+    a.blocks = [{ id: "a1", role: "assistant", text: "a".repeat(200) }];
+    b.blocks = [{ id: "b1", role: "assistant", text: "b".repeat(200) }];
+    const budget = Math.max(
+      estimateSessionCacheBytes(a),
+      estimateSessionCacheBytes(b),
+    );
+
+    rememberLoadedSession(cache, a, 12, budget);
+    rememberLoadedSession(cache, b, 12, budget);
+    expect([...cache.keys()]).toEqual(["b"]);
+  });
+
+  it("does not retain one session larger than the whole budget", () => {
+    const cache = new Map();
+    const oversized = chat("large");
+    oversized.blocks = [
+      { id: "large-1", role: "assistant", text: "x".repeat(1_000) },
+    ];
+
+    rememberLoadedSession(cache, oversized, 12, 100);
+    expect(cache.size).toBe(0);
+  });
 });
diff --git a/src/lib/sessionCache.ts b/src/lib/sessionCache.ts
index 704f7d5b..b1248950 100644
--- a/src/lib/sessionCache.ts
+++ b/src/lib/sessionCache.ts
@@ -1,18 +1,71 @@
 import type { Session } from "./session";
 
 /** Closed chats stay here so clicking a session card can paint without disk. */
-export const SESSION_LOAD_CACHE_LIMIT = 48;
+export const SESSION_LOAD_CACHE_LIMIT = 12;
+export const SESSION_LOAD_CACHE_MAX_BYTES = 32 * 1024 * 1024;
+
+const estimatedBytes = new WeakMap<object, number>();
+
+/** Conservative retained-size estimate without allocating a serialized copy. */
+export function estimateSessionCacheBytes(session: Session): number {
+  const known = estimatedBytes.get(session);
+  if (known != null) return known;
+
+  let bytes = 0;
+  const seen = new WeakSet<object>();
+  const pending: unknown[] = [session];
+  while (pending.length > 0) {
+    const value = pending.pop();
+    if (typeof value === "string") {
+      bytes += value.length * 2;
+      continue;
+    }
+    if (typeof value === "number") {
+      bytes += 8;
+      continue;
+    }
+    if (typeof value === "boolean") {
+      bytes += 4;
+      continue;
+    }
+    if (!value || typeof value !== "object" || seen.has(value)) continue;
+    seen.add(value);
+
+    if (Array.isArray(value)) {
+      bytes += 24 + value.length * 8;
+      for (const item of value) pending.push(item);
+      continue;
+    }
+
+    const values = Object.values(value);
+    bytes += 32 + values.length * 8;
+    for (const item of values) pending.push(item);
+  }
+
+  estimatedBytes.set(session, bytes);
+  return bytes;
+}
 
 export function rememberLoadedSession(
   cache: Map<string, Session>,
   session: Session,
   limit = SESSION_LOAD_CACHE_LIMIT,
+  maxBytes = SESSION_LOAD_CACHE_MAX_BYTES,
 ) {
   cache.delete(session.id);
+  const sessionBytes = estimateSessionCacheBytes(session);
+  if (limit <= 0 || sessionBytes > maxBytes) return;
+
   cache.set(session.id, session);
-  while (cache.size > limit) {
+  let cacheBytes = 0;
+  for (const cached of cache.values()) {
+    cacheBytes += estimateSessionCacheBytes(cached);
+  }
+  while (cache.size > limit || cacheBytes > maxBytes) {
     const oldest = cache.keys().next().value;
     if (oldest == null) break;
+    const evicted = cache.get(oldest);
+    if (evicted) cacheBytes -= estimateSessionCacheBytes(evicted);
     cache.delete(oldest);
   }
 }
diff --git a/src/lib/workspaceTabGroups.test.ts b/src/lib/workspaceTabGroups.test.ts
index ae7d2c99..de0c1257 100644
--- a/src/lib/workspaceTabGroups.test.ts
+++ b/src/lib/workspaceTabGroups.test.ts
@@ -12,6 +12,7 @@ import type { Session } from "./session";
 import {
   applyPlaceSessionOnPane,
   filterTabsForProject,
+  findOpenSessionTab,
   findTabForProject,
   planWorkspaceTabClose,
   replaceGroupInTabOrder,
@@ -97,6 +98,20 @@ describe("focusedWorkspaceTabCwd", () => {
   });
 });
 
+describe("findOpenSessionTab", () => {
+  it("does not focus a ghost tab whose session has been parked", () => {
+    const ghost = tab("ghost-tab", "parked-session");
+    expect(findOpenSessionTab([ghost], [], "parked-session")).toBeUndefined();
+    expect(
+      findOpenSessionTab(
+        [ghost],
+        [session("parked-session", "/workspace")],
+        "parked-session",
+      ),
+    ).toBe(ghost);
+  });
+});
+
 describe("workspaceTabProject", () => {
   it("reads project from the tab session cwd", () => {
     const workspace = tab("t1", "s1");
diff --git a/src/lib/workspaceTabGroups.ts b/src/lib/workspaceTabGroups.ts
index c388143d..9ce4416f 100644
--- a/src/lib/workspaceTabGroups.ts
+++ b/src/lib/workspaceTabGroups.ts
@@ -58,6 +58,16 @@ export function findTabForProject(
   });
 }
 
+/** A tab is only openable as a chat when its session object is also mounted. */
+export function findOpenSessionTab(
+  tabs: readonly WorkspaceTab[],
+  sessions: readonly Pick<Session, "id">[],
+  sessionId: string,
+): WorkspaceTab | undefined {
+  if (!sessions.some((session) => session.id === sessionId)) return undefined;
+  return tabs.find((tab) => leafIds(tab.layout).includes(sessionId));
+}
+
 export function filterTabsForProject(
   tabs: WorkspaceTab[],
   sessions: Session[],

From 223bc3c1ed44e44f3266c68c96b140478076b83e Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 06:15:32 +0100
Subject: [PATCH 05/17] Move linked work item notices into session panes

- Render notices within the focused session transcript
- Remove portal positioning and height management
---
 src/App.tsx                                   | 62 ++-----------------
 src/chrome/LinkedWorkItemUpdateNotice.test.ts |  3 +
 src/chrome/LinkedWorkItemUpdateNotice.tsx     | 30 ++-------
 src/surfaces/PaneTree.tsx                     | 15 +++++
 src/surfaces/SessionPane.tsx                  | 37 +++++++++++
 5 files changed, 64 insertions(+), 83 deletions(-)

diff --git a/src/App.tsx b/src/App.tsx
index 51a9ffff..9e5c1b58 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -278,7 +278,6 @@ import { liveAgentsFromSessions } from "./lib/liveAgents";
 import { hiddenApprovalNotices } from "./lib/approvalToast";
 import { useSessionReminders } from "./hooks/useSessionReminders";
 import { ReminderNotices } from "./chrome/ReminderNotices";
-import { LinkedWorkItemUpdateNotice } from "./chrome/LinkedWorkItemUpdateNotice";
 import { nextUnseenFinishedSessions } from "./lib/sessionDone";
 import {
   loadNotificationsEnabled,
@@ -342,7 +341,6 @@ import type { ConnectableInboxSource } from "./lib/inboxFilters";
 import { InboxView } from "./surfaces/InboxView";
 import type { InboxSessionPortal } from "./surfaces/InboxDiscussionPanel";
 import { inboxAskKey, inboxAskPrompt } from "./lib/inboxAsk";
-import { requestAddToChat } from "./lib/quoteDraft";
 import { NotesView } from "./surfaces/NotesView";
 import {
   githubWorkItemThread,
@@ -1089,8 +1087,6 @@ export default function App({
     [sessions, activeTabId, tabs, composerFocused],
   );
   const [reminderNoticesHeight, setReminderNoticesHeight] = useState(0);
-  const [linkedActivityNoticeHeight, setLinkedActivityNoticeHeight] =
-    useState(0);
 
   useEffect(() => {
     syncDockBadge(sessions);
@@ -5821,8 +5817,12 @@ export default function App({
     onSteerQueuedMessage,
     onResumeQueue,
     onInboxCardDismiss,
+    onLinkedWorkItemUpdateCardDismiss,
     onNoteCardDismiss,
     onHandoffCardDismiss,
+    onOpenLinkedWorkItem,
+    onArchiveSession: onArchiveHistorySession,
+    onDeleteSession: onDeleteHistorySession,
     onApproval,
     onQuestionReply,
     onQuestionInteraction,
@@ -6215,62 +6215,10 @@ export default function App({
 
       <ApprovalToasts
         notices={hiddenApprovalToasts}
-        topOffset={
-          12 +
-          (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0) +
-          (linkedActivityNoticeHeight ? linkedActivityNoticeHeight + 8 : 0)
-        }
+        topOffset={12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)}
         onFocusSession={onOpenApprovalSession}
         onApproval={onApproval}
       />
-      <LinkedWorkItemUpdateNotice
-        card={
-          searchViewOpen || inboxViewOpen || notesViewOpen || settingsOpen
-            ? undefined
-            : sessions.find((session) => session.id === activeTab?.focusedId)
-                ?.linkedWorkItemUpdateCard
-        }
-        topOffset={12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)}
-        onAcknowledge={() => {
-          const session = sessions.find(
-            (entry) => entry.id === activeTab?.focusedId,
-          );
-          const updatedAt = session?.linkedWorkItemUpdateCard?.updatedAt;
-          if (session && updatedAt != null) {
-            markLinkedSessionUpdateSeen(session.id, updatedAt);
-          }
-        }}
-        onDismiss={() => {
-          if (activeTab?.focusedId) {
-            onLinkedWorkItemUpdateCardDismiss(activeTab.focusedId);
-          }
-        }}
-        onOpenDiscussion={() => {
-          const session = sessions.find(
-            (entry) => entry.id === activeTab?.focusedId,
-          );
-          if (session?.linkedWorkItem) {
-            onOpenLinkedWorkItem(session.linkedWorkItem);
-          }
-        }}
-        onAddToChat={(text) => {
-          requestAddToChat(text, "plain");
-          setComposerFocused(true);
-        }}
-        onArchiveSession={() => {
-          const sessionId = activeTab?.focusedId;
-          return sessionId
-            ? onArchiveHistorySession(sessionId, true)
-            : Promise.resolve(false);
-        }}
-        onDeleteSession={() => {
-          const sessionId = activeTab?.focusedId;
-          return sessionId
-            ? onDeleteHistorySession(sessionId)
-            : Promise.resolve(false);
-        }}
-        onHeightChange={setLinkedActivityNoticeHeight}
-      />
       <ReminderNotices
         reminders={sessionReminders.due}
         error={sessionReminders.error}
diff --git a/src/chrome/LinkedWorkItemUpdateNotice.test.ts b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
index 70b00d2a..11fbeb57 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.test.ts
+++ b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
@@ -147,6 +147,9 @@ describe("linked work item update notice", () => {
     const notice = document.body.querySelector<HTMLElement>(
       'section[aria-label="New activity on Pull request 42"]',
     );
+    expect(notice?.parentElement).toBe(container);
+    expect(notice?.classList.contains("absolute")).toBe(true);
+    expect(notice?.classList.contains("fixed")).toBe(false);
     expect(notice?.classList.contains("isolate")).toBe(true);
     expect(notice?.classList.contains("bg-content/10")).toBe(false);
     expect(notice?.classList.contains("bg-background-base/95")).toBe(false);
diff --git a/src/chrome/LinkedWorkItemUpdateNotice.tsx b/src/chrome/LinkedWorkItemUpdateNotice.tsx
index 4c22cdd4..471cf777 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.tsx
+++ b/src/chrome/LinkedWorkItemUpdateNotice.tsx
@@ -1,7 +1,5 @@
 import { openUrl } from "@tauri-apps/plugin-opener";
-import { useEffect, useLayoutEffect, useRef, useState } from "react";
-import { createPortal } from "react-dom";
-import { LAYER } from "../lib/layers";
+import { useEffect, useRef, useState } from "react";
 import {
   linkedWorkItemActivityPrompt,
   linkedWorkItemTerminalState,
@@ -27,14 +25,12 @@ import {
 
 type Props = {
   card?: LinkedWorkItemUpdateCard;
-  topOffset?: number;
   onAcknowledge: () => void;
   onDismiss: () => void;
   onOpenDiscussion: () => void;
   onAddToChat: (text: string) => void;
   onArchiveSession?: () => Promise<boolean>;
   onDeleteSession?: () => Promise<boolean>;
-  onHeightChange?: (height: number) => void;
 };
 
 function entryKindLabel(entry: LinkedWorkItemActivityEntry): string {
@@ -62,32 +58,17 @@ function ActivityIcon({ entry }: { entry: LinkedWorkItemActivityEntry }) {
 
 export function LinkedWorkItemUpdateNotice({
   card,
-  topOffset = 12,
   onAcknowledge,
   onDismiss,
   onOpenDiscussion,
   onAddToChat,
   onArchiveSession,
   onDeleteSession,
-  onHeightChange,
 }: Props) {
-  const panelRef = useRef<HTMLElement>(null);
   const soundedCards = useRef(new Set<string>());
   const [cleanupAction, setCleanupAction] = useState<
     "archive" | "delete" | undefined
   >();
-  useLayoutEffect(() => {
-    const panel = panelRef.current;
-    if (!panel || !onHeightChange) return;
-    const measure = () => onHeightChange(panel.offsetHeight);
-    measure();
-    const observer = new ResizeObserver(measure);
-    observer.observe(panel);
-    return () => {
-      observer.disconnect();
-      onHeightChange(0);
-    };
-  }, [card, onHeightChange]);
   useEffect(() => {
     if (!card || card.status !== "ready") return;
     const key = `${card.kind}:${card.repo}:${card.number}:${card.updatedAt}`;
@@ -155,13 +136,11 @@ export function LinkedWorkItemUpdateNotice({
     }
   };
 
-  return createPortal(
+  return (
     <section
-      ref={panelRef}
       aria-label={`New activity on ${kindLabel} ${card.number}`}
       aria-live="polite"
-      style={{ zIndex: LAYER.popover - 1, top: topOffset }}
-      className="linked-activity-notice fixed right-3 isolate w-[min(320px,calc(100vw-24px))] overflow-hidden rounded-xl border border-content/10 text-content shadow-xl"
+      className="linked-activity-notice pointer-events-auto absolute top-3 right-3 z-40 isolate w-[min(320px,calc(100%_-_24px))] overflow-hidden rounded-xl border border-content/10 text-content shadow-xl"
     >
       <div
         aria-hidden="true"
@@ -329,7 +308,6 @@ export function LinkedWorkItemUpdateNotice({
           {agentLabel}
         </button>
       </div>
-    </section>,
-    document.body,
+    </section>
   );
 }
diff --git a/src/surfaces/PaneTree.tsx b/src/surfaces/PaneTree.tsx
index d6a0b9b6..b5cc73d3 100644
--- a/src/surfaces/PaneTree.tsx
+++ b/src/surfaces/PaneTree.tsx
@@ -27,6 +27,7 @@ import {
   type Attachment,
   type Block,
   type HarnessId,
+  type LinkedWorkItem,
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
@@ -86,8 +87,12 @@ type Shared = {
   onSteerQueuedMessage: (sessionId: string, messageId: string) => void;
   onResumeQueue: (sessionId: string) => void;
   onInboxCardDismiss?: (sessionId: string) => void;
+  onLinkedWorkItemUpdateCardDismiss?: (sessionId: string) => void;
   onNoteCardDismiss?: (sessionId: string) => void;
   onHandoffCardDismiss?: (sessionId: string) => void;
+  onOpenLinkedWorkItem?: (item: LinkedWorkItem) => void;
+  onArchiveSession?: (sessionId: string, archived: boolean) => Promise<boolean>;
+  onDeleteSession?: (sessionId: string) => Promise<boolean>;
   onApproval: (
     sessionId: string,
     requestId: number,
@@ -175,8 +180,12 @@ function PaneTreeComponent({
   onSteerQueuedMessage,
   onResumeQueue,
   onInboxCardDismiss,
+  onLinkedWorkItemUpdateCardDismiss,
   onNoteCardDismiss,
   onHandoffCardDismiss,
+  onOpenLinkedWorkItem,
+  onArchiveSession,
+  onDeleteSession,
   onApproval,
   onQuestionReply,
   onQuestionInteraction,
@@ -390,8 +399,14 @@ function PaneTreeComponent({
                 onSteerQueuedMessage={onSteerQueuedMessage}
                 onResumeQueue={onResumeQueue}
                 onInboxCardDismiss={onInboxCardDismiss}
+                onLinkedWorkItemUpdateCardDismiss={
+                  onLinkedWorkItemUpdateCardDismiss
+                }
                 onNoteCardDismiss={onNoteCardDismiss}
                 onHandoffCardDismiss={onHandoffCardDismiss}
+                onOpenLinkedWorkItem={onOpenLinkedWorkItem}
+                onArchiveSession={onArchiveSession}
+                onDeleteSession={onDeleteSession}
                 onApproval={onApproval}
                 onQuestionReply={onQuestionReply}
                 onQuestionInteraction={onQuestionInteraction}
diff --git a/src/surfaces/SessionPane.tsx b/src/surfaces/SessionPane.tsx
index 7d16541b..74594237 100644
--- a/src/surfaces/SessionPane.tsx
+++ b/src/surfaces/SessionPane.tsx
@@ -11,6 +11,7 @@ import {
 } from "react";
 import { Composer } from "../chrome/Composer";
 import { DiscussionEmpty } from "../chrome/DiscussionEmpty";
+import { LinkedWorkItemUpdateNotice } from "../chrome/LinkedWorkItemUpdateNotice";
 import { SessionReview } from "../chrome/SessionReview";
 import { PromptOutline } from "../chrome/PromptOutline";
 import {
@@ -25,6 +26,7 @@ import {
   type Attachment,
   type Block,
   type HarnessId,
+  type LinkedWorkItem,
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
@@ -56,6 +58,7 @@ import {
   subscribeChatBackgroundPath,
 } from "../lib/appearance";
 import type { SessionFolderTarget } from "../lib/sessionFolders";
+import { markLinkedSessionUpdateSeen } from "../lib/linkedSessionSeen";
 
 type Props = {
   session: Session;
@@ -99,8 +102,12 @@ type Props = {
   onSteerQueuedMessage: (sessionId: string, messageId: string) => void;
   onResumeQueue: (sessionId: string) => void;
   onInboxCardDismiss?: (sessionId: string) => void;
+  onLinkedWorkItemUpdateCardDismiss?: (sessionId: string) => void;
   onNoteCardDismiss?: (sessionId: string) => void;
   onHandoffCardDismiss?: (sessionId: string) => void;
+  onOpenLinkedWorkItem?: (item: LinkedWorkItem) => void;
+  onArchiveSession?: (sessionId: string, archived: boolean) => Promise<boolean>;
+  onDeleteSession?: (sessionId: string) => Promise<boolean>;
   onApproval: (
     sessionId: string,
     requestId: number,
@@ -166,8 +173,12 @@ export const SessionPane = memo(function SessionPane({
   onSteerQueuedMessage,
   onResumeQueue,
   onInboxCardDismiss,
+  onLinkedWorkItemUpdateCardDismiss,
   onNoteCardDismiss,
   onHandoffCardDismiss,
+  onOpenLinkedWorkItem,
+  onArchiveSession,
+  onDeleteSession,
   onApproval,
   onQuestionReply,
   onQuestionInteraction,
@@ -450,6 +461,32 @@ export const SessionPane = memo(function SessionPane({
         </div>
       ) : null}
       <div ref={transcriptScope} className="@container relative min-h-0 flex-1">
+        {visible && focused && !session.inboxAsk ? (
+          <LinkedWorkItemUpdateNotice
+            card={session.linkedWorkItemUpdateCard}
+            onAcknowledge={() => {
+              const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;
+              if (updatedAt != null) {
+                markLinkedSessionUpdateSeen(session.id, updatedAt);
+              }
+            }}
+            onDismiss={() => onLinkedWorkItemUpdateCardDismiss?.(session.id)}
+            onOpenDiscussion={() => {
+              if (session.linkedWorkItem) {
+                onOpenLinkedWorkItem?.(session.linkedWorkItem);
+              }
+            }}
+            onAddToChat={(text) => addSelectionToChat(text, "plain")}
+            onArchiveSession={
+              onArchiveSession
+                ? () => onArchiveSession(session.id, true)
+                : undefined
+            }
+            onDeleteSession={
+              onDeleteSession ? () => onDeleteSession(session.id) : undefined
+            }
+          />
+        ) : null}
         {isEmpty ? (
           session.inboxAsk ? (
             <div className="scrollbar-none h-full min-h-0 overflow-y-auto">

From 86d1678f120d3569d958b85d14529acbdf5f07c0 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 06:20:43 +0100
Subject: [PATCH 06/17] Persist linked activity sound deduplication across
 remounts

- Track announced activity by session and update timestamp
- Add remount and new-activity coverage
---
 src/chrome/LinkedWorkItemUpdateNotice.test.ts | 73 +++++++++++++++++--
 src/chrome/LinkedWorkItemUpdateNotice.tsx     | 15 ++--
 src/lib/sounds.ts                             | 23 +++++-
 src/surfaces/SessionPane.tsx                  |  1 +
 4 files changed, 96 insertions(+), 16 deletions(-)

diff --git a/src/chrome/LinkedWorkItemUpdateNotice.test.ts b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
index 11fbeb57..3934b456 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.test.ts
+++ b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
@@ -3,14 +3,19 @@ import { act, createElement } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { LinkedWorkItemUpdateCard } from "../lib/linkedWorkItemActivity";
+import { resetSoundCues } from "../lib/sounds";
 import { LinkedWorkItemUpdateNotice } from "./LinkedWorkItemUpdateNotice";
 
-const { openUrl, playCue } = vi.hoisted(() => ({
+const { openUrl, play } = vi.hoisted(() => ({
   openUrl: vi.fn(),
-  playCue: vi.fn(),
+  play: vi.fn(),
 }));
 vi.mock("@tauri-apps/plugin-opener", () => ({ openUrl }));
-vi.mock("../lib/sounds", () => ({ playCue }));
+vi.mock("cuelume", () => ({
+  play,
+  setEnabled: vi.fn(),
+  setVolume: vi.fn(),
+}));
 
 const baseCard: LinkedWorkItemUpdateCard = {
   kind: "pr",
@@ -49,7 +54,9 @@ beforeEach(() => {
     },
   );
   openUrl.mockReset();
-  playCue.mockReset();
+  play.mockReset();
+  resetSoundCues();
+  localStorage.clear();
   container = document.createElement("div");
   document.body.append(container);
   root = createRoot(container);
@@ -76,6 +83,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: { ...baseCard, status: "loading" },
           onAcknowledge: () => {},
           onDismiss: () => {},
@@ -91,6 +99,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: baseCard,
           onAcknowledge: () => {},
           onDismiss: () => {},
@@ -102,11 +111,12 @@ describe("linked work item update notice", () => {
     expect(
       document.body.querySelector('[aria-label^="New activity on"]')?.classList,
     ).toContain("linked-activity-notice");
-    expect(playCue).toHaveBeenCalledExactlyOnceWith("linkedActivity");
+    expect(play).toHaveBeenCalledExactlyOnceWith("chime");
 
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           onAcknowledge: () => {},
           onDismiss: () => {},
           onOpenDiscussion: () => {},
@@ -117,6 +127,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: baseCard,
           onAcknowledge: () => {},
           onDismiss: () => {},
@@ -125,7 +136,53 @@ describe("linked work item update notice", () => {
         }),
       );
     });
-    expect(playCue).toHaveBeenCalledTimes(1);
+    expect(play).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays silent after a tab remount but announces new activity", () => {
+    const renderNotice = (
+      card: LinkedWorkItemUpdateCard,
+      sessionId = "session-1",
+    ) => {
+      act(() => {
+        root.render(
+          createElement(LinkedWorkItemUpdateNotice, {
+            sessionId,
+            card,
+            onAcknowledge: () => {},
+            onDismiss: () => {},
+            onOpenDiscussion: () => {},
+            onAddToChat: () => {},
+          }),
+        );
+      });
+    };
+
+    renderNotice(baseCard);
+    expect(play).toHaveBeenCalledExactlyOnceWith("chime");
+
+    act(() => root.render(null));
+    renderNotice({ ...baseCard });
+    expect(play).toHaveBeenCalledTimes(1);
+    expect(
+      container.querySelector('[aria-label^="New activity on"]'),
+    ).not.toBeNull();
+
+    const updatedCard = { ...baseCard, updatedAt: baseCard.updatedAt + 60_000 };
+    renderNotice({ ...updatedCard, status: "loading" });
+    renderNotice({ ...updatedCard, status: "error" });
+    expect(play).toHaveBeenCalledTimes(1);
+    renderNotice(updatedCard);
+    expect(play).toHaveBeenCalledTimes(2);
+
+    act(() => root.render(null));
+    renderNotice({ ...updatedCard });
+    expect(play).toHaveBeenCalledTimes(2);
+
+    renderNotice(baseCard, "session-2");
+    expect(play).toHaveBeenCalledTimes(3);
+    renderNotice(updatedCard);
+    expect(play).toHaveBeenCalledTimes(3);
   });
 
   it("offers discussion and agent actions for a new comment", () => {
@@ -135,6 +192,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: baseCard,
           onAcknowledge,
           onDismiss: () => {},
@@ -191,6 +249,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card,
           onAcknowledge,
           onDismiss: () => {},
@@ -214,6 +273,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: { ...baseCard, state: "merged" },
           onAcknowledge,
           onDismiss: () => {},
@@ -242,6 +302,7 @@ describe("linked work item update notice", () => {
     act(() => {
       root.render(
         createElement(LinkedWorkItemUpdateNotice, {
+          sessionId: "session-1",
           card: { ...baseCard, kind: "issue", state: "closed" },
           onAcknowledge: () => {},
           onDismiss: () => {},
diff --git a/src/chrome/LinkedWorkItemUpdateNotice.tsx b/src/chrome/LinkedWorkItemUpdateNotice.tsx
index 471cf777..98cc1b29 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.tsx
+++ b/src/chrome/LinkedWorkItemUpdateNotice.tsx
@@ -1,5 +1,5 @@
 import { openUrl } from "@tauri-apps/plugin-opener";
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useState } from "react";
 import {
   linkedWorkItemActivityPrompt,
   linkedWorkItemTerminalState,
@@ -8,7 +8,7 @@ import {
   type LinkedWorkItemUpdateCard,
 } from "../lib/linkedWorkItemActivity";
 import { formatRelativeTime } from "../lib/githubTasks";
-import { playCue } from "../lib/sounds";
+import { announceLinkedActivity } from "../lib/sounds";
 import {
   Archive,
   Check,
@@ -24,6 +24,7 @@ import {
 } from "./icons";
 
 type Props = {
+  sessionId: string;
   card?: LinkedWorkItemUpdateCard;
   onAcknowledge: () => void;
   onDismiss: () => void;
@@ -57,6 +58,7 @@ function ActivityIcon({ entry }: { entry: LinkedWorkItemActivityEntry }) {
 }
 
 export function LinkedWorkItemUpdateNotice({
+  sessionId,
   card,
   onAcknowledge,
   onDismiss,
@@ -65,17 +67,12 @@ export function LinkedWorkItemUpdateNotice({
   onArchiveSession,
   onDeleteSession,
 }: Props) {
-  const soundedCards = useRef(new Set<string>());
   const [cleanupAction, setCleanupAction] = useState<
     "archive" | "delete" | undefined
   >();
   useEffect(() => {
-    if (!card || card.status !== "ready") return;
-    const key = `${card.kind}:${card.repo}:${card.number}:${card.updatedAt}`;
-    if (soundedCards.current.has(key)) return;
-    soundedCards.current.add(key);
-    playCue("linkedActivity");
-  }, [card]);
+    announceLinkedActivity(sessionId, card);
+  }, [sessionId, card]);
   if (!card || card.status === "loading") return null;
 
   const KindIcon = card.kind === "pr" ? GitPullRequest : CircleDot;
diff --git a/src/lib/sounds.ts b/src/lib/sounds.ts
index 31fc908d..d99eab5b 100644
--- a/src/lib/sounds.ts
+++ b/src/lib/sounds.ts
@@ -1,4 +1,5 @@
 import { play, setEnabled, setVolume, type SoundName } from "cuelume";
+import type { LinkedWorkItemUpdateCard } from "./linkedWorkItemActivity";
 
 const KEY = "monocode.sounds";
 
@@ -68,6 +69,25 @@ export function playCue(cue: SoundCue) {
 let inboxDotOn = false;
 let inboxPrimed = false;
 let announcedUpdate: string | undefined;
+const announcedLinkedActivities = new Set<string>();
+
+/** Remember each session's activity across notice unmounts when switching tabs. */
+export function announceLinkedActivity(
+  sessionId: string,
+  card: LinkedWorkItemUpdateCard | undefined,
+) {
+  if (!card || card.status !== "ready") return;
+  const key = JSON.stringify([
+    sessionId,
+    card.kind,
+    card.repo.toLowerCase(),
+    card.number,
+    card.updatedAt,
+  ]);
+  if (announcedLinkedActivities.has(key)) return;
+  announcedLinkedActivities.add(key);
+  playCue("linkedActivity");
+}
 
 /**
  * Rising edge of the project-rail inbox dot, after the first snapshot.
@@ -90,9 +110,10 @@ export function announceUpdateAvailable(version: string | null) {
   playCue("updateAvailable");
 }
 
-/** Test helper: forget which inbox/update cues already fired. */
+/** Test helper: forget which notification cues already fired. */
 export function resetSoundCues() {
   inboxDotOn = false;
   inboxPrimed = false;
   announcedUpdate = undefined;
+  announcedLinkedActivities.clear();
 }
diff --git a/src/surfaces/SessionPane.tsx b/src/surfaces/SessionPane.tsx
index 74594237..9d3e5322 100644
--- a/src/surfaces/SessionPane.tsx
+++ b/src/surfaces/SessionPane.tsx
@@ -463,6 +463,7 @@ export const SessionPane = memo(function SessionPane({
       <div ref={transcriptScope} className="@container relative min-h-0 flex-1">
         {visible && focused && !session.inboxAsk ? (
           <LinkedWorkItemUpdateNotice
+            sessionId={session.id}
             card={session.linkedWorkItemUpdateCard}
             onAcknowledge={() => {
               const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;

From c7e0acb4b486aecc05ed683aa54271ff5413a418 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 06:26:36 +0100
Subject: [PATCH 07/17] Rework linked work item update notice actions

- Promote agent action and simplify dismissal control
- Rename activity links and update related tests
---
 src/chrome/LinkedWorkItemUpdateNotice.test.ts | 10 ++--
 src/chrome/LinkedWorkItemUpdateNotice.tsx     | 54 ++++++++-----------
 2 files changed, 28 insertions(+), 36 deletions(-)

diff --git a/src/chrome/LinkedWorkItemUpdateNotice.test.ts b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
index 3934b456..47f25960 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.test.ts
+++ b/src/chrome/LinkedWorkItemUpdateNotice.test.ts
@@ -214,13 +214,15 @@ describe("linked work item update notice", () => {
     expect(notice?.querySelector(".popover-backdrop")).not.toBeNull();
     expect(document.body.textContent).toContain("1 new comment");
     expect(
-      button("Dismiss").nextElementSibling?.getAttribute("aria-label"),
-    ).toBe("Dismiss updates for Pull request 42");
-    expect(button("Open discussion").classList.contains("truncate")).toBe(true);
+      notice?.querySelector(
+        'button[aria-label="Dismiss updates for Pull request 42"]',
+      ),
+    ).not.toBeNull();
+    expect(button("Open PR").classList.contains("truncate")).toBe(true);
     expect(button("Address with agent").classList).toContain(
       "whitespace-nowrap",
     );
-    act(() => button("Open discussion").click());
+    act(() => button("Open PR").click());
     expect(onAcknowledge).toHaveBeenCalledTimes(1);
     expect(onOpenDiscussion).toHaveBeenCalledTimes(1);
     act(() => button("Address with agent").click());
diff --git a/src/chrome/LinkedWorkItemUpdateNotice.tsx b/src/chrome/LinkedWorkItemUpdateNotice.tsx
index 98cc1b29..56233473 100644
--- a/src/chrome/LinkedWorkItemUpdateNotice.tsx
+++ b/src/chrome/LinkedWorkItemUpdateNotice.tsx
@@ -82,11 +82,10 @@ export function LinkedWorkItemUpdateNotice({
     latest?.kind === "comment" ||
     latest?.kind === "review" ||
     latest?.kind === "review_comment";
-  const primaryLabel = discussion
-    ? "Open discussion"
-    : latest?.kind === "commit"
+  const openLabel =
+    latest?.kind === "commit"
       ? "Open commit"
-      : `Open ${card.kind === "pr" ? "pull request" : "issue"}`;
+      : `Open ${card.kind === "pr" ? "PR" : "issue"}`;
   const agentLabel = discussion
     ? "Address with agent"
     : latest?.kind === "commit"
@@ -108,7 +107,7 @@ export function LinkedWorkItemUpdateNotice({
         ? GitPullRequestClosed
         : Check;
 
-  const openPrimary = () => {
+  const openActivity = () => {
     onAcknowledge();
     if (discussion) {
       onOpenDiscussion();
@@ -151,24 +150,15 @@ export function LinkedWorkItemUpdateNotice({
             GitHub activity
           </span>
         </div>
-        <div className="flex items-center gap-px">
-          <button
-            type="button"
-            onClick={dismiss}
-            className="shrink-0 whitespace-nowrap rounded-md px-1.5 h-6 text-[11px] text-content/50 hover:bg-content/10 hover:text-content"
-          >
-            Dismiss
-          </button>
-          <button
-            type="button"
-            title="Dismiss"
-            aria-label={`Dismiss updates for ${kindLabel} ${card.number}`}
-            onClick={dismiss}
-            className="grid size-6 place-items-center rounded-md text-content/40 hover:bg-content/10 hover:text-content"
-          >
-            <X className="size-3" strokeWidth={2} />
-          </button>
-        </div>
+        <button
+          type="button"
+          title="Dismiss"
+          aria-label={`Dismiss updates for ${kindLabel} ${card.number}`}
+          onClick={dismiss}
+          className="grid size-6 shrink-0 place-items-center rounded-md text-content/40 hover:bg-content/10 hover:text-content"
+        >
+          <X className="size-3" strokeWidth={2} />
+        </button>
       </div>
 
       <div className="relative z-[1] px-3 py-2.5">
@@ -285,18 +275,10 @@ export function LinkedWorkItemUpdateNotice({
       ) : null}
 
       <div className="relative z-[1] flex min-w-0 items-center gap-1.5 border-t border-content/10 px-3 py-2.5 text-[11px]">
-        <button
-          type="button"
-          title={primaryLabel}
-          className="min-w-0 flex-1 truncate whitespace-nowrap rounded-md bg-content/10 px-2 py-1 font-medium hover:bg-content/15"
-          onClick={openPrimary}
-        >
-          {primaryLabel}
-        </button>
         <button
           type="button"
           title={agentLabel}
-          className="min-w-0 flex-1 truncate whitespace-nowrap rounded-md px-2 py-1 text-content/65 hover:bg-content/10"
+          className="min-w-0 flex-1 truncate whitespace-nowrap rounded-md bg-content px-2 py-1 font-medium text-background-base hover:bg-content/90"
           onClick={() => {
             onAcknowledge();
             onAddToChat(linkedWorkItemActivityPrompt(card));
@@ -304,6 +286,14 @@ export function LinkedWorkItemUpdateNotice({
         >
           {agentLabel}
         </button>
+        <button
+          type="button"
+          title={openLabel}
+          className="min-w-0 flex-1 truncate whitespace-nowrap rounded-md bg-content/10 px-2 py-1 font-medium hover:bg-content/15"
+          onClick={openActivity}
+        >
+          {openLabel}
+        </button>
       </div>
     </section>
   );

From 19a7c311c999d49a51b0a83df71477d749a1dfd8 Mon Sep 17 00:00:00 2001
From: Utkarsh Rahim <41941875+UtkarshRahim@users.noreply.github.com>
Date: Mon, 14 Sep 2026 11:21:10 +0530
Subject: [PATCH 08/17] feature to view the full files on the PR (#189)

* feature to view the full files on the PR

* changes after npm run check

* fix : coderabbit and hardbeat920 comments resolved

* added flags --no-color, --no-ext-diff, and --default-prefix
---
 src-tauri/src/fs.rs            | 439 +++++++++++++++++++++++++++++++--
 src/lib/githubTasks.ts         |  21 +-
 src/lib/unifiedDiff.test.ts    |  12 +
 src/surfaces/InboxPrDiff.tsx   |  17 +-
 src/surfaces/InboxView.test.ts |  17 +-
 src/surfaces/InboxView.tsx     |  92 +++++--
 6 files changed, 547 insertions(+), 51 deletions(-)

diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index ca37d935..4b66c147 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -1,6 +1,5 @@
 use std::collections::{HashMap, HashSet};
-use std::io::ErrorKind;
-use std::io::Write;
+use std::io::{ErrorKind, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::Mutex;
@@ -752,11 +751,19 @@ pub struct GitHubPrDiff {
 const MAX_PR_DIFF_BYTES: usize = 2 * 1024 * 1024;
 
 /// Unified diff and file stats for a pull request, via `gh`.
+/// When `full_context` is true, prefer a large-context `git diff` between the PR OIDs.
 #[tauri::command]
-pub async fn git_github_pr_diff(cwd: String, number: i64) -> Result<GitHubPrDiff, String> {
-    tauri::async_runtime::spawn_blocking(move || git_github_pr_diff_for(&expand_home(&cwd), number))
-        .await
-        .map_err(|e| e.to_string())?
+pub async fn git_github_pr_diff(
+    cwd: String,
+    number: i64,
+    full_context: Option<bool>,
+) -> Result<GitHubPrDiff, String> {
+    let full_context = full_context.unwrap_or(false);
+    tauri::async_runtime::spawn_blocking(move || {
+        git_github_pr_diff_for(&expand_home(&cwd), number, full_context)
+    })
+    .await
+    .map_err(|e| e.to_string())?
 }
 
 #[derive(Serialize, Clone, Debug, Default, PartialEq, Eq)]
@@ -2473,19 +2480,31 @@ fn github_avatar_url(login: &str) -> String {
     format!("https://avatars.githubusercontent.com/{encoded}?s=64")
 }
 
-fn git_github_pr_diff_for(root: &Path, number: i64) -> Result<GitHubPrDiff, String> {
+const PR_FULL_CONTEXT_LINES: &str = "999999";
+
+fn git_github_pr_diff_for(
+    root: &Path,
+    number: i64,
+    full_context: bool,
+) -> Result<GitHubPrDiff, String> {
     if number <= 0 {
         return Err("Invalid pull request number".into());
     }
     let number = number.to_string();
-    let json = gh_run(
-        root,
-        &["pr", "view", &number, "--json", "files,additions,deletions"],
-        false,
-    )?;
+    let fields = if full_context {
+        "files,additions,deletions,baseRefOid,headRefOid"
+    } else {
+        "files,additions,deletions"
+    };
+    let json = gh_run(root, &["pr", "view", &number, "--json", fields], false)?;
     let mut diff = parse_github_pr_diff_meta(&json)?;
-    let patch = gh_run(root, &["pr", "diff", &number], true)?;
-    if patch.len() > MAX_PR_DIFF_BYTES {
+    let (patch, truncated) = if full_context {
+        let (base, head) = parse_github_pr_oids(&json)?;
+        git_diff_full_context(root, &base, &head)?
+    } else {
+        (gh_run(root, &["pr", "diff", &number], true)?, false)
+    };
+    if truncated || patch.len() > MAX_PR_DIFF_BYTES {
         diff.truncated = true;
     } else {
         diff.patch = patch;
@@ -2497,6 +2516,152 @@ fn git_github_pr_diff_for(root: &Path, number: i64) -> Result<GitHubPrDiff, Stri
     Ok(diff)
 }
 
+fn parse_github_pr_oids(json: &str) -> Result<(String, String), String> {
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Row {
+        base_ref_oid: String,
+        head_ref_oid: String,
+    }
+    let row: Row = serde_json::from_str(json).map_err(|error| error.to_string())?;
+    let base = row.base_ref_oid.trim();
+    let head = row.head_ref_oid.trim();
+    if base.is_empty() || head.is_empty() {
+        return Err("Pull request is missing base or head commit".into());
+    }
+    Ok((base.to_string(), head.to_string()))
+}
+
+fn git_diff_full_context(root: &Path, base: &str, head: &str) -> Result<(String, bool), String> {
+    ensure_git_commit(root, base)?;
+    ensure_git_commit(root, head)?;
+    ensure_merge_base(root, base, head)?;
+    let context = format!("-U{PR_FULL_CONTEXT_LINES}");
+    let three_dot = format!("{base}...{head}");
+    let (bytes, truncated) = git_output_capped(
+        root,
+        &[
+            "diff",
+            "--no-color",
+            "--no-ext-diff",
+            "--default-prefix",
+            &context,
+            &three_dot,
+        ],
+        MAX_PR_DIFF_BYTES,
+    )
+    .ok_or_else(|| format!("git diff failed for {base}...{head}"))?;
+    if truncated {
+        return Ok((String::new(), true));
+    }
+    Ok((String::from_utf8_lossy(&bytes).into_owned(), false))
+}
+
+fn ensure_merge_base(root: &Path, base: &str, head: &str) -> Result<(), String> {
+    if merge_base_exists(root, base, head) {
+        return Ok(());
+    }
+    if let Some(remote) = github_fetch_remote(root) {
+        for deepen in ["50", "200", "800"] {
+            let _ = git_output(root, &["fetch", "--no-tags", "--deepen", deepen, &remote]);
+            if merge_base_exists(root, base, head) {
+                return Ok(());
+            }
+        }
+    }
+    Err(format!(
+        "Cannot find a merge base for {base} and {head}. Fetch more history and try again."
+    ))
+}
+
+fn merge_base_exists(root: &Path, base: &str, head: &str) -> bool {
+    git_output(root, &["merge-base", base, head]).is_some()
+}
+
+fn ensure_git_commit(root: &Path, oid: &str) -> Result<(), String> {
+    let spec = format!("{oid}^{{commit}}");
+    if git_output(root, &["cat-file", "-e", &spec]).is_some() {
+        return Ok(());
+    }
+    if let Some(remote) = github_fetch_remote(root) {
+        let _ = git_output(root, &["fetch", "--no-tags", "--depth", "1", &remote, oid]);
+    }
+    if git_output(root, &["cat-file", "-e", &spec]).is_some() {
+        return Ok(());
+    }
+    Err(format!(
+        "Missing git commit {oid}. Fetch the pull request refs and try again."
+    ))
+}
+
+fn github_fetch_remote(root: &Path) -> Option<String> {
+    if let Some(name) = gh_resolved_remote(root) {
+        return Some(name);
+    }
+    if let Some(url) = gh_repo_view_url(root) {
+        if let Some(name) = remote_matching_github_url(root, &url) {
+            return Some(name);
+        }
+    }
+    git_remote_name(root)
+}
+
+fn gh_resolved_remote(root: &Path) -> Option<String> {
+    let listed = git_stdout(
+        root,
+        &["config", "--get-regexp", r"remote\..*\.gh-resolved"],
+    )?;
+    for line in listed.lines() {
+        let key = line.split_whitespace().next()?;
+        let name = key.strip_prefix("remote.")?.strip_suffix(".gh-resolved")?;
+        if !name.is_empty() {
+            return Some(name.to_string());
+        }
+    }
+    None
+}
+
+fn gh_repo_view_url(root: &Path) -> Option<String> {
+    let text = gh_stdout(root, &["repo", "view", "--json", "url"])?;
+    serde_json::from_str::<serde_json::Value>(&text)
+        .ok()?
+        .get("url")?
+        .as_str()
+        .map(str::to_owned)
+        .filter(|url| !url.trim().is_empty())
+}
+
+fn remote_matching_github_url(root: &Path, url: &str) -> Option<String> {
+    let remotes = git_stdout(root, &["remote", "-v"])?;
+    let wanted = normalize_github_remote_url(url);
+    for line in remotes.lines() {
+        let mut parts = line.split_whitespace();
+        let name = parts.next()?;
+        let remote_url = parts.next()?;
+        if normalize_github_remote_url(remote_url) == wanted {
+            return Some(name.to_string());
+        }
+    }
+    None
+}
+
+fn normalize_github_remote_url(url: &str) -> String {
+    let trimmed = url.trim().trim_end_matches('/').trim_end_matches(".git");
+    if let Some((_, rest)) = trimmed.split_once("github.com:") {
+        return format!(
+            "github.com/{}",
+            rest.trim_start_matches('/').to_ascii_lowercase()
+        );
+    }
+    if let Some((_, rest)) = trimmed.split_once("github.com/") {
+        return format!(
+            "github.com/{}",
+            rest.trim_start_matches('/').to_ascii_lowercase()
+        );
+    }
+    trimmed.to_ascii_lowercase()
+}
+
 fn parse_github_pr_diff_meta(json: &str) -> Result<GitHubPrDiff, String> {
     #[derive(Deserialize)]
     struct FileRow {
@@ -2788,16 +2953,59 @@ fn git_output(root: &Path, args: &[&str]) -> Option<Vec<u8>> {
         .env("GIT_TERMINAL_PROMPT", "0")
         .output()
         .ok()?;
-    if output.status.success() {
-        return Some(output.stdout);
-    }
-    // `git diff` exits 1 when the files differ.
-    if output.status.code() == Some(1) && args.first().copied() == Some("diff") {
+    if git_status_ok(&output.status, args) {
         return Some(output.stdout);
     }
     None
 }
 
+fn git_output_capped(root: &Path, args: &[&str], max_bytes: usize) -> Option<(Vec<u8>, bool)> {
+    let mut child = git_cmd()
+        .arg("--no-pager")
+        .arg("-C")
+        .arg(root)
+        .args(args)
+        .env("GIT_OPTIONAL_LOCKS", "0")
+        .env("GIT_TERMINAL_PROMPT", "0")
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .ok()?;
+    let mut stdout = child.stdout.take()?;
+    let mut buf = Vec::new();
+    let mut chunk = [0u8; 8192];
+    loop {
+        let n = match stdout.read(&mut chunk) {
+            Ok(0) => break,
+            Ok(n) => n,
+            Err(_) => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return None;
+            }
+        };
+        let remaining = max_bytes.saturating_sub(buf.len());
+        if n > remaining {
+            buf.extend_from_slice(&chunk[..remaining]);
+            let _ = child.kill();
+            let _ = child.wait();
+            return Some((buf, true));
+        }
+        buf.extend_from_slice(&chunk[..n]);
+    }
+    let status = child.wait().ok()?;
+    if git_status_ok(&status, args) {
+        Some((buf, false))
+    } else {
+        None
+    }
+}
+
+fn git_status_ok(status: &std::process::ExitStatus, args: &[&str]) -> bool {
+    status.success() || (status.code() == Some(1) && args.first().copied() == Some("diff"))
+}
+
 fn git_branch(root: &Path) -> Option<String> {
     git_head_branch(root).or_else(|| git_stdout(root, &["rev-parse", "--short", "HEAD"]))
 }
@@ -5468,6 +5676,199 @@ mod tests {
         assert!(!diff.truncated);
     }
 
+    #[test]
+    fn parse_github_pr_oids_reads_base_and_head() {
+        let json = r#"{
+            "baseRefOid": "aaa111",
+            "headRefOid": "bbb222",
+            "files": []
+        }"#;
+        assert_eq!(
+            parse_github_pr_oids(json).unwrap(),
+            ("aaa111".into(), "bbb222".into())
+        );
+    }
+
+    #[test]
+    fn git_diff_full_context_includes_distant_lines() {
+        let dir = tmp("git-full-context");
+        let original = (1..=40)
+            .map(|i| format!("line-{i}"))
+            .collect::<Vec<_>>()
+            .join("\n")
+            + "\n";
+        if !init_git_commit(&dir.0, &[("big.txt", &original)]) {
+            return;
+        }
+        let base = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        let updated = original.replace("line-30", "LINE-30");
+        std::fs::write(dir.0.join("big.txt"), &updated).unwrap();
+        if !git(&dir.0, &["add", "."]) || !git(&dir.0, &["commit", "-m", "edit"]) {
+            return;
+        }
+        let head = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        let (patch, truncated) = git_diff_full_context(&dir.0, &base, &head).unwrap();
+        assert!(!truncated);
+        assert!(
+            patch.contains("line-1"),
+            "expected distant context in patch:\n{patch}"
+        );
+        assert!(patch.contains("LINE-30"), "expected changed line:\n{patch}");
+        let default = git_run(&dir.0, &["diff", &base, &head]).unwrap_or_default();
+        assert!(
+            !default.contains("line-1"),
+            "default context should omit distant lines"
+        );
+    }
+
+    #[test]
+    fn git_diff_full_context_uses_canonical_plain_output() {
+        let dir = tmp("git-full-context-canonical");
+        if !init_git_commit(&dir.0, &[("file.txt", "alpha\n")]) {
+            return;
+        }
+        let base = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        std::fs::write(dir.0.join("file.txt"), "beta\n").unwrap();
+        if !git(&dir.0, &["add", "."]) || !git(&dir.0, &["commit", "-m", "edit"]) {
+            return;
+        }
+        let head = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        let helper = dir.0.join("ext-diff.sh");
+        std::fs::write(&helper, "#!/bin/sh\necho EXTERNAL\n").unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            let mut permissions = std::fs::metadata(&helper).unwrap().permissions();
+            permissions.set_mode(0o755);
+            std::fs::set_permissions(&helper, permissions).unwrap();
+        }
+        if !git(&dir.0, &["config", "color.ui", "always"])
+            || !git(&dir.0, &["config", "color.diff", "always"])
+            || !git(&dir.0, &["config", "diff.noprefix", "true"])
+            || !git(
+                &dir.0,
+                &["config", "diff.external", &helper.to_string_lossy()],
+            )
+        {
+            return;
+        }
+        let raw = git_run(&dir.0, &["diff", &format!("{base}...{head}")]).unwrap_or_default();
+        assert!(
+            raw.contains("EXTERNAL") || !raw.contains("diff --git a/file.txt b/file.txt"),
+            "hostile git settings should change a default diff:\n{raw}"
+        );
+        let (patch, truncated) = git_diff_full_context(&dir.0, &base, &head).unwrap();
+        assert!(!truncated);
+        assert!(
+            patch.contains("diff --git a/file.txt b/file.txt"),
+            "expected canonical prefixes:\n{patch}"
+        );
+        assert!(
+            !patch.contains('\u{1b}') && !patch.contains("EXTERNAL"),
+            "expected plain git diff output:\n{patch}"
+        );
+    }
+
+    #[test]
+    fn git_diff_full_context_errors_without_a_merge_base() {
+        let dir = tmp("git-full-context-unrelated");
+        if !init_git_commit(&dir.0, &[("a.txt", "alpha\n")]) {
+            return;
+        }
+        let base = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        if !git(&dir.0, &["checkout", "--orphan", "other"]) {
+            return;
+        }
+        let _ = std::fs::remove_file(dir.0.join("a.txt"));
+        std::fs::write(dir.0.join("b.txt"), "beta\n").unwrap();
+        if !git(&dir.0, &["add", "."]) || !git(&dir.0, &["commit", "-m", "other"]) {
+            return;
+        }
+        let head = git_run(&dir.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        assert!(git_run(&dir.0, &["merge-base", &base, &head]).is_none());
+        let two_dot = git_run(&dir.0, &["diff", &base, &head]).unwrap_or_default();
+        assert!(
+            two_dot.contains("alpha") || two_dot.contains("beta"),
+            "two-dot should invent a comparison:\n{two_dot}"
+        );
+        let err = git_diff_full_context(&dir.0, &base, &head).unwrap_err();
+        assert!(
+            err.to_lowercase().contains("merge base"),
+            "expected merge-base error, got {err}"
+        );
+    }
+
+    #[test]
+    fn ensure_git_commit_fetches_from_gh_resolved_remote() {
+        let remote = tmp("git-full-context-upstream");
+        if !init_git_commit(&remote.0, &[("note.txt", "hello\n")]) {
+            return;
+        }
+        let oid = git_run(&remote.0, &["rev-parse", "HEAD"])
+            .unwrap()
+            .trim()
+            .to_string();
+        let decoy = tmp("git-full-context-origin");
+        if !init_git_commit(&decoy.0, &[("other.txt", "decoy\n")]) {
+            return;
+        }
+        let local = tmp("git-full-context-local");
+        if !init_git_commit(&local.0, &[("local.txt", "local\n")]) {
+            return;
+        }
+        let upstream_url = remote.0.to_string_lossy().into_owned();
+        let origin_url = decoy.0.to_string_lossy().into_owned();
+        if !git(&local.0, &["remote", "add", "origin", &origin_url])
+            || !git(&local.0, &["remote", "add", "upstream", &upstream_url])
+            || !git(&local.0, &["config", "remote.upstream.gh-resolved", "base"])
+        {
+            return;
+        }
+        assert_eq!(github_fetch_remote(&local.0).as_deref(), Some("upstream"));
+        let spec = format!("{oid}^{{commit}}");
+        assert!(git_output(&local.0, &["cat-file", "-e", &spec]).is_none());
+        ensure_git_commit(&local.0, &oid).unwrap();
+        assert!(git_output(&local.0, &["cat-file", "-e", &spec]).is_some());
+    }
+
+    #[test]
+    fn git_output_capped_stops_before_buffering_the_rest() {
+        let dir = tmp("git-output-capped");
+        let big = "x".repeat(80_000);
+        if !init_git_commit(&dir.0, &[("big.txt", &format!("{big}\n"))]) {
+            return;
+        }
+        std::fs::write(dir.0.join("big.txt"), format!("y{big}\n")).unwrap();
+        if !git(&dir.0, &["add", "."]) || !git(&dir.0, &["commit", "-m", "edit"]) {
+            return;
+        }
+        let (bytes, truncated) =
+            git_output_capped(&dir.0, &["diff", "HEAD~1", "HEAD"], 1024).unwrap();
+        assert!(truncated);
+        assert!(bytes.len() <= 1024);
+        let (head, truncated) = git_output_capped(&dir.0, &["rev-parse", "HEAD"], 1024).unwrap();
+        assert!(!truncated);
+        assert!(!head.is_empty());
+    }
+
     #[test]
     fn git_stage_rejects_path_escape() {
         let dir = tmp("git-stage-escape");
diff --git a/src/lib/githubTasks.ts b/src/lib/githubTasks.ts
index f7e3d03c..9889f8f2 100644
--- a/src/lib/githubTasks.ts
+++ b/src/lib/githubTasks.ts
@@ -499,25 +499,36 @@ export function gitlabAttentionLabel(reason: string): string {
   }
 }
 
-export function prDiffCacheKey(cwd: string, number: number): string {
-  return `${normalizeProjectPath(cwd)}:pr:${number}`;
+export function prDiffCacheKey(
+  cwd: string,
+  number: number,
+  fullContext = false,
+): string {
+  return `${normalizeProjectPath(cwd)}:pr:${number}${fullContext ? ":full" : ""}`;
 }
 
 export function peekGithubPrDiff(
   cwd: string,
   number: number,
+  fullContext = false,
 ): GithubPrDiff | null {
-  return prDiffByKey.get(prDiffCacheKey(cwd, number)) ?? null;
+  return prDiffByKey.get(prDiffCacheKey(cwd, number, fullContext)) ?? null;
 }
 
 export async function githubPrDiff(
   cwd: string,
   number: number,
+  options?: { fullContext?: boolean },
 ): Promise<GithubPrDiff> {
-  const key = prDiffCacheKey(cwd, number);
+  const fullContext = options?.fullContext === true;
+  const key = prDiffCacheKey(cwd, number, fullContext);
   const pending = prDiffInflight.get(key);
   if (pending) return pending;
-  const promise = invoke<GithubPrDiff>("git_github_pr_diff", { cwd, number })
+  const promise = invoke<GithubPrDiff>("git_github_pr_diff", {
+    cwd,
+    number,
+    fullContext,
+  })
     .then((diff) => {
       prDiffByKey.set(key, diff);
       return diff;
diff --git a/src/lib/unifiedDiff.test.ts b/src/lib/unifiedDiff.test.ts
index 6d781ba8..e465ac2c 100644
--- a/src/lib/unifiedDiff.test.ts
+++ b/src/lib/unifiedDiff.test.ts
@@ -95,6 +95,18 @@ describe("foldUnifiedLines", () => {
       "c11",
     ]);
   });
+
+  it("keeps every line visible when context is unlimited", () => {
+    const lines: UnifiedLine[] = [
+      ...rangeContext(1, 8),
+      { kind: "del", text: "old", oldNumber: 9, newNumber: null },
+      { kind: "add", text: "new", oldNumber: null, newNumber: 9 },
+      ...rangeContext(10, 16),
+    ];
+    const blocks = foldUnifiedLines(lines, Number.POSITIVE_INFINITY);
+    expect(blocks.map((block) => block.kind)).toEqual(["hunk"]);
+    expect(blocks[0]?.kind === "hunk" && blocks[0].lines).toEqual(lines);
+  });
 });
 
 describe("blocksFromLines", () => {
diff --git a/src/surfaces/InboxPrDiff.tsx b/src/surfaces/InboxPrDiff.tsx
index 29ea7907..81f5dfc1 100644
--- a/src/surfaces/InboxPrDiff.tsx
+++ b/src/surfaces/InboxPrDiff.tsx
@@ -6,13 +6,16 @@ import { UnifiedDiffView, type UnifiedDiffFileModel } from "./UnifiedDiffView";
 
 type Props = {
   diff: GithubPrDiff;
+  /** When true, show the whole file (no fold rows). */
+  fullFile?: boolean;
 };
 
-export function InboxPrDiff({ diff }: Props) {
+export function InboxPrDiff({ diff, fullFile = false }: Props) {
   const files = useMemo(() => {
     const parsed = mergePrDiff(diff.files, parsePrPatch(diff.patch));
-    return parsed.map((file) => toModel(file, diff.truncated));
-  }, [diff]);
+    const context = fullFile ? Number.POSITIVE_INFINITY : undefined;
+    return parsed.map((file) => toModel(file, diff.truncated, context));
+  }, [diff, fullFile]);
 
   return (
     <UnifiedDiffView
@@ -26,7 +29,11 @@ export function InboxPrDiff({ diff }: Props) {
   );
 }
 
-function toModel(file: PrDiffFile, truncated: boolean): UnifiedDiffFileModel {
+function toModel(
+  file: PrDiffFile,
+  truncated: boolean,
+  context?: number,
+): UnifiedDiffFileModel {
   const lines = file.lines.map(toUnifiedLine);
   return {
     id: file.path,
@@ -44,7 +51,7 @@ function toModel(file: PrDiffFile, truncated: boolean): UnifiedDiffFileModel {
         : undefined,
     additions: file.additions,
     deletions: file.deletions,
-    blocks: blocksFromLines(lines),
+    blocks: blocksFromLines(lines, context),
   };
 }
 
diff --git a/src/surfaces/InboxView.test.ts b/src/surfaces/InboxView.test.ts
index ef20add6..871f5298 100644
--- a/src/surfaces/InboxView.test.ts
+++ b/src/surfaces/InboxView.test.ts
@@ -3,7 +3,7 @@ import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it } from "vitest";
 import type { InboxItem } from "../lib/githubTasks";
 import type { SessionSummary } from "../lib/sessionStore";
-import { InboxDetail } from "./InboxView";
+import { InboxDetail, inboxShowsFullFileDiff } from "./InboxView";
 
 function item(overrides: Partial<InboxItem> = {}): InboxItem {
   return {
@@ -75,6 +75,21 @@ describe("InboxDetail layout", () => {
     expect(header).toContain("Code");
   });
 
+  it("offers full-file diffs only for GitHub pull requests", () => {
+    expect(inboxShowsFullFileDiff(item({ kind: "pr" }))).toBe(true);
+    expect(
+      inboxShowsFullFileDiff(
+        item({
+          kind: "pr",
+          provider: "gitlab",
+          repo: "acme/platform",
+          url: "https://gitlab.example.com/acme/platform/-/merge_requests/12",
+        }),
+      ),
+    ).toBe(false);
+    expect(inboxShowsFullFileDiff(item({ kind: "issue" }))).toBe(false);
+  });
+
   it("keeps the Linear project picker beside the pinned send action", () => {
     const markup = renderDetail(
       item({
diff --git a/src/surfaces/InboxView.tsx b/src/surfaces/InboxView.tsx
index dc9e745a..55da668c 100644
--- a/src/surfaces/InboxView.tsx
+++ b/src/surfaces/InboxView.tsx
@@ -1222,6 +1222,10 @@ function InboxCard({
   );
 }
 
+export function inboxShowsFullFileDiff(item: InboxItem): boolean {
+  return item.provider === "github" && item.kind === "pr";
+}
+
 export function InboxDetail({
   item,
   cwd,
@@ -1274,6 +1278,8 @@ export function InboxDetail({
   const [loading, setLoading] = useState(cached == null);
   const [error, setError] = useState<string | null>(null);
   const [tab, setTab] = useState<"summary" | "code">("summary");
+  const [diffMode, setDiffMode] = useState<"hunks" | "full">("hunks");
+  const fullFile = inboxShowsFullFileDiff(item) && diffMode === "full";
   const [prDiff, setPrDiff] = useState<GithubPrDiff | null>(cachedDiff);
   const [diffLoading, setDiffLoading] = useState(isPr && cachedDiff == null);
   const [diffError, setDiffError] = useState<string | null>(null);
@@ -1497,7 +1503,7 @@ export function InboxDetail({
     let cancelled = false;
     const cachedDiff = gitlab
       ? peekGitlabMrDiff(item.repo, item.number)
-      : peekGithubPrDiff(item.projectPath, item.number);
+      : peekGithubPrDiff(item.projectPath, item.number, fullFile);
     if (cachedDiff) {
       setPrDiff(cachedDiff);
       setDiffLoading(false);
@@ -1509,7 +1515,7 @@ export function InboxDetail({
     }
     const pending = gitlab
       ? gitlabMrDiff(item.repo, item.number)
-      : githubPrDiff(item.projectPath, item.number);
+      : githubPrDiff(item.projectPath, item.number, { fullContext: fullFile });
     void pending
       .then((next) => {
         if (cancelled) return;
@@ -1527,7 +1533,16 @@ export function InboxDetail({
     return () => {
       cancelled = true;
     };
-  }, [gitlab, isPr, item.number, item.projectPath, item.repo, revision, tab]);
+  }, [
+    fullFile,
+    gitlab,
+    isPr,
+    item.number,
+    item.projectPath,
+    item.repo,
+    revision,
+    tab,
+  ]);
 
   const postComment = async (body: string) => {
     setPosting(true);
@@ -1802,23 +1817,57 @@ export function InboxDetail({
             ) : null}
           </header>
           {isPr ? (
-            <div
-              role="tablist"
-              aria-label={
-                gitlab ? "Merge request sections" : "Pull request sections"
-              }
-              className="flex h-9 items-stretch gap-4"
-            >
-              <InboxDetailTab
-                label="Summary"
-                selected={tab === "summary"}
-                onSelect={() => setTab("summary")}
-              />
-              <InboxDetailTab
-                label="Code"
-                selected={tab === "code"}
-                onSelect={() => setTab("code")}
-              />
+            <div className="flex h-9 items-stretch gap-4">
+              <div
+                role="tablist"
+                aria-label={
+                  gitlab ? "Merge request sections" : "Pull request sections"
+                }
+                className="flex items-stretch gap-4"
+              >
+                <InboxDetailTab
+                  label="Summary"
+                  selected={tab === "summary"}
+                  onSelect={() => setTab("summary")}
+                />
+                <InboxDetailTab
+                  label="Code"
+                  selected={tab === "code"}
+                  onSelect={() => setTab("code")}
+                />
+              </div>
+              {tab === "code" && inboxShowsFullFileDiff(item) ? (
+                <div
+                  role="group"
+                  aria-label="Diff context"
+                  className="ml-auto flex items-center self-center rounded-md border border-content/10 bg-content/[0.03] p-0.5"
+                >
+                  <button
+                    type="button"
+                    aria-pressed={diffMode === "hunks"}
+                    onClick={() => setDiffMode("hunks")}
+                    className={`rounded px-2.5 py-1 text-[11px] leading-none ${
+                      diffMode === "hunks"
+                        ? "bg-content/10 text-content"
+                        : "text-content/45 hover:text-content/70"
+                    }`}
+                  >
+                    Hunks
+                  </button>
+                  <button
+                    type="button"
+                    aria-pressed={diffMode === "full"}
+                    onClick={() => setDiffMode("full")}
+                    className={`rounded px-2.5 py-1 text-[11px] leading-none ${
+                      diffMode === "full"
+                        ? "bg-content/10 text-content"
+                        : "text-content/45 hover:text-content/70"
+                    }`}
+                  >
+                    Full file
+                  </button>
+                </div>
+              ) : null}
             </div>
           ) : null}
         </div>
@@ -1848,8 +1897,9 @@ export function InboxDetail({
               <p className="text-[13px] text-content/50">{diffError}</p>
             ) : prDiff ? (
               <InboxPrDiff
-                key={`${item.projectPath}:${item.number}:${revision}`}
+                key={`${item.projectPath}:${item.number}:${revision}:${diffMode}`}
                 diff={prDiff}
+                fullFile={fullFile}
               />
             ) : (
               <p className="text-[13px] text-content/45">No file changes</p>

From c600f7afdf3109b8013caa0c92fdeb81151684b4 Mon Sep 17 00:00:00 2001
From: Gabriel <kore.dv7@gmail.com>
Date: Mon, 14 Sep 2026 03:14:13 -0300
Subject: [PATCH 09/17] Prevent Windows console flashes from GitHub CLI (#221)

---
 src-tauri/src/fs.rs          |  1 +
 src-tauri/src/inbox_media.rs |  1 +
 src-tauri/src/lib.rs         | 25 +++++++++++++++++++++++--
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index 4b66c147..94638b6e 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -2857,6 +2857,7 @@ fn gh_run(root: &Path, args: &[&str], allow_empty: bool) -> Result<String, Strin
         .env("GH_PAGER", "cat")
         .env("GIT_PAGER", "cat");
     crate::harness::apply_gui_env(&mut cmd);
+    crate::hide_window_console(&mut cmd);
     let output = cmd.output().map_err(|error| {
         if error.kind() == ErrorKind::NotFound {
             "GitHub CLI (`gh`) is not installed.".to_string()
diff --git a/src-tauri/src/inbox_media.rs b/src-tauri/src/inbox_media.rs
index c19e51c4..3351c350 100644
--- a/src-tauri/src/inbox_media.rs
+++ b/src-tauri/src/inbox_media.rs
@@ -270,6 +270,7 @@ fn github_auth_token() -> Option<String> {
         .env("GIT_TERMINAL_PROMPT", "0")
         .env("GH_PAGER", "cat");
     crate::harness::apply_gui_env(&mut cmd);
+    crate::hide_window_console(&mut cmd);
     let output = cmd.output().ok()?;
     if !output.status.success() {
         return None;
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 1cc52781..2baf753d 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -78,12 +78,33 @@ pub(crate) fn hide_window_console(cmd: &mut std::process::Command) {
     #[cfg(windows)]
     {
         use std::os::windows::process::CommandExt;
-        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
-        cmd.creation_flags(CREATE_NO_WINDOW);
+        cmd.creation_flags(WINDOWS_BACKGROUND_CREATION_FLAGS);
     }
     let _ = cmd;
 }
 
+#[cfg(windows)]
+const WINDOWS_BACKGROUND_CREATION_FLAGS: u32 = 0x0800_0000; // CREATE_NO_WINDOW
+
+#[cfg(all(test, windows))]
+mod background_command_tests {
+    use super::*;
+
+    #[test]
+    fn background_commands_keep_piped_output_and_exit_status() {
+        assert_eq!(WINDOWS_BACKGROUND_CREATION_FLAGS, 0x0800_0000);
+
+        let mut cmd = std::process::Command::new("cmd.exe");
+        cmd.args(["/D", "/C", "(echo stdout)&(echo stderr 1>&2)&exit /b 7"]);
+        hide_window_console(&mut cmd);
+
+        let output = cmd.output().expect("background command should run");
+        assert_eq!(output.status.code(), Some(7));
+        assert!(String::from_utf8_lossy(&output.stdout).contains("stdout"));
+        assert!(String::from_utf8_lossy(&output.stderr).contains("stderr"));
+    }
+}
+
 /// Finder-launched .app bundles often omit HOME/USER/SHELL. Fall back to the
 /// passwd database so harness CLIs still find `~/.fx` and the login keychain.
 pub(crate) fn passwd_identity() -> Option<PasswdIdentity> {

From 2ce2dc423314571f6273d92c415651b1df6cbe20 Mon Sep 17 00:00:00 2001
From: Akshat Dubey <akshatdubey0808@gmail.com>
Date: Mon, 14 Sep 2026 12:26:18 +0530
Subject: [PATCH 10/17] Autofocus search when opening the sidebar project
 picker (#226)

* Autofocus search when opening the sidebar project picker

- Focus the search input via a ref when the picker opens, retrying on the next frame
- Add regression coverage for search focus on open

* Exercise deferred focus retry in project picker test

- Hold animation frames and flush the retry before asserting focus
---
 src/chrome/Sidebar.tsx           | 12 ++++++++++-
 src/chrome/SidebarRename.test.ts | 34 ++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index c23c7a67..d318475f 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -1720,6 +1720,7 @@ function SidebarProjectPicker({
   const [query, setQuery] = useState("");
   const [active, setActive] = useState(0);
   const pickerRef = useRef<HTMLDivElement>(null);
+  const searchRef = useRef<HTMLInputElement>(null);
   const [groupLabels] = useState(loadTabGroupLabels);
   const [groupColors] = useState(loadTabGroupColors);
   const [groupCustomColors] = useState(loadTabGroupCustomColors);
@@ -1762,6 +1763,15 @@ function SidebarProjectPicker({
     setActive(0);
   };
 
+  useEffect(() => {
+    if (!open) return;
+    searchRef.current?.focus();
+    const frame = window.requestAnimationFrame(() => {
+      searchRef.current?.focus();
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [open]);
+
   const pickProject = (path: string) => {
     closePicker();
     if (!sameProjectPath(path, cwd)) onSelectProject(path);
@@ -1860,7 +1870,7 @@ function SidebarProjectPicker({
               <Search className="size-4 shrink-0" strokeWidth={1.75} />
               <span className="sr-only">Search projects</span>
               <input
-                autoFocus
+                ref={searchRef}
                 value={query}
                 onChange={(event) => {
                   setQuery(event.target.value);
diff --git a/src/chrome/SidebarRename.test.ts b/src/chrome/SidebarRename.test.ts
index 06247a3b..599b269e 100644
--- a/src/chrome/SidebarRename.test.ts
+++ b/src/chrome/SidebarRename.test.ts
@@ -32,6 +32,10 @@ function renameInput(): HTMLInputElement {
   return container.querySelector("input:not([placeholder])")!;
 }
 
+function projectSearchInput(): HTMLInputElement | null {
+  return document.querySelector('input[placeholder="Search projects..."]');
+}
+
 function pressKey(target: HTMLElement, key: string) {
   const event = new KeyboardEvent("keydown", {
     key,
@@ -257,6 +261,36 @@ describe("sidebar session rename", () => {
   });
 });
 
+describe("sidebar project picker", () => {
+  it("focuses the project search input when opened", () => {
+    // Hold animation frames so the deferred focus retry runs on demand.
+    const frames: FrameRequestCallback[] = [];
+    vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+      frames.push(callback);
+      return frames.length;
+    });
+    vi.stubGlobal("cancelAnimationFrame", vi.fn());
+    props.onSelectProject = vi.fn();
+    act(() => render());
+
+    const trigger = container.querySelector<HTMLButtonElement>(
+      '[aria-label^="Switch project"]',
+    )!;
+    act(() => trigger.click());
+
+    const input = projectSearchInput();
+    expect(input).not.toBeNull();
+    expect(document.activeElement).toBe(input);
+
+    // Focus lost before the next frame is restored by the retry.
+    act(() => input!.blur());
+    expect(document.activeElement).not.toBe(input);
+    expect(frames).toHaveLength(1);
+    act(() => frames.forEach((frame) => frame(0)));
+    expect(document.activeElement).toBe(input);
+  });
+});
+
 describe("sidebar reorder affordances", () => {
   it("keeps the default cursor on reorderable tabs and folders", () => {
     props.sessions = [

From 8f31d4bd1a696631f87cd418075301e7ee8d74cc Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 07:59:00 +0100
Subject: [PATCH 11/17] Add secure user link previews

- Fetch page titles and favicons through the native host
- Render compact previews while preserving surrounding message text
- Validate public URLs and add parser and transcript tests
---
 Cargo.lock                           |   1 +
 src-tauri/Cargo.toml                 |   1 +
 src-tauri/src/lib.rs                 |   2 +
 src-tauri/src/link_preview.rs        | 526 +++++++++++++++++++++++++++
 src/chrome/Sidebar.tsx               |   2 +-
 src/index.css                        |  15 +
 src/lib/linkPreview.test.ts          |  63 ++++
 src/lib/linkPreview.ts               | 106 ++++++
 src/surfaces/AgentTranscript.test.ts |  28 ++
 src/surfaces/AgentTranscript.tsx     |  27 +-
 src/surfaces/SettingsView.tsx        |   2 +-
 src/surfaces/UserLinkPreview.tsx     |  63 ++++
 12 files changed, 830 insertions(+), 6 deletions(-)
 create mode 100644 src-tauri/src/link_preview.rs
 create mode 100644 src/lib/linkPreview.test.ts
 create mode 100644 src/lib/linkPreview.ts
 create mode 100644 src/surfaces/UserLinkPreview.tsx

diff --git a/Cargo.lock b/Cargo.lock
index 6b5f90c8..ff03f048 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2237,6 +2237,7 @@ dependencies = [
  "tauri-plugin-updater",
  "tauri-plugin-window-state",
  "ureq",
+ "url",
  "windows-sys 0.61.2",
 ]
 
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index d023c040..24f74f07 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -24,6 +24,7 @@ base64 = "0.22"
 tauri-plugin-dialog = "2"
 rusqlite = { version = "0.40.2", features = ["bundled"], default-features = false }
 ureq = { version = "2.12.1", default-features = false, features = ["tls", "gzip"] }
+url = "2.5"
 tauri-plugin-process = "2"
 
 [target.'cfg(unix)'.dependencies]
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 2baf753d..9f8651bb 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -8,6 +8,7 @@ mod gitlab;
 mod harness;
 mod inbox_media;
 mod linear;
+mod link_preview;
 #[cfg(target_os = "macos")]
 mod macos;
 mod menu;
@@ -281,6 +282,7 @@ pub fn run() {
             linear::linear_issue_details,
             linear::linear_issue_thread,
             linear::linear_issue_comment,
+            link_preview::fetch_link_preview,
             fs::git_branches,
             fs::git_checkout,
             fs::git_create_branch,
diff --git a/src-tauri/src/link_preview.rs b/src-tauri/src/link_preview.rs
new file mode 100644
index 00000000..4a38c9e9
--- /dev/null
+++ b/src-tauri/src/link_preview.rs
@@ -0,0 +1,526 @@
+use std::io::Read;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs};
+use std::time::Duration;
+
+use base64::Engine;
+use serde::Serialize;
+use url::{Host, Url};
+
+const HTTP_TIMEOUT: Duration = Duration::from_secs(7);
+const MAX_REDIRECTS: usize = 5;
+const MAX_PAGE_BYTES: usize = 512 * 1024;
+const MAX_ICON_BYTES: usize = 256 * 1024;
+const USER_AGENT: &str = "Mozilla/5.0 (compatible; MonoCode-LinkPreview/1.0)";
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LinkPreviewMetadata {
+    title: Option<String>,
+    favicon_data_url: Option<String>,
+}
+
+struct FetchedResource {
+    final_url: Url,
+    content_type: Option<String>,
+    bytes: Vec<u8>,
+}
+
+/// Fetch metadata in the native host so the webview's deliberately narrow CSP
+/// can remain intact. Every hop is checked before a request is made.
+#[tauri::command]
+pub async fn fetch_link_preview(url: String) -> Result<LinkPreviewMetadata, String> {
+    tauri::async_runtime::spawn_blocking(move || fetch_link_preview_sync(&url))
+        .await
+        .map_err(|error| error.to_string())?
+}
+
+fn fetch_link_preview_sync(raw: &str) -> Result<LinkPreviewMetadata, String> {
+    let url = parse_public_url(raw)?;
+    let page = fetch_resource(url, "text/html,application/xhtml+xml;q=0.9", MAX_PAGE_BYTES)?;
+    if !is_html(&page.content_type) {
+        return Ok(LinkPreviewMetadata {
+            title: None,
+            favicon_data_url: None,
+        });
+    }
+
+    let html = String::from_utf8_lossy(&page.bytes);
+    let title = document_title(&html);
+    let default_icon = page
+        .final_url
+        .join("/favicon.ico")
+        .map_err(|_| "Could not resolve this site's icon".to_string())?;
+    let linked_icon = document_icon_href(&html)
+        .and_then(|href| page.final_url.join(&href).ok())
+        .filter(is_http_url);
+
+    let favicon_data_url = linked_icon
+        .and_then(fetch_icon_data_url)
+        .or_else(|| fetch_icon_data_url(default_icon));
+
+    Ok(LinkPreviewMetadata {
+        title,
+        favicon_data_url,
+    })
+}
+
+fn fetch_icon_data_url(url: Url) -> Option<String> {
+    let icon = fetch_resource(url, "image/*,*/*;q=0.1", MAX_ICON_BYTES).ok()?;
+    let mime = image_mime(icon.content_type.as_deref(), &icon.bytes)?;
+    let encoded = base64::engine::general_purpose::STANDARD.encode(icon.bytes);
+    Some(format!("data:{mime};base64,{encoded}"))
+}
+
+fn fetch_resource(mut url: Url, accept: &str, max_bytes: usize) -> Result<FetchedResource, String> {
+    let agent = ureq::AgentBuilder::new()
+        .timeout(HTTP_TIMEOUT)
+        .redirects(0)
+        .build();
+
+    for _ in 0..=MAX_REDIRECTS {
+        validate_public_target(&url)?;
+        let response = match agent
+            .get(url.as_str())
+            .set("Accept", accept)
+            .set("User-Agent", USER_AGENT)
+            .call()
+        {
+            Ok(response) => response,
+            Err(ureq::Error::Status(status, response)) if is_redirect(status) => response,
+            Err(ureq::Error::Status(status, _)) => {
+                return Err(format!("Link preview request failed ({status})"));
+            }
+            Err(_) => return Err("Could not load link preview".into()),
+        };
+
+        if is_redirect(response.status()) {
+            let location = response
+                .header("Location")
+                .ok_or_else(|| "Link preview redirect has no destination".to_string())?;
+            url = url
+                .join(location)
+                .map_err(|_| "Link preview redirect is invalid".to_string())?;
+            if !is_http_url(&url) {
+                return Err("Link preview redirect is not HTTP".into());
+            }
+            continue;
+        }
+
+        if !(200..300).contains(&response.status()) {
+            return Err(format!(
+                "Link preview request failed ({})",
+                response.status()
+            ));
+        }
+        if let Some(length) = response
+            .header("Content-Length")
+            .and_then(|value| value.parse::<usize>().ok())
+        {
+            if length > max_bytes {
+                return Err("Link preview response is too large".into());
+            }
+        }
+        let content_type = response.header("Content-Type").map(str::to_string);
+        let mut reader = response.into_reader().take(max_bytes as u64 + 1);
+        let mut bytes = Vec::new();
+        reader
+            .read_to_end(&mut bytes)
+            .map_err(|_| "Could not read link preview".to_string())?;
+        if bytes.len() > max_bytes {
+            return Err("Link preview response is too large".into());
+        }
+        return Ok(FetchedResource {
+            final_url: url,
+            content_type,
+            bytes,
+        });
+    }
+
+    Err("Too many link preview redirects".into())
+}
+
+fn parse_public_url(raw: &str) -> Result<Url, String> {
+    let value = raw.trim();
+    if value.is_empty() || value.len() > 8192 {
+        return Err("Link preview URL is invalid".into());
+    }
+    let url = Url::parse(value).map_err(|_| "Link preview URL is invalid".to_string())?;
+    if !is_http_url(&url)
+        || !url.username().is_empty()
+        || url.password().is_some()
+        || url.host_str().is_none()
+    {
+        return Err("Link preview URL is invalid".into());
+    }
+    validate_public_target(&url)?;
+    Ok(url)
+}
+
+fn is_http_url(url: &Url) -> bool {
+    url.scheme() == "https" || url.scheme() == "http"
+}
+
+fn validate_public_target(url: &Url) -> Result<(), String> {
+    if !is_http_url(url) || !url.username().is_empty() || url.password().is_some() {
+        return Err("Link preview target is invalid".into());
+    }
+    let host = match url
+        .host()
+        .ok_or_else(|| "Link preview target is invalid".to_string())?
+    {
+        Host::Ipv4(ip) => return public_ip_result(IpAddr::V4(ip)),
+        Host::Ipv6(ip) => return public_ip_result(IpAddr::V6(ip)),
+        Host::Domain(host) => host.trim_end_matches('.').to_ascii_lowercase(),
+    };
+    if host == "localhost" || host.ends_with(".localhost") || host.ends_with(".local") {
+        return Err("Local addresses cannot be previewed".into());
+    }
+
+    let port = url
+        .port_or_known_default()
+        .ok_or_else(|| "Link preview target has no port".to_string())?;
+    let addresses: Vec<_> = (host.as_str(), port)
+        .to_socket_addrs()
+        .map_err(|_| "Could not resolve link preview host".to_string())?
+        .collect();
+    if addresses.is_empty() || addresses.iter().any(|address| !is_public_ip(address.ip())) {
+        return Err("Private addresses cannot be previewed".into());
+    }
+    Ok(())
+}
+
+fn public_ip_result(ip: IpAddr) -> Result<(), String> {
+    if is_public_ip(ip) {
+        Ok(())
+    } else {
+        Err("Private addresses cannot be previewed".into())
+    }
+}
+
+fn is_public_ip(ip: IpAddr) -> bool {
+    match ip {
+        IpAddr::V4(ip) => is_public_ipv4(ip),
+        IpAddr::V6(ip) => is_public_ipv6(ip),
+    }
+}
+
+fn is_public_ipv4(ip: Ipv4Addr) -> bool {
+    let [a, b, c, _] = ip.octets();
+    !(a == 0
+        || a == 10
+        || a == 127
+        || (a == 100 && (64..=127).contains(&b))
+        || (a == 169 && b == 254)
+        || (a == 172 && (16..=31).contains(&b))
+        || (a == 192 && b == 0 && c == 0)
+        || (a == 192 && b == 0 && c == 2)
+        || (a == 192 && b == 168)
+        || (a == 198 && (b == 18 || b == 19))
+        || (a == 198 && b == 51 && c == 100)
+        || (a == 203 && b == 0 && c == 113)
+        || a >= 224)
+}
+
+fn is_public_ipv6(ip: Ipv6Addr) -> bool {
+    if let Some(ipv4) = ip.to_ipv4() {
+        return is_public_ipv4(ipv4);
+    }
+    let segments = ip.segments();
+    if ip.is_unspecified()
+        || ip.is_loopback()
+        || ip.is_multicast()
+        || segments[0] & 0xfe00 == 0xfc00
+        || segments[0] & 0xffc0 == 0xfe80
+        || segments[0] & 0xffc0 == 0xfec0
+        || (segments[0] == 0x2001 && segments[1] == 0x0db8)
+    {
+        return false;
+    }
+    true
+}
+
+fn is_redirect(status: u16) -> bool {
+    matches!(status, 301 | 302 | 303 | 307 | 308)
+}
+
+fn is_html(content_type: &Option<String>) -> bool {
+    content_type.as_deref().is_none_or(|value| {
+        let mime = value.split(';').next().unwrap_or("").trim();
+        mime.eq_ignore_ascii_case("text/html") || mime.eq_ignore_ascii_case("application/xhtml+xml")
+    })
+}
+
+fn image_mime(content_type: Option<&str>, bytes: &[u8]) -> Option<&'static str> {
+    if bytes.starts_with(b"\x89PNG\r\n\x1a\n") {
+        return Some("image/png");
+    }
+    if bytes.starts_with(&[0xff, 0xd8, 0xff]) {
+        return Some("image/jpeg");
+    }
+    if bytes.starts_with(b"GIF87a") || bytes.starts_with(b"GIF89a") {
+        return Some("image/gif");
+    }
+    if bytes.len() >= 12 && bytes.starts_with(b"RIFF") && &bytes[8..12] == b"WEBP" {
+        return Some("image/webp");
+    }
+    if bytes.starts_with(&[0, 0, 1, 0]) {
+        return Some("image/x-icon");
+    }
+    match content_type
+        .and_then(|value| value.split(';').next())
+        .map(str::trim)
+        .map(str::to_ascii_lowercase)
+        .as_deref()
+    {
+        Some("image/vnd.microsoft.icon") | Some("image/x-icon") => Some("image/x-icon"),
+        _ => None,
+    }
+}
+
+fn document_title(html: &str) -> Option<String> {
+    for key in ["og:title", "twitter:title"] {
+        for tag in opening_tags(html, "meta") {
+            let marker = attribute(tag, "property").or_else(|| attribute(tag, "name"));
+            if marker
+                .as_deref()
+                .is_some_and(|value| value.eq_ignore_ascii_case(key))
+            {
+                if let Some(value) = attribute(tag, "content").and_then(clean_text) {
+                    return Some(value);
+                }
+            }
+        }
+    }
+
+    let lower = html.to_ascii_lowercase();
+    let start = lower.find("<title")?;
+    let opening_end = tag_end(html, start)?;
+    let close = lower[opening_end + 1..].find("</title>")? + opening_end + 1;
+    clean_text(html[opening_end + 1..close].to_string())
+}
+
+fn document_icon_href(html: &str) -> Option<String> {
+    opening_tags(html, "link").into_iter().find_map(|tag| {
+        let rel = attribute(tag, "rel")?;
+        if !rel
+            .split_ascii_whitespace()
+            .any(|part| part.eq_ignore_ascii_case("icon"))
+        {
+            return None;
+        }
+        attribute(tag, "href").filter(|href| !href.trim().is_empty())
+    })
+}
+
+fn opening_tags<'a>(html: &'a str, name: &str) -> Vec<&'a str> {
+    let lower = html.to_ascii_lowercase();
+    let needle = format!("<{name}");
+    let mut tags = Vec::new();
+    let mut offset = 0;
+    while let Some(relative) = lower[offset..].find(&needle) {
+        let start = offset + relative;
+        let after = start + needle.len();
+        let boundary = lower.as_bytes().get(after).copied();
+        if boundary.is_some_and(|byte| byte.is_ascii_whitespace() || byte == b'/' || byte == b'>') {
+            if let Some(end) = tag_end(html, start) {
+                tags.push(&html[start..=end]);
+                offset = end + 1;
+                continue;
+            }
+        }
+        offset = after;
+    }
+    tags
+}
+
+fn tag_end(html: &str, start: usize) -> Option<usize> {
+    let mut quote = None;
+    for (relative, byte) in html.as_bytes()[start..].iter().copied().enumerate() {
+        match (quote, byte) {
+            (Some(expected), value) if value == expected => quote = None,
+            (None, b'\'' | b'"') => quote = Some(byte),
+            (None, b'>') => return Some(start + relative),
+            _ => {}
+        }
+    }
+    None
+}
+
+fn attribute(tag: &str, wanted: &str) -> Option<String> {
+    let bytes = tag.as_bytes();
+    let mut cursor = 1;
+    while cursor < bytes.len() && is_attribute_name_byte(bytes[cursor]) {
+        cursor += 1;
+    }
+    while cursor < bytes.len() {
+        while cursor < bytes.len() && (bytes[cursor].is_ascii_whitespace() || bytes[cursor] == b'/')
+        {
+            cursor += 1;
+        }
+        let name_start = cursor;
+        while cursor < bytes.len() && is_attribute_name_byte(bytes[cursor]) {
+            cursor += 1;
+        }
+        if cursor == name_start {
+            cursor += 1;
+            continue;
+        }
+        let name = &tag[name_start..cursor];
+        while cursor < bytes.len() && bytes[cursor].is_ascii_whitespace() {
+            cursor += 1;
+        }
+        if bytes.get(cursor) != Some(&b'=') {
+            continue;
+        }
+        cursor += 1;
+        while cursor < bytes.len() && bytes[cursor].is_ascii_whitespace() {
+            cursor += 1;
+        }
+        let (value_start, value_end) = match bytes.get(cursor).copied() {
+            Some(quote @ (b'\'' | b'"')) => {
+                cursor += 1;
+                let start = cursor;
+                while cursor < bytes.len() && bytes[cursor] != quote {
+                    cursor += 1;
+                }
+                (start, cursor)
+            }
+            Some(_) => {
+                let start = cursor;
+                while cursor < bytes.len()
+                    && !bytes[cursor].is_ascii_whitespace()
+                    && bytes[cursor] != b'>'
+                {
+                    cursor += 1;
+                }
+                (start, cursor)
+            }
+            None => return None,
+        };
+        if name.eq_ignore_ascii_case(wanted) {
+            return Some(decode_entities(&tag[value_start..value_end]));
+        }
+        cursor = cursor.saturating_add(1);
+    }
+    None
+}
+
+fn is_attribute_name_byte(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b':')
+}
+
+fn clean_text(value: String) -> Option<String> {
+    let mut without_tags = String::with_capacity(value.len());
+    let mut in_tag = false;
+    for character in value.chars() {
+        match character {
+            '<' => in_tag = true,
+            '>' => in_tag = false,
+            _ if !in_tag => without_tags.push(character),
+            _ => {}
+        }
+    }
+    let decoded = decode_entities(&without_tags);
+    let collapsed = decoded.split_whitespace().collect::<Vec<_>>().join(" ");
+    if collapsed.is_empty() {
+        return None;
+    }
+    Some(collapsed.chars().take(240).collect())
+}
+
+fn decode_entities(value: &str) -> String {
+    let mut result = String::with_capacity(value.len());
+    let mut rest = value;
+    while let Some(index) = rest.find('&') {
+        result.push_str(&rest[..index]);
+        let entity_start = &rest[index + 1..];
+        let Some(end) = entity_start.find(';').filter(|end| *end <= 12) else {
+            result.push('&');
+            rest = entity_start;
+            continue;
+        };
+        let entity = &entity_start[..end];
+        let decoded = match entity {
+            "amp" => Some('&'),
+            "lt" => Some('<'),
+            "gt" => Some('>'),
+            "quot" => Some('"'),
+            "apos" | "#39" => Some('\''),
+            "nbsp" => Some(' '),
+            value if value.starts_with("#x") || value.starts_with("#X") => {
+                u32::from_str_radix(&value[2..], 16)
+                    .ok()
+                    .and_then(char::from_u32)
+            }
+            value if value.starts_with('#') => value[1..].parse().ok().and_then(char::from_u32),
+            _ => None,
+        };
+        if let Some(character) = decoded {
+            result.push(character);
+        } else {
+            result.push('&');
+            result.push_str(entity);
+            result.push(';');
+        }
+        rest = &entity_start[end + 1..];
+    }
+    result.push_str(rest);
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_social_title_and_icon_attributes_in_any_order() {
+        let html = r#"
+          <html><head>
+            <title>Fallback &amp; title</title>
+            <meta content="A nicer &quot;title&quot;" property="og:title">
+            <link href="/assets/icon.png" sizes="32x32" rel="shortcut icon">
+          </head></html>
+        "#;
+        assert_eq!(document_title(html).as_deref(), Some("A nicer \"title\""));
+        assert_eq!(
+            document_icon_href(html).as_deref(),
+            Some("/assets/icon.png")
+        );
+    }
+
+    #[test]
+    fn falls_back_to_the_document_title() {
+        let html = "<TITLE>  Example <b>docs</b> &amp; API  </TITLE>";
+        assert_eq!(document_title(html).as_deref(), Some("Example docs & API"));
+    }
+
+    #[test]
+    fn rejects_local_and_special_networks() {
+        for address in [
+            "127.0.0.1",
+            "10.0.0.1",
+            "169.254.1.1",
+            "172.20.1.1",
+            "192.168.1.1",
+            "100.64.0.1",
+            "192.0.2.1",
+            "::1",
+            "::127.0.0.1",
+            "::ffff:127.0.0.1",
+            "fc00::1",
+            "fe80::1",
+        ] {
+            assert!(!is_public_ip(address.parse().unwrap()), "{address}");
+        }
+        assert!(is_public_ip("8.8.8.8".parse().unwrap()));
+        assert!(is_public_ip("2606:4700:4700::1111".parse().unwrap()));
+    }
+
+    #[test]
+    fn accepts_only_plain_http_urls() {
+        assert!(parse_public_url("file:///tmp/page.html").is_err());
+        assert!(parse_public_url("https://user:secret@example.com").is_err());
+        assert!(parse_public_url("http://localhost:3000").is_err());
+        assert!(parse_public_url("http://[::1]:3000").is_err());
+    }
+}
diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index d318475f..38cc0f48 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -1144,7 +1144,7 @@ function SidebarComponent({
   const sidebarContent = (
     <aside
       ref={resize.setPaneRef}
-      className="sidebar-glass relative flex h-full min-h-0 shrink-0 flex-col border-r border-content/10"
+      className="body-glass relative flex h-full min-h-0 shrink-0 flex-col border-r border-content/10"
     >
       {railVisible ? (
         <>
diff --git a/src/index.css b/src/index.css
index 58c67b03..a41a96de 100644
--- a/src/index.css
+++ b/src/index.css
@@ -230,6 +230,21 @@ html.chat-background-empty-only
   content-visibility: visible;
 }
 
+.user-message-with-link {
+  display: block;
+}
+
+.user-link-preview {
+  display: inline;
+  white-space: normal;
+}
+
+.user-link-preview-title {
+  display: inline;
+  white-space: normal;
+  overflow-wrap: anywhere;
+}
+
 /*
  * After a send, the live turn fills the transcript viewport so the prompt sits
  * at the top. Switching tabs keeps this. Closing the tab drops it, so opening
diff --git a/src/lib/linkPreview.test.ts b/src/lib/linkPreview.test.ts
new file mode 100644
index 00000000..7498d564
--- /dev/null
+++ b/src/lib/linkPreview.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { parseStandaloneHttpUrl, parseUserMessageLink } from "./linkPreview";
+
+describe("parseStandaloneHttpUrl", () => {
+  it("normalizes a standalone web URL for display", () => {
+    expect(
+      parseStandaloneHttpUrl(
+        "  https://www.example.com/docs/start?q=one#intro  ",
+      ),
+    ).toEqual({
+      url: "https://www.example.com/docs/start?q=one#intro",
+      host: "example.com",
+      displayUrl: "example.com/docs/start?q=one#intro",
+    });
+  });
+
+  it("keeps a root URL compact", () => {
+    expect(parseStandaloneHttpUrl("http://example.com/")?.displayUrl).toBe(
+      "example.com",
+    );
+  });
+
+  it("does not turn prose or credentialed URLs into preview cards", () => {
+    expect(
+      parseStandaloneHttpUrl("take a look at https://example.com"),
+    ).toBeNull();
+    expect(
+      parseStandaloneHttpUrl("https://person:secret@example.com"),
+    ).toBeNull();
+    expect(parseStandaloneHttpUrl("file:///tmp/example.html")).toBeNull();
+  });
+});
+
+describe("parseUserMessageLink", () => {
+  it("extracts a URL followed by a comment", () => {
+    expect(
+      parseUserMessageLink(
+        "https://github.com/hardbeat920/monocode/pull/226 check this",
+      ),
+    ).toEqual({
+      link: {
+        url: "https://github.com/hardbeat920/monocode/pull/226",
+        host: "github.com",
+        displayUrl: "github.com/hardbeat920/monocode/pull/226",
+      },
+      beforeText: "",
+      afterText: " check this",
+    });
+  });
+
+  it("preserves prose around a URL and drops sentence punctuation", () => {
+    const result = parseUserMessageLink(
+      "Please review (https://example.com/docs), thanks",
+    );
+    expect(result?.beforeText).toBe("Please review (");
+    expect(result?.afterText).toBe("), thanks");
+    expect(result?.link.url).toBe("https://example.com/docs");
+  });
+
+  it("returns null when there is no valid web URL", () => {
+    expect(parseUserMessageLink("Nothing to preview here")).toBeNull();
+  });
+});
diff --git a/src/lib/linkPreview.ts b/src/lib/linkPreview.ts
new file mode 100644
index 00000000..b08eb81e
--- /dev/null
+++ b/src/lib/linkPreview.ts
@@ -0,0 +1,106 @@
+import { invoke } from "@tauri-apps/api/core";
+
+export type UserLink = {
+  url: string;
+  host: string;
+  displayUrl: string;
+};
+
+export type UserMessageLink = {
+  link: UserLink;
+  beforeText: string;
+  afterText: string;
+};
+
+export type LinkPreviewMetadata = {
+  title: string | null;
+  faviconDataUrl: string | null;
+};
+
+const metadataCache = new Map<string, Promise<LinkPreviewMetadata>>();
+
+/** Find the first web URL and preserve the rest of the user's message. */
+export function parseUserMessageLink(text: string): UserMessageLink | null {
+  const match = /https?:\/\/[^\s<>"']+/i.exec(text);
+  if (!match) return null;
+
+  const value = trimUrlPunctuation(match[0]);
+  const link = parseHttpUrl(value);
+  if (!link) return null;
+
+  return {
+    link,
+    beforeText: text.slice(0, match.index),
+    afterText: text.slice(match.index + value.length),
+  };
+}
+
+/** Kept as a small utility for callers that need the stricter exact-URL rule. */
+export function parseStandaloneHttpUrl(text: string): UserLink | null {
+  const value = text.trim();
+  if (!value || /\s/.test(value)) return null;
+  return parseHttpUrl(value);
+}
+
+function parseHttpUrl(value: string): UserLink | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return null;
+  }
+
+  if (
+    (parsed.protocol !== "https:" && parsed.protocol !== "http:") ||
+    parsed.username ||
+    parsed.password ||
+    !parsed.hostname
+  ) {
+    return null;
+  }
+
+  const host = parsed.hostname.replace(/\.$/, "").toLowerCase();
+  const displayHost = host.startsWith("www.") ? host.slice(4) : host;
+  const suffix = `${parsed.pathname === "/" ? "" : parsed.pathname}${parsed.search}${parsed.hash}`;
+
+  return {
+    url: parsed.href,
+    host: displayHost,
+    displayUrl: `${displayHost}${suffix}`,
+  };
+}
+
+function trimUrlPunctuation(value: string): string {
+  let end = value.length;
+  while (end > 0 && /[.,!;:]/.test(value[end - 1])) end -= 1;
+
+  for (const [opening, closing] of [
+    ["(", ")"],
+    ["[", "]"],
+    ["{", "}"],
+  ]) {
+    while (
+      value.slice(0, end).endsWith(closing) &&
+      count(value.slice(0, end), closing) > count(value.slice(0, end), opening)
+    ) {
+      end -= 1;
+    }
+  }
+  return value.slice(0, end);
+}
+
+function count(value: string, character: string): number {
+  return value.split(character).length - 1;
+}
+
+export function fetchLinkPreviewMetadata(
+  url: string,
+): Promise<LinkPreviewMetadata> {
+  const cached = metadataCache.get(url);
+  if (cached) return cached;
+
+  const pending = invoke<LinkPreviewMetadata>("fetch_link_preview", { url });
+  metadataCache.set(url, pending);
+  pending.catch(() => metadataCache.delete(url));
+  return pending;
+}
diff --git a/src/surfaces/AgentTranscript.test.ts b/src/surfaces/AgentTranscript.test.ts
index 8fb73f33..5df1d385 100644
--- a/src/surfaces/AgentTranscript.test.ts
+++ b/src/surfaces/AgentTranscript.test.ts
@@ -25,6 +25,34 @@ function render(
 }
 
 describe("AgentTranscript collapsed work", () => {
+  it("renders a standalone user URL as a compact link preview", () => {
+    const markup = render([
+      { id: "user", role: "user", text: "https://www.example.com/docs" },
+    ]);
+
+    expect(markup).toContain("data-user-link-preview");
+    expect(markup).toContain("example.com/docs");
+    expect(markup).toContain("Open example.com");
+    expect(markup).toContain("user-link-preview-title");
+    expect(markup).toContain("user-message-with-link");
+    expect(markup).not.toContain("text-ellipsis");
+  });
+
+  it("keeps surrounding prose and previews its first URL", () => {
+    const markup = render([
+      {
+        id: "user",
+        role: "user",
+        text: "Please check https://example.com/docs",
+      },
+    ]);
+
+    expect(markup).toContain("data-user-link-preview");
+    expect(markup).toContain("Please check");
+    expect(markup).toContain("Open example.com");
+    expect(markup).not.toContain("Please check https://example.com/docs");
+  });
+
   it("keeps each completed turn's recorded model label", () => {
     const blocks: Block[] = [
       {
diff --git a/src/surfaces/AgentTranscript.tsx b/src/surfaces/AgentTranscript.tsx
index 9226b685..ebf36ba7 100644
--- a/src/surfaces/AgentTranscript.tsx
+++ b/src/surfaces/AgentTranscript.tsx
@@ -71,6 +71,8 @@ import { useTranscriptSelection } from "../hooks/useTranscriptSelection";
 import type { TranscriptLayout } from "../lib/appearance";
 import { AgentMarkdown } from "./AgentMarkdown";
 import { TranscriptSelectionMenu } from "./TranscriptSelectionMenu";
+import { parseUserMessageLink } from "../lib/linkPreview";
+import { UserLinkPreview } from "./UserLinkPreview";
 import {
   activityPhaseTitle,
   activityStillRunning,
@@ -1091,10 +1093,14 @@ function UserMessageBlock({
   const [expanded, setExpanded] = useState(false);
   const [overflows, setOverflows] = useState(false);
   const [singleLine, setSingleLine] = useState(false);
-  const textRef = useRef<HTMLPreElement>(null);
+  const textRef = useRef<HTMLElement>(null);
   const card = block.secondOpinion;
   const note = block.noteCard;
   const text = card && card.kind !== "handoff" ? "" : block.text;
+  const messageLink = text ? parseUserMessageLink(text) : null;
+  const displayText = messageLink
+    ? `${messageLink.beforeText}${messageLink.afterText}`
+    : text;
   const chat = layout === "chat";
   const textOnly =
     Boolean(text) && !block.attachments?.length && !card && !note;
@@ -1178,12 +1184,25 @@ function UserMessageBlock({
             <SecondOpinionCard card={card} />
           </div>
         ) : null}
-        {text ? (
+        {messageLink ? (
+          <div
+            ref={(element) => {
+              textRef.current = element;
+            }}
+            className="user-message-with-link min-w-0 whitespace-pre-wrap break-words font-sans text-sm"
+          >
+            {messageLink.beforeText}
+            <UserLinkPreview link={messageLink.link} />
+            {messageLink.afterText}
+          </div>
+        ) : displayText ? (
           <pre
-            ref={textRef}
+            ref={(element) => {
+              textRef.current = element;
+            }}
             className={`min-w-0 whitespace-pre-wrap break-words font-sans text-sm ${expanded ? "" : "line-clamp-4"}`}
           >
-            {text}
+            {displayText}
           </pre>
         ) : null}
       </div>
diff --git a/src/surfaces/SettingsView.tsx b/src/surfaces/SettingsView.tsx
index 1a996105..05b44846 100644
--- a/src/surfaces/SettingsView.tsx
+++ b/src/surfaces/SettingsView.tsx
@@ -1267,7 +1267,7 @@ function AppearancePage({ appearance }: { appearance: AppearanceSettings }) {
         description={
           glassDisabled
             ? "Light mode always uses an opaque window. Your dark-mode value is preserved."
-            : "How much of the desktop shows through the sidebar and the project rail."
+            : "How much of the desktop shows through the project rail and other glass panes."
         }
       >
         <Slider
diff --git a/src/surfaces/UserLinkPreview.tsx b/src/surfaces/UserLinkPreview.tsx
new file mode 100644
index 00000000..33a15651
--- /dev/null
+++ b/src/surfaces/UserLinkPreview.tsx
@@ -0,0 +1,63 @@
+import { useEffect, useState } from "react";
+import { openUrl } from "@tauri-apps/plugin-opener";
+import {
+  fetchLinkPreviewMetadata,
+  type LinkPreviewMetadata,
+  type UserLink,
+} from "../lib/linkPreview";
+
+export function UserLinkPreview({ link }: { link: UserLink }) {
+  const [metadata, setMetadata] = useState<LinkPreviewMetadata | null>(null);
+  const [faviconFailed, setFaviconFailed] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    setMetadata(null);
+    setFaviconFailed(false);
+    void fetchLinkPreviewMetadata(link.url)
+      .then((value) => {
+        if (!cancelled) setMetadata(value);
+      })
+      .catch(() => undefined);
+    return () => {
+      cancelled = true;
+    };
+  }, [link.url]);
+
+  const title = metadata?.title?.trim() || link.host;
+  const favicon = faviconFailed ? null : metadata?.faviconDataUrl;
+
+  return (
+    <a
+      href={link.url}
+      data-user-link-preview
+      title={link.url}
+      aria-label={`Open ${title}`}
+      className="user-link-preview group mx-0.5 text-sky-400/90 hover:text-sky-300 hover:underline"
+      onClick={(event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        void openUrl(link.url).catch((error) => {
+          console.error("Failed to open web link:", error);
+        });
+      }}
+    >
+      <span className="mr-1 inline-flex size-4 items-center justify-center overflow-hidden rounded bg-background-base/50 align-[-0.125em] text-[9px] font-semibold uppercase text-content/55">
+        {favicon ? (
+          <img
+            src={favicon}
+            alt=""
+            draggable={false}
+            className="size-3.5 object-contain"
+            onError={() => setFaviconFailed(true)}
+          />
+        ) : (
+          link.host.charAt(0)
+        )}
+      </span>
+      <span className="user-link-preview-title font-medium group-hover:underline">
+        {title}
+      </span>
+    </a>
+  );
+}

From 52e542004871ae498a1b9bbd5f9795687da50ae0 Mon Sep 17 00:00:00 2001
From: elijah7x <51269401+elijah7x@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:29:21 +0800
Subject: [PATCH 12/17] Fix OMP advisor interjections folding away complete
 answers (#156)

* Fix OMP advisor interjection rendering

* fix: restore OMP interjections in persisted sessions

* fix: preserve OMP advisor status and split continuations

* fix: collapse long interjection bodies by default

* fix: recover OMP interjections along active ancestry

* fix: preserve assistant streams across advisor status rows

* fix: verify status-split prose against all active OMP assistant messages

* fix: enforce interjection boundaries and occurrence-aware repair

* test: cover stacked interjection boundaries and occupancy caps

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix: align status-split repair to source message order

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix: decide status-split welds by in-order source alignment

A matching combined text can be a message the transcript never stored, so
the cursor check welded two real messages whenever fragments coincided with
later source slots. Decide each candidate against the optimal in-order
alignment instead: singles claim their earliest source slot, a weld wins
only when it explains at least as much, ties resolve toward earlier source
positions, and a weld may never land behind the first fragment's own slot.
Chain candidates repair multi-status splits in one idempotent pass, and
budget bounds fall back to the cursor rule on pathological transcripts.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

* Fail closed when status-split alignment exceeds its budget

The persisted repair used to fall back to a linear first-pair matcher once
the in-order alignment ran past its depth/memo/text budget. That matcher
can re-weld separate messages, and the result is written back to the
session store. Return the original blocks unmerged instead.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 src-tauri/src/fs.rs                           | 470 +++++++++++++-
 src-tauri/src/lib.rs                          |   2 +
 src/lib/fs.ts                                 |  35 ++
 src/lib/harness/apply.test.ts                 | 146 +++++
 src/lib/harness/apply.ts                      |  33 +-
 src/lib/harness/ompLive.test.ts               | 105 ++++
 src/lib/harness/piFamily.ts                   |  75 +++
 src/lib/harness/types.ts                      |   2 +
 src/lib/ompInterjections.test.ts              | 585 ++++++++++++++++++
 src/lib/ompInterjections.ts                   | 362 +++++++++++
 src/lib/session.ts                            |  11 +
 src/lib/sessionStore.test.ts                  |  47 ++
 src/lib/sessionStore.ts                       |  52 +-
 .../AgentTranscript.interjection.test.ts      |  89 +++
 src/surfaces/AgentTranscript.test.ts          |  21 +
 src/surfaces/AgentTranscript.tsx              |  91 +++
 src/surfaces/transcriptActivity.test.ts       |  21 +
 src/surfaces/transcriptActivity.ts            |   4 +
 18 files changed, 2142 insertions(+), 9 deletions(-)
 create mode 100644 src/lib/ompInterjections.test.ts
 create mode 100644 src/lib/ompInterjections.ts
 create mode 100644 src/surfaces/AgentTranscript.interjection.test.ts

diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index 94638b6e..fb0cc005 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -1,5 +1,5 @@
 use std::collections::{HashMap, HashSet};
-use std::io::{ErrorKind, Read, Write};
+use std::io::{BufRead, BufReader, ErrorKind, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::Mutex;
@@ -22,6 +22,312 @@ pub struct DirEntry {
     ignored: bool,
 }
 
+#[derive(Serialize, Debug, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OmpInterjectionAnchor {
+    id: String,
+    after_assistant_text: String,
+    after_occurrence: usize,
+    after_assistant_text_concat: String,
+    after_concat_occurrence: usize,
+    /// A directly following text-only answer can have been coalesced into the
+    /// parent block by old builds. Require both full texts before splitting it.
+    following_assistant_text: Option<String>,
+    following_assistant_text_concat: Option<String>,
+    text: String,
+    custom_type: String,
+    severity: Option<String>,
+}
+
+/// One active-path assistant message in file order. Both join forms of its
+/// text parts are alternatives for the same message, never two messages.
+#[derive(Serialize, Debug, PartialEq, Eq)]
+pub struct OmpAssistantText {
+    text: String,
+    concat: String,
+}
+
+/// Recover displayed OMP custom messages that older MonoCode builds omitted
+/// from their persisted transcript. The provider id is already stored with the
+/// session; matching the original JSONL keeps the repair deterministic instead
+/// of guessing from neighbouring reasoning text.
+#[tauri::command(async)]
+pub fn omp_session_interjections(
+    provider_session_id: String,
+) -> Result<Vec<OmpInterjectionAnchor>, String> {
+    let Some(path) = omp_session_path(&provider_session_id)? else {
+        return Ok(Vec::new());
+    };
+    parse_omp_interjections(&path)
+}
+
+#[tauri::command(async)]
+pub fn omp_active_assistant_texts(
+    provider_session_id: String,
+) -> Result<Vec<OmpAssistantText>, String> {
+    let Some(path) = omp_session_path(&provider_session_id)? else {
+        return Ok(Vec::new());
+    };
+    active_omp_assistant_texts(&path)
+}
+
+fn omp_session_path(provider_session_id: &str) -> Result<Option<PathBuf>, String> {
+    if provider_session_id.is_empty()
+        || !provider_session_id
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-' || byte == b'_')
+    {
+        return Err("Invalid OMP provider session id".into());
+    }
+    let root = dirs_home()
+        .map(PathBuf::from)
+        .ok_or("Home directory is unavailable")?
+        .join(".omp/agent/sessions");
+    Ok(find_omp_session_file(&root, provider_session_id))
+}
+
+fn find_omp_session_file(root: &Path, provider_session_id: &str) -> Option<PathBuf> {
+    let suffix = format!("_{provider_session_id}.jsonl");
+    let projects = std::fs::read_dir(root).ok()?;
+    for project in projects.flatten() {
+        let path = project.path();
+        if path.is_file()
+            && path
+                .file_name()
+                .and_then(|name| name.to_str())
+                .is_some_and(|name| name.ends_with(&suffix))
+        {
+            return Some(path);
+        }
+        if !path.is_dir() {
+            continue;
+        }
+        let Ok(entries) = std::fs::read_dir(path) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            let candidate = entry.path();
+            if candidate.is_file()
+                && candidate
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .is_some_and(|name| name.ends_with(&suffix))
+            {
+                return Some(candidate);
+            }
+        }
+    }
+    None
+}
+
+fn omp_message_text(value: &serde_json::Value, separator: &str) -> String {
+    if let Some(text) = value.as_str() {
+        return text.to_owned();
+    }
+    value
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(|part| {
+            (part.get("type").and_then(serde_json::Value::as_str) == Some("text"))
+                .then(|| part.get("text").and_then(serde_json::Value::as_str))
+                .flatten()
+        })
+        .collect::<Vec<_>>()
+        .join(separator)
+}
+
+fn read_omp_entries(path: &Path) -> Result<Vec<serde_json::Value>, String> {
+    let file = std::fs::File::open(path).map_err(|error| format!("{}: {error}", path.display()))?;
+    let mut entries = Vec::new();
+    for line in BufReader::new(file).lines() {
+        let Ok(line) = line else { continue };
+        let Ok(value) = serde_json::from_str::<serde_json::Value>(&line) else {
+            continue;
+        };
+        entries.push(value);
+    }
+    Ok(entries)
+}
+
+fn omp_active_ids(entries: &[serde_json::Value]) -> HashSet<&str> {
+    let nodes: HashMap<_, _> = entries
+        .iter()
+        .filter_map(|value| value["id"].as_str().map(|id| (id, value)))
+        .collect();
+    let mut active = HashSet::new();
+    let mut cursor = entries.last().and_then(|value| value["id"].as_str());
+    while let Some(id) = cursor {
+        if !active.insert(id) {
+            break;
+        }
+        cursor = nodes.get(id).and_then(|value| value["parentId"].as_str());
+    }
+    active
+}
+
+// Return the ordered sequence, not per-text counts: a status split may only
+// be merged with the message at its own source position.
+fn active_omp_assistant_texts(path: &Path) -> Result<Vec<OmpAssistantText>, String> {
+    let entries = read_omp_entries(path)?;
+    let active = omp_active_ids(&entries);
+    Ok(entries
+        .iter()
+        .filter(|value| {
+            value["type"] == "message"
+                && value["message"]["role"] == "assistant"
+                && value["id"].as_str().is_some_and(|id| active.contains(id))
+        })
+        .map(|value| {
+            let content = &value["message"]["content"];
+            OmpAssistantText {
+                text: omp_message_text(content, "\n"),
+                concat: omp_message_text(content, ""),
+            }
+        })
+        .filter(|message| !message.text.trim().is_empty())
+        .collect())
+}
+
+fn parse_omp_interjections(path: &Path) -> Result<Vec<OmpInterjectionAnchor>, String> {
+    let entries = read_omp_entries(path)?;
+    let nodes: HashMap<_, _> = entries
+        .iter()
+        .filter_map(|value| value["id"].as_str().map(|id| (id, value)))
+        .collect();
+    let active = omp_active_ids(&entries);
+    let mut assistants: HashMap<&str, (String, usize, String, usize)> = HashMap::new();
+    let mut occurrences: HashMap<String, usize> = HashMap::new();
+    let mut concat_occurrences: HashMap<String, usize> = HashMap::new();
+    let mut out: Vec<OmpInterjectionAnchor> = Vec::new();
+    // Metadata and compaction participate in ancestry, not anchor text.
+    // Keep file order for occurrences and notes, but exclude abandoned branches.
+    for value in &entries {
+        if !value["id"].as_str().is_some_and(|id| active.contains(id)) {
+            continue;
+        }
+        match value.get("type").and_then(serde_json::Value::as_str) {
+            Some("message")
+                if value
+                    .pointer("/message/role")
+                    .and_then(serde_json::Value::as_str)
+                    == Some("assistant") =>
+            {
+                let Some(id) = value.get("id").and_then(serde_json::Value::as_str) else {
+                    continue;
+                };
+                let text = omp_message_text(&value["message"]["content"], "\n");
+                let concat_text = omp_message_text(&value["message"]["content"], "");
+                if text.trim().is_empty() {
+                    continue;
+                }
+                if let Some(anchor) = out.last_mut() {
+                    let text_only = value["message"]["content"]
+                        .as_array()
+                        .is_some_and(|parts| parts.iter().all(|part| part["type"] == "text"));
+                    if text_only
+                        && value.get("parentId").and_then(serde_json::Value::as_str)
+                            == Some(anchor.id.as_str())
+                    {
+                        anchor.following_assistant_text = Some(text.clone());
+                        anchor.following_assistant_text_concat = Some(concat_text.clone());
+                    }
+                }
+                let occurrence = occurrences.entry(text.clone()).or_default();
+                *occurrence += 1;
+                let concat_occurrence = concat_occurrences.entry(concat_text.clone()).or_default();
+                *concat_occurrence += 1;
+                assistants.insert(id, (text, *occurrence, concat_text, *concat_occurrence));
+            }
+            Some("custom_message")
+                if value.get("display").and_then(serde_json::Value::as_bool) == Some(true) =>
+            {
+                let Some(id) = value.get("id").and_then(serde_json::Value::as_str) else {
+                    continue;
+                };
+                let Some(parent_id) = value.get("parentId").and_then(serde_json::Value::as_str)
+                else {
+                    continue;
+                };
+                let mut ancestor = Some(parent_id);
+                let mut seen = HashSet::new();
+                let mut assistant = None;
+                while let Some(id) = ancestor {
+                    if !active.contains(id) || !seen.insert(id) {
+                        break;
+                    }
+                    if let Some(found) = assistants.get(id) {
+                        assistant = Some(found);
+                        break;
+                    }
+                    let Some(parent) = nodes.get(id) else { break };
+                    if matches!(
+                        parent
+                            .pointer("/message/role")
+                            .and_then(serde_json::Value::as_str),
+                        Some("user" | "assistant")
+                    ) {
+                        break;
+                    }
+                    ancestor = parent["parentId"].as_str();
+                }
+                let Some((after_assistant_text, after_occurrence, concat_text, concat_occurrence)) =
+                    assistant
+                else {
+                    continue;
+                };
+                let custom_type = value
+                    .get("customType")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or("custom")
+                    .to_owned();
+                let mut severity = None;
+                let mut note_bodies = Vec::new();
+                if custom_type == "advisor" {
+                    for note in value
+                        .pointer("/details/notes")
+                        .and_then(serde_json::Value::as_array)
+                        .into_iter()
+                        .flatten()
+                    {
+                        if let Some(body) = note.get("note").and_then(serde_json::Value::as_str) {
+                            note_bodies.push(body);
+                        }
+                        let next = note.get("severity").and_then(serde_json::Value::as_str);
+                        if next == Some("blocker")
+                            || (next == Some("concern") && severity.as_deref() != Some("blocker"))
+                            || (next == Some("nit") && severity.is_none())
+                        {
+                            severity = next.map(str::to_owned);
+                        }
+                    }
+                }
+                let text = if note_bodies.is_empty() {
+                    omp_message_text(&value["content"], "\n")
+                } else {
+                    note_bodies.join("\n\n")
+                };
+                // Tool results, metadata and note chains seal the same preceding
+                // assistant prose. Notes resolving there stack in source order.
+                out.push(OmpInterjectionAnchor {
+                    id: id.to_owned(),
+                    after_assistant_text: after_assistant_text.clone(),
+                    after_occurrence: *after_occurrence,
+                    after_assistant_text_concat: concat_text.clone(),
+                    after_concat_occurrence: *concat_occurrence,
+                    following_assistant_text: None,
+                    following_assistant_text_concat: None,
+                    text,
+                    custom_type,
+                    severity,
+                });
+            }
+            _ => {}
+        }
+    }
+    Ok(out)
+}
+
 /// Immediate children of `path` (project tree). Folders first, then files.
 #[tauri::command(async)]
 pub fn list_dir(path: String) -> Result<Vec<DirEntry>, String> {
@@ -4282,6 +4588,168 @@ mod tests {
 
     static TMP_SEQ: AtomicU64 = AtomicU64::new(0);
 
+    fn assistant_text(text: &str, concat: &str) -> OmpAssistantText {
+        OmpAssistantText {
+            text: text.into(),
+            concat: concat.into(),
+        }
+    }
+
+    #[test]
+    fn omp_active_assistant_texts_keep_active_message_order_with_both_forms() {
+        let dir = tmp("omp-active-texts");
+        let path = dir.0.join("session.jsonl");
+        let records = [
+            serde_json::json!({"type":"message","id":"u","message":{"role":"user","content":"User only"}}),
+            serde_json::json!({"type":"message","id":"abandoned","parentId":"u","message":{"role":"assistant","content":"Off branch"}}),
+            serde_json::json!({"type":"message","id":"a","parentId":"u","message":{"role":"assistant","content":[{"type":"text","text":"First."},{"type":"thinking","thinking":"Hidden"},{"type":"text","text":"Second."}]}}),
+            serde_json::json!({"type":"message","id":"tool","parentId":"a","message":{"role":"assistant","content":[{"type":"toolCall","name":"read"}]}}),
+            serde_json::json!({"type":"message","id":"b","parentId":"tool","message":{"role":"assistant","content":"Plain"}}),
+            serde_json::json!({"type":"custom_message","id":"note","parentId":"b","content":"Note only"}),
+        ];
+        let jsonl = records.iter().map(|v| format!("{v}\n")).collect::<String>();
+        std::fs::write(&path, jsonl).unwrap();
+        assert_eq!(
+            active_omp_assistant_texts(&path).unwrap(),
+            [
+                assistant_text("First.\nSecond.", "First.Second."),
+                assistant_text("Plain", "Plain"),
+            ]
+        );
+    }
+
+    #[test]
+    fn omp_active_assistant_texts_repeat_equal_messages_in_file_order() {
+        let dir = tmp("omp-active-texts-repeats");
+        let path = dir.0.join("session.jsonl");
+        let records = [
+            serde_json::json!({"type":"message","id":"a","message":{"role":"assistant","content":"First."}}),
+            serde_json::json!({"type":"message","id":"off","parentId":"a","message":{"role":"assistant","content":"First.Second."}}),
+            serde_json::json!({"type":"message","id":"b","parentId":"a","message":{"role":"assistant","content":[{"type":"text","text":"Second."}]}}),
+            serde_json::json!({"type":"message","id":"c","parentId":"b","message":{"role":"assistant","content":"First.Second."}}),
+            serde_json::json!({"type":"message","id":"d","parentId":"c","message":{"role":"assistant","content":"First.Second."}}),
+        ];
+        std::fs::write(
+            &path,
+            records.iter().map(|v| format!("{v}\n")).collect::<String>(),
+        )
+        .unwrap();
+        assert_eq!(
+            active_omp_assistant_texts(&path).unwrap(),
+            [
+                assistant_text("First.", "First."),
+                assistant_text("Second.", "Second."),
+                assistant_text("First.Second.", "First.Second."),
+                assistant_text("First.Second.", "First.Second."),
+            ]
+        );
+    }
+
+    #[test]
+    fn omp_interjections_require_displayed_assistant_anchors() {
+        let dir = tmp("omp-interjections");
+        let path = dir.0.join("session.jsonl");
+        std::fs::write(
+            &path,
+            concat!(
+                "{\"type\":\"message\",\"id\":\"u\",\"message\":{\"role\":\"user\",\"content\":\"Go\"}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"orphan\",\"parentId\":\"u\",\"display\":true}\n",
+                "{\"type\":\"message\",\"id\":\"a1\",\"parentId\":\"orphan\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Answer\"}]}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"hidden\",\"parentId\":\"a1\",\"display\":false}\n",
+                "invalid partial line\n",
+                "{\"type\":\"message\",\"id\":\"a2\",\"parentId\":\"hidden\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Answer\"}]}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"review\",\"parentId\":\"a2\",\"display\":true,\"customType\":\"advisor\",\"details\":{\"notes\":[{\"note\":\"First\",\"severity\":\"nit\"},{\"note\":\"Second\",\"severity\":\"blocker\"}]}}\n",
+                "{\"type\":\"message\",\"id\":\"a3\",\"parentId\":\"review\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Checked\"}]}}\n",
+            ),
+        )
+        .unwrap();
+        let anchors = parse_omp_interjections(&path).unwrap();
+        assert_eq!(anchors.len(), 1);
+        assert_eq!(anchors[0].after_assistant_text, "Answer");
+        assert_eq!(anchors[0].after_occurrence, 2);
+        assert_eq!(
+            anchors[0].following_assistant_text.as_deref(),
+            Some("Checked")
+        );
+        assert_eq!(anchors[0].text, "First\n\nSecond");
+        assert_eq!(anchors[0].severity.as_deref(), Some("blocker"));
+    }
+
+    #[test]
+    fn omp_interjections_do_not_coalesce_across_reasoning() {
+        let dir = tmp("omp-interjections-reasoning");
+        let path = dir.0.join("session.jsonl");
+        std::fs::write(
+            &path,
+            concat!(
+                "{\"type\":\"message\",\"id\":\"a\",\"message\":{\"role\":\"assistant\",\"content\":\"Answer\"}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"review\",\"parentId\":\"a\",\"display\":true,\"content\":\"Check\"}\n",
+                "{\"type\":\"message\",\"id\":\"b\",\"parentId\":\"review\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"thinking\",\"thinking\":\"Wait\"},{\"type\":\"text\",\"text\":\"Checked\"}]}}\n",
+            ),
+        )
+        .unwrap();
+        let anchors = parse_omp_interjections(&path).unwrap();
+        assert_eq!(anchors[0].following_assistant_text, None);
+        assert_eq!(anchors[0].text, "Check");
+    }
+    #[test]
+    fn omp_interjections_follow_active_ancestry_and_keep_text_forms() {
+        let dir = tmp("omp-interjections-ancestry");
+        let path = dir.0.join("session.jsonl");
+        std::fs::write(
+            &path,
+            concat!(
+                "{\"type\":\"message\",\"id\":\"a\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"One\"},{\"type\":\"text\",\"text\":\"Two\"}]}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"abandoned\",\"parentId\":\"a\",\"display\":true,\"content\":\"Wrong branch\"}\n",
+                "{\"type\":\"message\",\"id\":\"t\",\"parentId\":\"a\",\"message\":{\"role\":\"toolResult\",\"content\":\"Done\"}}\n",
+                "{\"type\":\"custom_message\",\"id\":\"first\",\"parentId\":\"t\",\"display\":true,\"content\":\"First\"}\n",
+                "{\"type\":\"custom_message\",\"id\":\"second\",\"parentId\":\"first\",\"display\":true,\"content\":\"Second\"}\n",
+                "{\"type\":\"compaction\",\"id\":\"meta\",\"parentId\":\"second\"}\n",
+                "{\"type\":\"custom_message\",\"id\":\"third\",\"parentId\":\"meta\",\"display\":true,\"content\":\"Third\"}\n",
+                "{\"type\":\"message\",\"id\":\"b\",\"parentId\":\"third\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Three\"},{\"type\":\"text\",\"text\":\"Four\"}]}}\n",
+            ),
+        )
+        .unwrap();
+        let anchors = parse_omp_interjections(&path).unwrap();
+        assert_eq!(
+            anchors.iter().map(|a| a.id.as_str()).collect::<Vec<_>>(),
+            ["first", "second", "third"]
+        );
+        for anchor in &anchors {
+            assert_eq!(anchor.after_assistant_text, "One\nTwo");
+            assert_eq!(anchor.after_assistant_text_concat, "OneTwo");
+            assert_eq!(anchor.after_occurrence, 1);
+            assert_eq!(anchor.after_concat_occurrence, 1);
+        }
+        assert_eq!(anchors[0].following_assistant_text, None);
+        assert_eq!(anchors[1].following_assistant_text, None);
+        assert_eq!(
+            anchors[2].following_assistant_text.as_deref(),
+            Some("Three\nFour")
+        );
+        assert_eq!(
+            anchors[2].following_assistant_text_concat.as_deref(),
+            Some("ThreeFour")
+        );
+    }
+
+    #[test]
+    fn omp_interjections_do_not_cross_users_or_empty_assistant_messages() {
+        let dir = tmp("omp-interjections-barriers");
+        let path = dir.0.join("session.jsonl");
+        for role in ["user", "assistant"] {
+            let records = [
+                serde_json::json!({"type":"message","id":"a","message":{"role":"assistant","content":"Earlier"}}),
+                serde_json::json!({"type":"message","id":"barrier","parentId":"a","message":{"role":role,"content":[]}}),
+                serde_json::json!({"type":"message","id":"tool","parentId":"barrier","message":{"role":"toolResult","content":"Done"}}),
+                serde_json::json!({"type":"custom_message","id":"note","parentId":"tool","display":true,"content":"Note"}),
+            ];
+            let jsonl = records.map(|record| record.to_string()).join("\n");
+            std::fs::write(&path, jsonl).unwrap();
+            assert!(parse_omp_interjections(&path).unwrap().is_empty());
+        }
+    }
+
     #[test]
     fn stat_files_returns_mtime_for_existing_files_only() {
         let dir = tmp("stat-files");
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9f8651bb..09b39dcf 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -301,6 +301,8 @@ pub fn run() {
             fs::read_binary_file,
             fs::write_attachment,
             fs::read_text_file,
+            fs::omp_session_interjections,
+            fs::omp_active_assistant_texts,
             fs::write_text_file,
             skills::list_skills,
             search::search_project,
diff --git a/src/lib/fs.ts b/src/lib/fs.ts
index 06c99eb1..3d8f04f4 100644
--- a/src/lib/fs.ts
+++ b/src/lib/fs.ts
@@ -1,6 +1,41 @@
 import { invoke } from "@tauri-apps/api/core";
 import { open } from "@tauri-apps/plugin-dialog";
 import { slash } from "./paths";
+import type { InterjectionMeta } from "./session";
+
+export type OmpInterjectionAnchor = InterjectionMeta & {
+  id: string;
+  afterAssistantText: string;
+  /** One-based occurrence among assistant messages with exactly this text. */
+  afterOccurrence: number;
+  /** Direct-concat live representation, with its own exact-text occurrence. */
+  afterAssistantTextConcat?: string;
+  afterConcatOccurrence?: number;
+  text: string;
+  /** Full text of a directly following text-only answer, if present. */
+  followingAssistantText?: string | null;
+  followingAssistantTextConcat?: string | null;
+};
+
+export function ompSessionInterjections(
+  providerSessionId: string,
+): Promise<OmpInterjectionAnchor[]> {
+  return invoke<OmpInterjectionAnchor[]>("omp_session_interjections", {
+    providerSessionId,
+  });
+}
+
+/** One active-path assistant message in source order. Its newline and concat
+ * representations are alternative forms of the same message, not two messages.
+ */
+export interface OmpAssistantText {
+  text: string;
+  concat: string;
+}
+
+export function ompActiveAssistantTexts(providerSessionId: string): Promise<OmpAssistantText[]> {
+  return invoke<OmpAssistantText[]>("omp_active_assistant_texts", { providerSessionId });
+}
 
 export type FsEntry = {
   name: string;
diff --git a/src/lib/harness/apply.test.ts b/src/lib/harness/apply.test.ts
index 572ef7f1..dc54a079 100644
--- a/src/lib/harness/apply.test.ts
+++ b/src/lib/harness/apply.test.ts
@@ -130,6 +130,102 @@ describe("streamed markdown", () => {
     expect(session.blocks).toHaveLength(1);
     expect(session.blocks[0]?.text).toBe("I'll read the file");
   });
+
+  it("continues open prose through status rows, then completes it", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "message.delta", text: "contributor（" });
+    const id = session.blocks[0].id;
+    session = applyHarnessEvent(session, { type: "status", text: "Advisor reviewed this turn" });
+    session = applyHarnessEvent(session, { type: "message.delta", text: "邮箱归属链已验证）" });
+    expect(session.blocks.map(block => block.text)).toEqual([
+      "contributor（邮箱归属链已验证）", "Advisor reviewed this turn",
+    ]);
+    expect(session.blocks[0]).toMatchObject({ id, streaming: true });
+    session = applyHarnessEvent(session, { type: "message.completed" });
+    session = applyHarnessEvent(session, { type: "message.delta", text: "Next message." });
+    expect(session.blocks[0].streaming).toBe(false);
+    expect(session.blocks[2]).toMatchObject({ role: "assistant", text: "Next message." });
+  });
+
+  it.each([false, true])("seals open prose at an interjection, with preceding status: %s", status => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "message.delta", text: "contributor（" });
+    const id = session.blocks[0].id;
+    if (status) session = applyHarnessEvent(session, { type: "status", text: "Reviewed" });
+    session = applyHarnessEvent(session, { type: "interjection", text: "Review", customType: "advisor" });
+    expect(session.blocks[0]).toMatchObject({ id, streaming: false });
+    session = applyHarnessEvent(session, { type: "message.delta", text: "邮箱归属链已验证）" });
+    expect(session.blocks.map(block => block.text)).toEqual([
+      "contributor（", ...(status ? ["Reviewed"] : []), "Review", "邮箱归属链已验证）",
+    ]);
+    expect(session.blocks.at(-1)).toMatchObject({ role: "assistant", streaming: true });
+    expect(session.blocks.at(-1)!.id).not.toBe(id);
+  });
+
+  it("does not resume a sealed assistant through status after an interjection", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "message.delta", text: "First." });
+    const id = session.blocks[0].id;
+    session = applyHarnessEvent(session, { type: "interjection", text: "Review", customType: "advisor" });
+    session = applyHarnessEvent(session, { type: "status", text: "Advisor reviewed this turn" });
+    session = applyHarnessEvent(session, { type: "message.delta", text: "Second." });
+    expect(session.blocks.map(block => block.text)).toEqual([
+      "First.", "Review", "Advisor reviewed this turn", "Second.",
+    ]);
+    expect(session.blocks[0]).toMatchObject({ id, streaming: false, text: "First." });
+    expect(session.blocks.at(-1)!.id).not.toBe(id);
+  });
+
+  it("keeps stacked interjections as hard boundaries", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "message.delta", text: "First." });
+    session = applyHarnessEvent(session, { type: "interjection", text: "One", customType: "advisor" });
+    session = applyHarnessEvent(session, { type: "interjection", text: "Two", customType: "advisor" });
+    session = applyHarnessEvent(session, { type: "message.delta", text: "Second." });
+    expect(session.blocks.map(block => [block.role, block.text])).toEqual([
+      ["assistant", "First."], ["system", "One"], ["system", "Two"], ["assistant", "Second."],
+    ]);
+  });
+
+  it("seals open reasoning at an interjection", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "reasoning.delta", text: "Think" });
+    const id = session.blocks[0].id;
+    session = applyHarnessEvent(session, { type: "interjection", text: "Review", customType: "advisor" });
+    session = applyHarnessEvent(session, { type: "reasoning.delta", text: " more" });
+    expect(session.blocks[0]).toMatchObject({ id, text: "Think", streaming: false });
+    expect(session.blocks.at(-1)).toMatchObject({ role: "reasoning", text: " more", streaming: true });
+    expect(session.blocks.at(-1)!.id).not.toBe(id);
+  });
+
+  it("continues open prose through many status rows", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "message.delta", text: "Hel" });
+    const id = session.blocks[0].id;
+    for (const text of ["A", "B", "C", "D", "E"]) {
+      session = applyHarnessEvent(session, { type: "status", text });
+    }
+    session = applyHarnessEvent(session, { type: "message.delta", text: "lo" });
+    expect(session.blocks[0]).toMatchObject({ id, text: "Hello", streaming: true });
+    expect(session.blocks.filter(block => block.role === "system")).toHaveLength(5);
+  });
+
+  it("continues reasoning across status but seals it when a tool starts", () => {
+    let session = newSession("omp", "/tmp");
+    session = applyHarnessEvent(session, { type: "reasoning.delta", text: "Think" });
+    session = applyHarnessEvent(session, { type: "status", text: "Reviewing" });
+    session = applyHarnessEvent(session, { type: "reasoning.delta", text: " more" });
+    expect(session.blocks[0]).toMatchObject({ text: "Think more", streaming: true });
+    session = applyHarnessEvent(session, { type: "tool.started", callId: "call", title: "Read" });
+    expect(session.blocks[0].streaming).toBe(false);
+    session = applyHarnessEvent(session, { type: "status", text: "Waiting" });
+    session = applyHarnessEvent(session, { type: "tool.updated", callId: "call", status: "completed" });
+    expect(session.blocks.filter(block => block.role === "tool")).toMatchObject([
+      { streaming: false, tool: { callId: "call", status: "completed" } },
+    ]);
+    session = applyHarnessEvent(session, { type: "reasoning.delta", text: "New thought" });
+    expect(session.blocks.at(-1)).toMatchObject({ role: "reasoning", text: "New thought" });
+  });
 });
 
 describe("appendSteerUser", () => {
@@ -204,6 +300,56 @@ describe("status blocks", () => {
   });
 });
 
+describe("interjection blocks", () => {
+  it("keeps a boundary between completed assistant messages", () => {
+    let session = appendUser(newSession("pi", "/tmp"), "go");
+    session = applyHarnessEvent(session, {
+      type: "message.delta",
+      text: "Complete answer.",
+    });
+    session = applyHarnessEvent(session, { type: "message.completed" });
+    session = applyHarnessEvent(session, {
+      type: "interjection",
+      text: "Check the fallback.",
+      customType: "advisor",
+    });
+    session = applyHarnessEvent(session, {
+      type: "message.delta",
+      text: "Checked.",
+    });
+
+    expect(session.blocks.slice(1)).toMatchObject([
+      { role: "assistant", text: "Complete answer.", streaming: false },
+      { role: "system", interjection: { customType: "advisor" } },
+      { role: "assistant", text: "Checked.", streaming: true },
+    ]);
+  });
+
+  it("appends every interjection as a distinct persisted boundary", () => {
+    let session = appendUser(newSession("pi", "/tmp"), "go");
+    session = applyHarnessEvent(session, {
+      type: "interjection",
+      text: "Check the fallback.",
+      customType: "advisor",
+      severity: "concern",
+    });
+    session = applyHarnessEvent(session, {
+      type: "interjection",
+      text: "Check the fallback.",
+      customType: "advisor",
+      severity: "concern",
+    });
+
+    const interjections = session.blocks.filter((block) => block.interjection);
+    expect(interjections).toHaveLength(2);
+    expect(interjections[0]).toMatchObject({
+      role: "system",
+      text: "Check the fallback.",
+      interjection: { customType: "advisor", severity: "concern" },
+    });
+  });
+});
+
 describe("task list updates", () => {
   it("updates one structured checklist instead of appending plan cards", () => {
     let session = appendUser(newSession("codex", "/tmp"), "fix it");
diff --git a/src/lib/harness/apply.ts b/src/lib/harness/apply.ts
index 90ca25a9..2108d053 100644
--- a/src/lib/harness/apply.ts
+++ b/src/lib/harness/apply.ts
@@ -134,6 +134,18 @@ export function applyHarnessEvent(
       };
     case "status":
       return appendStatus(session, event.text);
+    case "interjection":
+      // A visible boundary the user must not miss, so unlike status it never
+      // deduplicates and never reads as turn lifecycle.
+      return appendBlock(session, {
+        id: crypto.randomUUID(),
+        role: "system",
+        text: event.text,
+        interjection: {
+          customType: event.customType,
+          ...(event.severity ? { severity: event.severity } : {}),
+        },
+      });
     default:
       return session;
   }
@@ -571,10 +583,13 @@ function appendStatus(session: Session, text: string): Session {
 }
 
 function appendBlock(session: Session, block: Block): Session {
-  return { ...session, blocks: [...sealLastStream(session.blocks), block] };
+  return {
+    ...session,
+    blocks: [...(block.role === "system" && !block.interjection ? session.blocks : sealLastStream(session.blocks)), block],
+  };
 }
 
-/** Append to the latest block only when it is the same role; never splice into an earlier one. */
+/** Only ordinary status rows leave an open prose stream intact. */
 function patchStreaming(
   session: Session,
   role: "assistant" | "reasoning",
@@ -582,12 +597,14 @@ function patchStreaming(
   streaming: boolean,
 ): Session {
   if (!text && role === "reasoning") return session;
-  const last = session.blocks[session.blocks.length - 1];
-  if (last?.role === role) {
+  let index = session.blocks.length - 1;
+  while (index >= 0 && session.blocks[index].role === "system" && !session.blocks[index].interjection) index--;
+  const last = session.blocks[index];
+  if (last?.role === role && (index === session.blocks.length - 1 || last.streaming)) {
     const nextText = joinStreamText(last.text, text);
     if (nextText === last.text && last.streaming === streaming) return session;
     const blocks = session.blocks.slice();
-    blocks[blocks.length - 1] = {
+    blocks[index] = {
       ...last,
       text: nextText,
       streaming,
@@ -956,7 +973,9 @@ function findToolIndex(
 }
 
 function sealLastStream(blocks: Block[]): Block[] {
-  const last = blocks[blocks.length - 1];
+  let index = blocks.length - 1;
+  while (index >= 0 && blocks[index].role === "system" && !blocks[index].interjection) index--;
+  const last = blocks[index];
   if (
     !last?.streaming ||
     (last.role !== "assistant" && last.role !== "reasoning")
@@ -964,7 +983,7 @@ function sealLastStream(blocks: Block[]): Block[] {
     return blocks.slice();
   }
   const next = blocks.slice();
-  next[next.length - 1] = { ...last, streaming: false };
+  next[index] = { ...last, streaming: false };
   return next;
 }
 
diff --git a/src/lib/harness/ompLive.test.ts b/src/lib/harness/ompLive.test.ts
index 7b8fd523..0911c88f 100644
--- a/src/lib/harness/ompLive.test.ts
+++ b/src/lib/harness/ompLive.test.ts
@@ -467,6 +467,111 @@ describe("OMP command lifecycle over the real RPC multiplexer", () => {
       1,
     );
   });
+
+  it("surfaces displayed OMP advisor notes and hides internal messages", async () => {
+    const running = await started();
+    const advisor = {
+      role: "custom",
+      customType: "advisor",
+      display: true,
+      content: "raw advisory envelope",
+      details: {
+        notes: [
+          { note: "Minor note", severity: "nit" },
+          { note: "Stop here", severity: "blocker" },
+        ],
+      },
+    };
+    frame("omp-test", { type: "message_start", message: advisor });
+    frame("omp-test", { type: "message_end", message: advisor });
+    frame("omp-test", {
+      type: "message_start",
+      message: {
+        role: "custom",
+        customType: "xdev-mount-notice",
+        display: false,
+        content: "internal mount details",
+      },
+    });
+    frame("omp-test", { type: "advisor_yielded" });
+
+    expect(events).toContainEqual({
+      type: "interjection",
+      text: "Minor note\n\nStop here",
+      customType: "advisor",
+      severity: "blocker",
+    });
+    expect(
+      events.filter((event) => event.type === "interjection"),
+    ).toHaveLength(1);
+    expect(
+      events.some(
+        (event) => "text" in event && event.text === "internal mount details",
+      ),
+    ).toBe(false);
+    frame("omp-test", { type: "agent_end" });
+    await running.turn;
+  });
+
+  it("emits a transient status when the OMP advisor yields", async () => {
+    const running = await started();
+    const start = events.length;
+    frame("omp-test", { type: "advisor_yielded" });
+    expect(events.slice(start)).toEqual([
+      { type: "status", text: expect.any(String) },
+    ]);
+    frame("omp-test", { type: "agent_end" });
+    await running.turn;
+  });
+
+  it("uses generic content for other displayed OMP custom messages", async () => {
+    const running = await started();
+    frame("omp-test", {
+      type: "message_start",
+      message: {
+        role: "custom",
+        customType: "extension-notice",
+        display: true,
+        content: [
+          { type: "text", text: "Extension changed the plan." },
+          { type: "image", data: "ignored", mimeType: "image/png" },
+          { type: "text", text: "Review it." },
+        ],
+      },
+    });
+
+    expect(events).toContainEqual({
+      type: "interjection",
+      text: "Extension changed the plan.\nReview it.",
+      customType: "extension-notice",
+    });
+    frame("omp-test", { type: "agent_end" });
+    await running.turn;
+  });
+
+  it("does not reinterpret Pi custom messages as OMP interjections", async () => {
+    const turn = sendPiTurn({
+      ...input("pi-test", "hello"),
+      model: "pi:default",
+    });
+    await vi.waitFor(() =>
+      expect(transport.requests.some((r) => r.command.type === "prompt")).toBe(
+        true,
+      ),
+    );
+    frame("pi-test", {
+      type: "message_start",
+      message: {
+        role: "custom",
+        customType: "advisor",
+        display: true,
+        content: "Pi-owned custom frame",
+      },
+    });
+    expect(events.some((event) => event.type === "interjection")).toBe(false);
+    frame("pi-test", { type: "agent_end" });
+    await turn;
+  });
 });
 
 describe("OMP live command inventories", () => {
diff --git a/src/lib/harness/piFamily.ts b/src/lib/harness/piFamily.ts
index af3530e7..e257cf0f 100644
--- a/src/lib/harness/piFamily.ts
+++ b/src/lib/harness/piFamily.ts
@@ -616,6 +616,64 @@ async function runTurn(
   }
 }
 
+/**
+ * OMP's advisor and extensions interject mid-turn. Frames marked display:true
+ * exist so clients can show them: structured advisor notes replace the raw
+ * advisory envelope when present, and even a blank body stays a labeled
+ * boundary so the segments around it never silently merge.
+ */
+function customMessageText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value
+    .flatMap((part) => {
+      const record = asRecord(part);
+      return record?.type === "text" && typeof record.text === "string"
+        ? [record.text]
+        : [];
+    })
+    .join("\n");
+}
+
+function interjectionFromCustomMessage(
+  message: Record<string, unknown>,
+): Extract<HarnessEvent, { type: "interjection" }> | undefined {
+  if (message.display !== true) return undefined;
+  const customType = stringField(message, "customType") ?? "custom";
+  if (customType === "advisor") {
+    const notes = asRecord(message.details)?.notes;
+    const bodies: string[] = [];
+    let severity: Extract<HarnessEvent, { type: "interjection" }>["severity"];
+    if (Array.isArray(notes)) {
+      for (const raw of notes) {
+        const note = asRecord(raw);
+        const body = stringField(note, "note");
+        if (!body) continue;
+        bodies.push(body);
+        // Keep the highest severity the retained notes actually carry.
+        const level = note?.severity;
+        if (level === "blocker") severity = "blocker";
+        else if (level === "concern" && severity !== "blocker") {
+          severity = "concern";
+        } else if (level === "nit" && !severity) severity = "nit";
+      }
+    }
+    if (bodies.length > 0) {
+      return {
+        type: "interjection",
+        text: bodies.join("\n\n"),
+        customType,
+        ...(severity ? { severity } : {}),
+      };
+    }
+  }
+  return {
+    type: "interjection",
+    text: customMessageText(message.content),
+    customType,
+  };
+}
+
 function handleFrame(
   flavor: PiFlavor,
   sessionId: string,
@@ -653,6 +711,23 @@ function handleFrame(
 
   const type = stringField(rec, "type");
   if (flavor.id === "omp") {
+    // OMP emits persisted custom_message entries on the live RPC stream as a
+    // message_start/message_end pair. Render the start once; consume the end
+    // and hidden custom messages so none can leak through a generic path.
+    if (type === "message_start" || type === "message_end") {
+      const message = asRecord(rec.message);
+      if (message?.role === "custom") {
+        if (type === "message_start") {
+          const interjection = interjectionFromCustomMessage(message);
+          if (interjection) live.onEvent(interjection);
+        }
+        return;
+      }
+    }
+    if (type === "advisor_yielded") {
+      live.onEvent({ type: "status", text: "Advisor reviewed this turn" });
+      return;
+    }
     if (type === "session_info_update") {
       const providerSessionId = stringField(rec, "sessionId");
       if (providerSessionId) {
diff --git a/src/lib/harness/types.ts b/src/lib/harness/types.ts
index 02c0f429..acf05c26 100644
--- a/src/lib/harness/types.ts
+++ b/src/lib/harness/types.ts
@@ -1,6 +1,7 @@
 import type {
   AgentStepKind,
   Attachment,
+  InterjectionMeta,
   RuntimeMode,
   TaskListItem,
   ToolPreview,
@@ -20,6 +21,7 @@ export type HarnessEvent =
       modelSettings?: Record<string, string>;
     }
   | { type: "status"; text: string }
+  | ({ type: "interjection"; text: string } & InterjectionMeta)
   | { type: "message.delta"; text: string }
   | { type: "message.completed" }
   | { type: "reasoning.delta"; text: string }
diff --git a/src/lib/ompInterjections.test.ts b/src/lib/ompInterjections.test.ts
new file mode 100644
index 00000000..9a34eead
--- /dev/null
+++ b/src/lib/ompInterjections.test.ts
@@ -0,0 +1,585 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { OmpAssistantText, OmpInterjectionAnchor } from "./fs";
+import { backfillOmpInterjections, ompStatusSplitTexts } from "./ompInterjections";
+import { newSession, type Block } from "./session";
+import { getSession } from "./sessionStore";
+import { foldableWork, foldedBlocks, groupTurnItems, groupTurns } from "../surfaces/transcriptActivity";
+
+const mocks = vi.hoisted(() => ({ invoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+afterEach(() => mocks.invoke.mockReset());
+
+const anchor: OmpInterjectionAnchor = {
+  id: "review",
+  afterAssistantText: "The complete answer.",
+  afterOccurrence: 1,
+  text: "Check the fallback.",
+  customType: "advisor",
+  severity: "concern",
+};
+
+function oldBlocks(): Block[] {
+  return [
+    { id: "u", role: "user", text: "Go" },
+    { id: "r1", role: "reasoning", text: "Thinking" },
+    { id: "t1", role: "tool", text: "Check", tool: { kind: "shell", title: "Check", status: "completed" } },
+    { id: "a1", role: "assistant", text: anchor.afterAssistantText },
+    { id: "r2", role: "reasoning", text: "Rechecking" },
+    { id: "t2", role: "tool", text: "Test", tool: { kind: "shell", title: "Test", status: "completed" } },
+    { id: "a2", role: "assistant", text: "Checked." },
+  ];
+}
+
+function foldedIds(blocks: Block[]) {
+  const items = groupTurnItems(groupTurns(blocks)[0]);
+  return foldedBlocks(items, foldableWork(items)!).map(block => block.id);
+}
+
+describe("OMP persisted interjection repair", () => {
+  it("restores the complete answer outside the work fold without inventing a turn", () => {
+    const before = oldBlocks();
+    expect(foldedIds(before)).toContain("a1");
+    const repaired = backfillOmpInterjections(before, [anchor]);
+    expect(repaired[4]).toMatchObject({ id: "omp-interjection-review", role: "system", text: anchor.text, interjection: { customType: "advisor", severity: "concern" } });
+    expect(groupTurns(repaired)).toHaveLength(1);
+    expect(foldedIds(repaired)).toEqual(["r2", "t2"]);
+    expect(before.map(block => block.id)).toEqual(["u", "r1", "t1", "a1", "r2", "t2", "a2"]);
+  });
+
+  it("targets the second identical answer rather than the first", () => {
+    const blocks = oldBlocks();
+    blocks[6] = { ...blocks[6], text: anchor.afterAssistantText };
+    const repaired = backfillOmpInterjections(blocks, [{ ...anchor, afterOccurrence: 2 }]);
+    expect(repaired.map(block => block.id)).toEqual(["u", "r1", "t1", "a1", "r2", "t2", "a2", "omp-interjection-review"]);
+  });
+
+  it("keeps unanchored progress prose folding and rejects approximate matches", () => {
+    const blocks = oldBlocks();
+    expect(backfillOmpInterjections(blocks, [])).toBe(blocks);
+    expect(backfillOmpInterjections(blocks, [{ ...anchor, afterAssistantText: "The complete" }])).toBe(blocks);
+    expect(backfillOmpInterjections(blocks, [{ ...anchor, afterAssistantText: ` ${anchor.afterAssistantText}` }])).toBe(blocks);
+    expect(foldedIds(blocks)).toContain("a1");
+  });
+
+  it("does not duplicate repaired or already captured live boundaries", () => {
+    const repaired = backfillOmpInterjections(oldBlocks(), [anchor]);
+    expect(backfillOmpInterjections(repaired, [anchor])).toBe(repaired);
+    const live = repaired.map(block => block.interjection ? { ...block, id: "random-live-id" } : block);
+    expect(backfillOmpInterjections(live, [anchor])).toBe(live);
+  });
+
+  it("splits a coalesced answer only with an exact full continuation from the source", () => {
+    const blocks: Block[] = [{ id: "a", role: "assistant", text: "First.\uD834\uDD1ESecond." }];
+    const merged = { ...anchor, afterAssistantText: "First.\uD834\uDD1E", followingAssistantText: "Second." };
+    const repaired = backfillOmpInterjections(blocks, [merged]);
+    expect(repaired.map(block => [block.role, block.text])).toEqual([
+      ["assistant", "First.\uD834\uDD1E"], ["system", anchor.text], ["assistant", "Second."],
+    ]);
+    expect(backfillOmpInterjections(repaired, [merged])).toBe(repaired);
+    expect(backfillOmpInterjections(blocks, [{ ...merged, followingAssistantText: "Second" }])).toBe(blocks);
+    expect(backfillOmpInterjections(blocks, [{ ...merged, followingAssistantText: undefined }])).toBe(blocks);
+  });
+
+  it("preserves source order and consumes live rows only once", () => {
+    const first = backfillOmpInterjections(oldBlocks(), [anchor]);
+    first[4] = { ...first[4], id: "live" };
+    const second = { ...anchor, id: "review-again" };
+    const repaired = backfillOmpInterjections(first, [anchor, second]);
+    expect(repaired.filter(block => block.interjection).map(block => block.id)).toEqual([
+      "live", "omp-interjection-review-again",
+    ]);
+    expect(backfillOmpInterjections(repaired, [anchor, second])).toBe(repaired);
+  });
+
+  it("preserves a split continuation after an existing live boundary and a new anchor", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First.Second." },
+      { id: "live", role: "system", text: anchor.text, interjection: { customType: "advisor", severity: "concern" } },
+    ];
+    const first = { ...anchor, afterAssistantText: "First.Second." };
+    const second = { ...anchor, id: "second", afterAssistantText: "First.", followingAssistantText: "Second.", text: "Another review." };
+    const repaired = backfillOmpInterjections(blocks, [first, second]);
+    expect(repaired.map(block => [block.role, block.text])).toEqual([
+      ["assistant", "First."], ["system", anchor.text],
+      ["system", second.text], ["assistant", "Second."],
+    ]);
+    expect(backfillOmpInterjections(repaired, [first, second])).toBe(repaired);
+    expect(backfillOmpInterjections(blocks, [first, second])).toEqual(repaired);
+    expect(blocks[0].text).toBe("First.Second.");
+  });
+
+  it("matches subsequent anchors against a continuation created in the same pass", () => {
+    const blocks: Block[] = [{ id: "a", role: "assistant", text: "First.Second." }];
+    const first = { ...anchor, afterAssistantText: "First.", followingAssistantText: "Second." };
+    const second = { ...anchor, id: "second", afterAssistantText: "Second.", text: "Second review." };
+    const repaired = backfillOmpInterjections(blocks, [first, second]);
+    expect(repaired.map(block => [block.role, block.text])).toEqual([
+      ["assistant", "First."], ["system", first.text],
+      ["assistant", "Second."], ["system", second.text],
+    ]);
+    expect(backfillOmpInterjections(repaired, [first, second])).toBe(repaired);
+  });
+
+  it("keeps all adjacent live notes before a recovered continuation", () => {
+    const first = { ...anchor, afterAssistantText: "First.", followingAssistantText: "Second." };
+    const second = { ...first, id: "second", text: "Second review." };
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First.Second." },
+      { id: "live-1", role: "system", text: first.text, interjection: { customType: "advisor", severity: "concern" } },
+      { id: "live-2", role: "system", text: second.text, interjection: { customType: "advisor", severity: "concern" } },
+    ];
+    const repaired = backfillOmpInterjections(blocks, [first, second]);
+    expect(repaired.map(block => [block.role, block.text])).toEqual([
+      ["assistant", "First."], ["system", first.text],
+      ["system", second.text], ["assistant", "Second."],
+    ]);
+    expect(backfillOmpInterjections(repaired, [first, second])).toBe(repaired);
+  });
+
+  it("adds tool-result and chained notes around an already repaired boundary without changing IDs", () => {
+    const before = backfillOmpInterjections(oldBlocks(), [anchor]);
+    const earlier = { ...anchor, id: "tool-note", text: "Tool review" };
+    const later = { ...anchor, id: "chained-note", text: "Another review" };
+    const repaired = backfillOmpInterjections(before, [earlier, anchor, later]);
+    expect(repaired.filter(block => block.interjection).map(block => block.id)).toEqual([
+      "omp-interjection-tool-note", "omp-interjection-review", "omp-interjection-chained-note",
+    ]);
+    expect(foldedIds(repaired)).toEqual(["r2", "t2"]);
+    expect(repaired.filter(block => !block.interjection)).toEqual(oldBlocks());
+    expect(backfillOmpInterjections(repaired, [earlier, anchor, later])).toBe(repaired);
+  });
+
+  it("matches both multipart representations with separate occurrences and exact split evidence", () => {
+    const multipart = {
+      ...anchor, afterAssistantText: "One\nTwo", afterAssistantTextConcat: "OneTwo",
+      afterOccurrence: 1, afterConcatOccurrence: 2,
+      followingAssistantText: "Three\nFour", followingAssistantTextConcat: "ThreeFour",
+    };
+    const blocks: Block[] = [
+      { id: "earlier", role: "assistant", text: "OneTwo" },
+      { id: "target", role: "assistant", text: "OneTwoThreeFour" },
+    ];
+    const repaired = backfillOmpInterjections(blocks, [multipart]);
+    expect(repaired.map(block => block.text)).toEqual(["OneTwo", "OneTwo", anchor.text, "ThreeFour"]);
+    expect(backfillOmpInterjections(repaired, [multipart])).toBe(repaired);
+    const legacy: Block[] = [{ id: "target", role: "assistant", text: "One\nTwoThree\nFour" }];
+    expect(backfillOmpInterjections(legacy, [multipart]).map(block => block.text)).toEqual([
+      "One\nTwo", anchor.text, "Three\nFour",
+    ]);
+    expect(backfillOmpInterjections(blocks, [{ ...multipart, followingAssistantTextConcat: "Three" }])).toBe(blocks);
+  });
+
+  it("restores an entire note chain when only its last note has exact split evidence", () => {
+    const first = { ...anchor, afterAssistantText: "First." };
+    const last = { ...first, id: "last", text: "Last note", followingAssistantText: "Second." };
+    const blocks: Block[] = [{ id: "a", role: "assistant", text: "First.Second." }];
+    const repaired = backfillOmpInterjections(blocks, [first, last]);
+    expect(repaired.map(block => block.text)).toEqual(["First.", first.text, last.text, "Second."]);
+    expect(backfillOmpInterjections(repaired, [first, last])).toBe(repaired);
+  });
+
+  /** Ordered active-path source messages; a string is one message in both forms. */
+  function source(...messages: (string | OmpAssistantText)[]): OmpAssistantText[] {
+    return messages.map(message => typeof message === "string" ? { text: message, concat: message } : message);
+  }
+
+  it("merges status-split prose with the next source message before placing later anchors", () => {
+    const first = { ...anchor, afterAssistantText: "First.Second.", followingAssistantText: "Later." };
+    const later = { ...anchor, id: "later", afterAssistantText: "Later." };
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Advisor reviewed this turn" },
+      { id: "b", role: "assistant", text: "Second." },
+      { id: "c", role: "assistant", text: "Later." },
+    ];
+    const messages = source("First.Second.", "Later.");
+    const repaired = backfillOmpInterjections(blocks, [first, later], messages);
+    expect(repaired.map(block => [block.id, block.text])).toEqual([
+      ["a", "First.Second."], ["omp-interjection-review", anchor.text],
+      ["status", blocks[1].text], ["c", "Later."], ["omp-interjection-later", anchor.text],
+    ]);
+    expect(backfillOmpInterjections(repaired, [first, later], messages)).toBe(repaired);
+    expect(blocks[0].text).toBe("First.");
+    expect(backfillOmpInterjections(blocks, [{ ...first, afterAssistantText: "First. Second." }], source("First. Second.", "Later."))).toBe(blocks);
+    const interleaved = blocks.map(block => block.id === "status"
+      ? { ...block, interjection: { customType: "advisor" } } : block);
+    expect(backfillOmpInterjections(interleaved, [first], messages)).toBe(interleaved);
+    const metadata = blocks.map(block => block.id === "b" ? { ...block, durationMs: 10 } : block);
+    expect(backfillOmpInterjections(metadata, [first], messages)).toBe(metadata);
+  });
+
+  it("never merges on anchor occurrences alone", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+    ];
+    const anchors = [{ ...anchor, afterAssistantText: "First.Second.", afterAssistantTextConcat: "First.Second.", afterConcatOccurrence: 1 }];
+    expect(backfillOmpInterjections(blocks, anchors)).toBe(blocks);
+    expect(backfillOmpInterjections(blocks, [{ ...anchors[0], afterAssistantText: "First.\nSecond.", afterOccurrence: 2 }])).toBe(blocks);
+    const repaired = backfillOmpInterjections(blocks, anchors, source("First.Second."));
+    expect(repaired.map(block => block.id)).toEqual(["a", "omp-interjection-review", "status"]);
+  });
+
+  it("keeps a split whose fragments are the next two source messages before the real complete answer", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+      { id: "c", role: "assistant", text: "First.Second." },
+    ];
+    const messages = source("First.", "Second.", "First.Second.");
+    expect(ompStatusSplitTexts(blocks)).toEqual(["First.Second."]);
+    expect(backfillOmpInterjections(blocks, [], messages)).toBe(blocks);
+    const anchors = [{ ...anchor, afterAssistantText: "First.Second." }];
+    const repaired = backfillOmpInterjections(blocks, anchors, messages);
+    expect(repaired.map(block => block.id)).toEqual(["a", "status", "b", "c", "omp-interjection-review"]);
+    expect(backfillOmpInterjections(repaired, anchors, messages)).toBe(repaired);
+  });
+
+  it("keeps a split whose fragments are later source messages when the combined text was never persisted", () => {
+    const blocks = split("a");
+    const messages = source("First.Second.", "First.", "Second.");
+    expect(backfillOmpInterjections(blocks, [], messages)).toBe(blocks);
+    const tail: Block[] = [...blocks, { id: "c", role: "assistant", text: "First.Second." }];
+    const messagesTail = source("First.Second.", "First.", "Second.", "First.Second.");
+    expect(backfillOmpInterjections(tail, [], messagesTail)).toBe(tail);
+  });
+
+  it("prefers the alignment that explains every block when fragment slots are claimed by later pairs", () => {
+    const blocks: Block[] = [
+      ...split("p1"),
+      { id: "m", role: "assistant", text: "Marker." },
+      ...split("p2"),
+      { id: "tail", role: "assistant", text: "First.Second." },
+    ];
+    const messages = source("First.Second.", "Marker.", "First.", "Second.", "First.Second.");
+    const repaired = backfillOmpInterjections(blocks, [], messages);
+    expect(repaired.map(block => [block.id, block.text])).toEqual([
+      ["p1", "First.Second."], ["p1-status", "Reviewed"], ["m", "Marker."],
+      ["p2", "First."], ["p2-status", "Reviewed"], ["p2-end", "Second."], ["tail", "First.Second."],
+    ]);
+  });
+
+  it("repairs a status chain as one message in a single idempotent pass", () => {
+    const chained: Block[] = [
+      { id: "a", role: "assistant", text: "A." },
+      { id: "a-s1", role: "system", text: "Reviewed" },
+      { id: "a-b", role: "assistant", text: "B." },
+      { id: "a-s2", role: "system", text: "Reviewed" },
+      { id: "a-c", role: "assistant", text: "C." },
+    ];
+    const repaired = backfillOmpInterjections(chained, [], source("A.B.", "A.B.C."));
+    expect(repaired.map(block => [block.id, block.text])).toEqual([
+      ["a", "A.B.C."], ["a-s1", "Reviewed"], ["a-s2", "Reviewed"],
+    ]);
+    expect(backfillOmpInterjections(repaired, [], source("A.B.", "A.B.C."))).toBe(repaired);
+  });
+
+  it("welds only the pair when a chain's middle fragment ends a real message", () => {
+    const chained: Block[] = [
+      { id: "a", role: "assistant", text: "A." },
+      { id: "a-s1", role: "system", text: "Reviewed" },
+      { id: "a-b", role: "assistant", text: "B." },
+      { id: "a-s2", role: "system", text: "Reviewed" },
+      { id: "a-c", role: "assistant", text: "C." },
+    ];
+    const repaired = backfillOmpInterjections(chained, [], source("A.B.", "C."));
+    expect(repaired.map(block => [block.id, block.text])).toEqual([
+      ["a", "A.B."], ["a-s1", "Reviewed"], ["a-s2", "Reviewed"], ["a-c", "C."],
+    ]);
+  });
+
+  it("never re-welds a block that already claimed an earlier source slot", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "a-status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+      { id: "c", role: "assistant", text: "Third." },
+    ];
+    const messages = source("First.Second.", "First.Second.Third.");
+    const once = backfillOmpInterjections(blocks, [], messages);
+    expect(once.map(block => [block.id, block.text])).toEqual([
+      ["a", "First.Second."], ["a-status", "Reviewed"], ["c", "Third."],
+    ]);
+    expect(backfillOmpInterjections(once, [], messages)).toBe(once);
+  });
+
+  it("keeps a split whose fragments are separated later source messages", () => {
+    const blocks = split("a");
+    const messages = source("First.Second.", "Unrelated.", "First.", "Second.");
+    expect(backfillOmpInterjections(blocks, [], messages)).toBe(blocks);
+  });
+
+  it("still merges a true split when only one fragment is a later source message", () => {
+    for (const messages of [source("First.Second.", "First."), source("First.Second.", "Second.")]) {
+      const repaired = backfillOmpInterjections(split("a"), [], messages);
+      expect(repaired.map(block => block.text)).toEqual(["First.Second.", "Reviewed"]);
+    }
+  });
+
+  it("leaves a split whose first fragment is its own source message and anchors the later complete answer", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "The complete " },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "answer." },
+      { id: "c", role: "assistant", text: anchor.afterAssistantText },
+    ];
+    const messages = source("The complete ", "answer.", anchor.afterAssistantText);
+    const repaired = backfillOmpInterjections(blocks, [anchor], messages);
+    expect(repaired.map(block => block.id)).toEqual(["a", "status", "b", "c", "omp-interjection-review"]);
+    expect(backfillOmpInterjections(repaired, [anchor], messages)).toBe(repaired);
+    expect(backfillOmpInterjections(blocks, [{ ...anchor, afterOccurrence: 2 }], messages)).toBe(blocks);
+  });
+
+  it("keeps streaming fragments and metadata even with a matching source message", () => {
+    const blocks: Block[] = [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+    ];
+    for (const index of [0, 2]) {
+      const streaming = blocks.map((block, i) => i === index ? { ...block, streaming: true } : block);
+      expect(ompStatusSplitTexts(streaming)).toEqual([]);
+      expect(backfillOmpInterjections(streaming, [], source("First.Second."))).toBe(streaming);
+    }
+    const metadata = blocks.map(block => block.id === "b" ? { ...block, durationMs: 10 } : block);
+    expect(ompStatusSplitTexts(metadata)).toEqual([]);
+    expect(backfillOmpInterjections(metadata, [], source("First.Second."))).toBe(metadata);
+  });
+
+  function split(id: string): Block[] {
+    return [
+      { id, role: "assistant", text: "First." },
+      { id: `${id}-status`, role: "system", text: "Reviewed" },
+      { id: `${id}-end`, role: "assistant", text: "Second." },
+    ];
+  }
+
+  it.each([
+    ["newline", { text: "First.\nSecond.", concat: "First.Second." }],
+    ["concat", { text: "First.Second.", concat: "First.Second." }],
+  ])("consumes one source message for one split, form: %s", (_form, message) => {
+    const blocks = [...split("a"), ...split("b")];
+    const messages = source(message);
+    const repaired = backfillOmpInterjections(blocks, [], messages);
+    expect(repaired.find(block => block.id === "a")!.text).toBe("First.Second.");
+    expect(repaired.filter(block => block.id.startsWith("b"))).toEqual(split("b"));
+    expect(backfillOmpInterjections(repaired, [], messages)).toBe(repaired);
+  });
+
+  it("merges a true split followed by a different complete message", () => {
+    const blocks: Block[] = [...split("a"), { id: "c", role: "assistant", text: "Later." }];
+    const repaired = backfillOmpInterjections(blocks, [], source("First.Second.", "Later."));
+    expect(repaired.map(block => [block.id, block.text])).toEqual([
+      ["a", "First.Second."], ["a-status", "Reviewed"], ["c", "Later."],
+    ]);
+  });
+
+  it.each([false, true])("lets an unsplit answer occupy its source slot before a later candidate, anchored: %s", anchored => {
+    const blocks: Block[] = [{ id: "complete", role: "assistant", text: "First.Second." }, ...split("a")];
+    const anchors = anchored ? [{ ...anchor, afterAssistantText: "First.Second." }] : [];
+    const repaired = backfillOmpInterjections(blocks, anchors, source("First.Second."));
+    expect(repaired.filter(block => block.id.startsWith("a"))).toEqual(split("a"));
+    const both = backfillOmpInterjections(blocks, anchors, source("First.Second.", "First.Second."));
+    expect(both.filter(block => block.role === "assistant").map(block => [block.id, block.text])).toEqual([
+      ["complete", "First.Second."], ["a", "First.Second."],
+    ]);
+  });
+
+  it("repairs two splits only with two source messages", () => {
+    const blocks = [...split("a"), ...split("b")];
+    const messages = source("First.Second.", "First.Second.");
+    const repaired = backfillOmpInterjections(blocks, [], messages);
+    expect(repaired.map(block => block.id)).toEqual(["a", "a-status", "b", "b-status"]);
+    expect(repaired.filter(block => block.role === "assistant").map(block => block.text)).toEqual(["First.Second.", "First.Second."]);
+    expect(backfillOmpInterjections(repaired, [], messages)).toBe(repaired);
+  });
+
+  it("keeps anchor evidence from adding to the source sequence", () => {
+    const blocks = [...split("a"), ...split("b")];
+    const anchors = [{ ...anchor, afterAssistantText: "First.Second." }];
+    const messages = source("First.Second.");
+    const repaired = backfillOmpInterjections(blocks, anchors, messages);
+    expect(repaired.filter(block => block.id.startsWith("b"))).toEqual(split("b"));
+    expect(backfillOmpInterjections(repaired, anchors, messages)).toBe(repaired);
+  });
+
+  it("does not bind a later anchor occurrence or unnumbered following text to an earlier split", () => {
+    const blocks = split("a");
+    expect(backfillOmpInterjections(blocks, [{ ...anchor, afterAssistantText: "First.Second.", afterOccurrence: 2 }])).toBe(blocks);
+    expect(backfillOmpInterjections(blocks, [{ ...anchor, followingAssistantText: "First.Second." }])).toBe(blocks);
+  });
+
+  it("merges ten identical splits only against the three source messages in order", () => {
+    const blocks = Array.from({ length: 10 }, (_, i) => split(String(i))).flat();
+    const messages = source("First.Second.", "First.Second.", "First.Second.");
+    const repaired = backfillOmpInterjections(blocks, [], messages);
+    expect(repaired.filter(block => block.role === "assistant" && block.text === "First.Second.").map(block => block.id)).toEqual(["0", "1", "2"]);
+    expect(repaired.filter(block => block.id.endsWith("-end"))).toHaveLength(7);
+    expect(backfillOmpInterjections(repaired, [], messages)).toBe(repaired);
+  });
+
+  it("realigns a complete block past source messages the transcript never stored", () => {
+    const blocks: Block[] = [{ id: "complete", role: "assistant", text: "Intro." }, ...split("a")];
+    const repaired = backfillOmpInterjections(blocks, [], source("Setup.", "Intro.", "First.Second."));
+    expect(repaired.map(block => block.id)).toEqual(["complete", "a", "a-status"]);
+  });
+
+  it("returns blocks unmerged when the alignment exceeds its budget", () => {
+    const chain = (count: number): Block[] => {
+      const blocks: Block[] = [];
+      for (let index = 0; index < count; index++) {
+        blocks.push({ id: `f${index}`, role: "assistant", text: `p${index}.` });
+        if (index + 1 < count) {
+          blocks.push({ id: `f${index}-status`, role: "system", text: "Reviewed" });
+        }
+      }
+      return blocks;
+    };
+    const joined = (count: number) =>
+      Array.from({ length: count }, (_, index) => `p${index}.`).join("");
+    // Control: a short chain of the same shape welds into one assistant block.
+    const merged = backfillOmpInterjections(chain(3), [], source(joined(3)));
+    expect(merged.map(block => [block.id, block.text])).toEqual([
+      ["f0", joined(3)], ["f0-status", "Reviewed"], ["f1-status", "Reviewed"],
+    ]);
+    // 2_500 fragments drive the recursive alignment past its depth budget;
+    // the persisted repair must fail closed, not weld by a weaker rule.
+    const deep = chain(2_500);
+    const result = backfillOmpInterjections(deep, [], source(joined(2_500)));
+    expect(result).toBe(deep);
+    expect(result).toEqual(deep);
+  });
+});
+
+describe("persisted session loading", () => {
+  function stored(harness: "omp" | "pi" = "omp", providerSessionId: string | undefined = "provider") {
+    return { ...newSession(harness, "/tmp/project"), id: "repair-load", providerSessionId, blocks: oldBlocks() };
+  }
+
+  it("repairs before returning and persists only the first repair", async () => {
+    let record = stored();
+    let writes = 0;
+    mocks.invoke.mockImplementation(async (command, args) => {
+      if (command === "session_get") return record;
+      if (command === "omp_session_interjections") return [anchor];
+      if (command === "session_upsert") {
+        writes += 1;
+        record = { ...record, ...args.session };
+        return record;
+      }
+      throw new Error(command);
+    });
+    const first = await getSession(record.id);
+    expect(foldedIds(first!.blocks)).toEqual(["r2", "t2"]);
+    const second = await getSession(record.id);
+    expect(second!.blocks).toEqual(first!.blocks);
+    expect(writes).toBe(1);
+  });
+
+  it.each([true, false])("repairs unanchored status splits only when verified: %s", async verified => {
+    let record = { ...stored(), blocks: [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+      { id: "u", role: "user", text: "Continue" },
+    ] as Block[] };
+    const original = record.blocks;
+    let writes = 0;
+    mocks.invoke.mockImplementation(async (command, args) => {
+      if (command === "session_get") return record;
+      if (command === "omp_session_interjections") return [];
+      if (command === "omp_active_assistant_texts") {
+        expect(args).toEqual({ providerSessionId: "provider" });
+        return verified ? [{ text: "First.Second.", concat: "First.Second." }] : [];
+      }
+      if (command === "session_upsert") {
+        writes++;
+        record = { ...record, ...args.session };
+        return record;
+      }
+      throw new Error(command);
+    });
+    const first = await getSession(record.id);
+    expect(first!.blocks).toEqual(verified
+      ? [{ ...original[0], text: "First.Second." }, original[1], original[3]] : original);
+    expect((await getSession(record.id))!.blocks).toEqual(first!.blocks);
+    expect(writes).toBe(verified ? 1 : 0);
+  });
+
+  it.each([false, true])("loads duplicate text without reusing occupied source evidence, complete first: %s", async complete => {
+    const first: Block[] = complete ? [{ id: "a", role: "assistant", text: "First.Second." }] : [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "s1", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+    ];
+    const later: Block[] = [
+      { id: "c", role: "assistant", text: "First." },
+      { id: "s2", role: "system", text: "Reviewed" },
+      { id: "d", role: "assistant", text: "Second." },
+    ];
+    const record = { ...stored(), blocks: [...first, ...later] };
+    mocks.invoke.mockImplementation(async (command, args) => {
+      if (command === "session_get") return record;
+      if (command === "omp_session_interjections") return [];
+      if (command === "omp_active_assistant_texts") return [{ text: "First.Second.", concat: "First.Second." }];
+      if (command === "session_upsert") return args.session;
+      throw new Error(command);
+    });
+    const loaded = (await getSession(record.id))!;
+    expect(loaded.blocks[0]).toMatchObject({ id: "a", text: "First.Second." });
+    expect(loaded.blocks.slice(-3)).toEqual(later);
+    expect(loaded.blocks).toHaveLength(complete ? 4 : 5);
+  });
+
+  it("loads a split of two source messages before their concatenation unchanged", async () => {
+    const record = { ...stored(), blocks: [
+      { id: "a", role: "assistant", text: "First." },
+      { id: "status", role: "system", text: "Reviewed" },
+      { id: "b", role: "assistant", text: "Second." },
+      { id: "c", role: "assistant", text: "First.Second." },
+    ] as Block[] };
+    const commands: string[] = [];
+    mocks.invoke.mockImplementation(async command => {
+      commands.push(command);
+      if (command === "session_get") return record;
+      if (command === "omp_session_interjections") return [];
+      if (command === "omp_active_assistant_texts") {
+        return ["First.", "Second.", "First.Second."].map(text => ({ text, concat: text }));
+      }
+      throw new Error(command);
+    });
+    expect((await getSession(record.id))!.blocks).toEqual(record.blocks);
+    expect(commands).toEqual(["session_get", "omp_session_interjections", "omp_active_assistant_texts"]);
+  });
+
+  it("leaves other harnesses and unbound OMP sessions untouched", async () => {
+    const other = stored("pi");
+    mocks.invoke.mockResolvedValue(other);
+    expect((await getSession(other.id))!.blocks).toEqual(other.blocks);
+    const unbound = { ...stored(), providerSessionId: undefined };
+    mocks.invoke.mockResolvedValue(unbound);
+    expect((await getSession(unbound.id))!.blocks).toEqual(unbound.blocks);
+    expect(mocks.invoke.mock.calls.map(call => call[0])).toEqual(["session_get", "session_get"]);
+  });
+
+  it("loads normally when the source command fails", async () => {
+    const record = stored();
+    mocks.invoke.mockImplementation(async command => {
+      if (command === "session_get") return record;
+      throw new Error("Log unavailable");
+    });
+    expect((await getSession(record.id))!.blocks).toEqual(record.blocks);
+  });
+
+  it("still displays recovered boundaries when persistence fails", async () => {
+    const record = stored();
+    mocks.invoke.mockImplementation(async command => {
+      if (command === "session_get") return record;
+      if (command === "omp_session_interjections") return [anchor];
+      throw new Error("Database unavailable");
+    });
+    expect(foldedIds((await getSession(record.id))!.blocks)).toEqual(["r2", "t2"]);
+  });
+});
diff --git a/src/lib/ompInterjections.ts b/src/lib/ompInterjections.ts
new file mode 100644
index 00000000..f333ba1d
--- /dev/null
+++ b/src/lib/ompInterjections.ts
@@ -0,0 +1,362 @@
+import type { OmpAssistantText, OmpInterjectionAnchor } from "./fs";
+import type { Block } from "./session";
+
+interface BoundaryNode {
+  block: Block;
+  index: number;
+  offset: number;
+  next?: BoundaryNode;
+}
+
+function sourceOrder(a: BoundaryNode, b: BoundaryNode): number {
+  return a.index - b.index || a.offset - b.offset;
+}
+
+/** For each block index, the next fragment index in a status-split chain
+ * (0 when none): every intervening row is a non-interjection system row and
+ * the next other row is a clean assistant block. */
+function chainHops(blocks: Block[]): Int32Array {
+  const hop = new Int32Array(blocks.length);
+  let nextNonStatus = blocks.length;
+  for (let index = blocks.length - 1; index >= 0; index--) {
+    const block = blocks[index];
+    if (block.role === "system" && !block.interjection) continue;
+    const last = nextNonStatus < blocks.length ? blocks[nextNonStatus] : undefined;
+    if (
+      block.role === "assistant" && block.text && !block.streaming &&
+      nextNonStatus > index + 1 && last?.role === "assistant" && last.text &&
+      !last.streaming &&
+      Object.keys(last).every(key => ["id", "role", "text", "streaming"].includes(key))
+    ) hop[index] = nextNonStatus;
+    nextNonStatus = index;
+  }
+  return hop;
+}
+
+/** Collect only shapes whose trailing fragments can be removed without data loss. */
+export function ompStatusSplitTexts(blocks: Block[]): string[] {
+  const hop = chainHops(blocks);
+  const texts: string[] = [];
+  let previous = -1;
+  for (let index = 0; index < blocks.length; index++) {
+    const block = blocks[index];
+    if (block.role === "system" && !block.interjection) continue;
+    if (hop[index] && (previous < 0 || hop[previous] !== index)) {
+      let text = block.text;
+      for (let next = hop[index]; next; next = hop[next]) text += blocks[next].text;
+      texts.push(text);
+    }
+    previous = index;
+  }
+  return texts;
+}
+
+/** Positions of every source text under both join forms; one message, one slot. */
+function sourcePositions(source: readonly OmpAssistantText[]): Map<string, number[]> {
+  const positions = new Map<string, number[]>();
+  source.forEach((message, slot) => {
+    const list = positions.get(message.text);
+    if (list) list.push(slot);
+    else positions.set(message.text, [slot]);
+    if (message.concat !== message.text) {
+      const concatList = positions.get(message.concat);
+      if (concatList) concatList.push(slot);
+      else positions.set(message.concat, [slot]);
+    }
+  });
+  return positions;
+}
+
+function slotAt(positions: Map<string, number[]>, text: string, from: number, limit: number): number {
+  const list = positions.get(text);
+  if (!list) return limit;
+  let lo = 0;
+  let hi = list.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (list[mid] < from) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo < list.length ? list[lo] : limit;
+}
+
+type AlignmentScore = readonly [number, number]; // [items matched, consumed slot sum]
+
+function beats(a: AlignmentScore, b: AlignmentScore): boolean {
+  return a[0] > b[0] || (a[0] === b[0] && a[1] < b[1]);
+}
+
+/** Undo status-only splits through the best in-order alignment between the
+ * persisted assistant sequence and the ordered active-path source messages.
+ * Every assistant block claims its earliest free source slot; a split
+ * candidate may instead weld a prefix of its fragments into one slot by
+ * their combined text. An alignment scores (blocks + source messages
+ * matched, then earliest consumed positions), decided per candidate against
+ * the optimal continuation: a weld never wins when the fragments explain
+ * themselves as real messages — including when the matching combined text is
+ * a message the transcript simply never stored — and equal matches resolve
+ * toward explaining earlier source slots. Anchors never authorize a merge.
+ * Pathological inputs exceed the alignment budget and fail closed: the
+ * blocks are returned unmerged rather than welded by a weaker rule.
+ */
+function mergeStatusSplits(blocks: Block[], source: readonly OmpAssistantText[]): Block[] {
+  const limit = source.length;
+  const width = limit + 1;
+  const positions = sourcePositions(source);
+  const maxText = source.reduce(
+    (max, message) => Math.max(max, message.text.length, message.concat.length), 0);
+  const nextSlot = (text: string, from: number) => slotAt(positions, text, from, limit);
+  const bindable = (block: Block) =>
+    block.role === "assistant" && !block.streaming && !!block.text;
+  const hop = chainHops(blocks);
+  try {
+    // Best continuation score for blocks[i..] against source[j..]: inert
+    // rows and single blocks are forced, so only split candidates branch.
+    const memo = new Map<number, AlignmentScore>();
+    let depth = 0;
+    let built = 0;
+    const score = (i: number, j: number): AlignmentScore => {
+      const key = i * width + j;
+      const hit = memo.get(key);
+      if (hit !== undefined) return hit;
+      if (depth > 2_000 || memo.size > 500_000) throw new Error("alignment budget");
+      depth++;
+      try {
+        let matched = 0;
+        let consumed = 0;
+        while (i < blocks.length) {
+          const block = blocks[i];
+          if (!bindable(block)) {
+            i++;
+            continue;
+          }
+          if (!hop[i]) {
+            const own = nextSlot(block.text, j);
+            if (own < limit) {
+              j = own + 1;
+              matched += 2;
+              consumed += own;
+            }
+            i++;
+            continue;
+          }
+          const own = nextSlot(block.text, j);
+          const tail = score(i + 1, own < limit ? own + 1 : j);
+          let best: AlignmentScore = own < limit
+            ? [tail[0] + 2, tail[1] + own]
+            : tail;
+          let combined = block.text;
+          for (let f = hop[i], t = 1; f && combined.length <= maxText; f = hop[f], t++) {
+            combined += blocks[f].text;
+            built += blocks[f].text.length;
+            if (built > 4_000_000) throw new Error("alignment budget");
+            // A weld that lands behind the first fragment's own slot would
+            // reorder evidence backward — the earlier exact claim wins.
+            const mergeSlot = nextSlot(combined, j);
+            if (mergeSlot < limit && (own >= limit || mergeSlot <= own)) {
+              const rest = score(f + 1, mergeSlot + 1);
+              const candidate: AlignmentScore = [rest[0] + t + 2, rest[1] + mergeSlot];
+              if (!beats(best, candidate)) best = candidate;
+            }
+          }
+          const total: AlignmentScore = [matched + best[0], consumed + best[1]];
+          memo.set(key, total);
+          return total;
+        }
+        const total: AlignmentScore = [matched, consumed];
+        memo.set(key, total);
+        return total;
+      } finally {
+        depth--;
+      }
+    };
+    let cursor = 0;
+    let repaired: Block[] | undefined;
+    for (let index = 0; index < blocks.length; index++) {
+      const first = blocks[index];
+      if (bindable(first) && hop[index]) {
+        const own = nextSlot(first.text, cursor);
+        const tail = score(index + 1, own < limit ? own + 1 : cursor);
+        let best: AlignmentScore = own < limit ? [tail[0] + 2, tail[1] + own] : tail;
+        let chosen: { last: number; slot: number; text: string } | undefined;
+        let combined = first.text;
+        for (let f = hop[index], t = 1; f && combined.length <= maxText; f = hop[f], t++) {
+          combined += blocks[f].text;
+          built += blocks[f].text.length;
+          if (built > 4_000_000) throw new Error("alignment budget");
+          const mergeSlot = nextSlot(combined, cursor);
+          if (mergeSlot < limit && (own >= limit || mergeSlot <= own)) {
+            const rest = score(f + 1, mergeSlot + 1);
+            const candidate: AlignmentScore = [rest[0] + t + 2, rest[1] + mergeSlot];
+            if (!beats(best, candidate)) {
+              best = candidate;
+              chosen = { last: f, slot: mergeSlot, text: combined };
+            }
+          }
+        }
+        if (chosen) {
+          repaired ??= blocks.slice(0, index);
+          repaired.push(
+            { ...first, text: chosen.text },
+            ...blocks.slice(index + 1, chosen.last).filter(block => block.role === "system"),
+          );
+          cursor = chosen.slot + 1;
+          index = chosen.last;
+          continue;
+        }
+        if (own < limit) cursor = own + 1;
+      } else if (bindable(first)) {
+        const own = nextSlot(first.text, cursor);
+        if (own < limit) cursor = own + 1;
+      }
+      repaired?.push(first);
+    }
+    return repaired ?? blocks;
+  } catch {
+    return blocks;
+  }
+}
+
+/** Restore omitted boundaries, not turns: live interjections also stay mid-turn.
+ * Exact text and one-based occurrence avoid inventing boundaries for progress
+ * prose. Split coalesced blocks only when both complete source messages
+ * concatenate exactly to their text; prefixes alone are not evidence.
+ */
+export function backfillOmpInterjections(
+  blocks: Block[],
+  anchors: readonly OmpInterjectionAnchor[],
+  source: readonly OmpAssistantText[] = [],
+): Block[] {
+  const merged = mergeStatusSplits(blocks, source);
+  if (anchors.length === 0) return merged;
+  const positions = new Map<string, BoundaryNode[]>();
+  const ids = new Map<string, BoundaryNode>();
+  const nodes = merged.map((block, index): BoundaryNode => ({ block, index, offset: 0 }));
+  function addPosition(node: BoundaryNode) {
+    const matches = positions.get(node.block.text);
+    if (matches) {
+      matches.push(node);
+      if (matches.length > 1 && sourceOrder(matches[matches.length - 2], node) > 0) {
+        matches.sort(sourceOrder);
+      }
+    } else positions.set(node.block.text, [node]);
+  }
+  nodes.forEach((node, index) => {
+    node.next = nodes[index + 1];
+    ids.set(node.block.id, node);
+    if (node.block.role === "assistant") addPosition(node);
+  });
+  const matchedLive = new Set<BoundaryNode>();
+  const boundaryEnds = new Map<BoundaryNode, BoundaryNode>();
+  let previous: BoundaryNode | undefined;
+  // A chain's final note alone has a directly linked continuation. Its exact
+  // split evidence also locates earlier notes sealing that same source message.
+  const continuations = new Map<string, Map<number, string>>();
+  function rememberContinuation(text: string, occurrence: number, following?: string | null) {
+    if (!following) return;
+    let byOccurrence = continuations.get(text);
+    if (!byOccurrence) continuations.set(text, byOccurrence = new Map());
+    byOccurrence.set(occurrence, following);
+  }
+  for (const anchor of anchors) {
+    rememberContinuation(anchor.afterAssistantText, anchor.afterOccurrence, anchor.followingAssistantText);
+    if (anchor.afterAssistantTextConcat !== undefined) {
+      rememberContinuation(anchor.afterAssistantTextConcat, anchor.afterConcatOccurrence ?? anchor.afterOccurrence, anchor.followingAssistantTextConcat);
+    }
+  }
+  let changed = merged !== blocks;
+  for (const anchor of anchors) {
+    // Keep legacy newline matches and IDs; live streams concatenate text parts.
+    // Each representation has its own occurrence count, never fuzzy matching.
+    function match(text: string, occurrence: number, following?: string | null) {
+      following ??= continuations.get(text)?.get(occurrence);
+      const exact = positions.get(text) ?? [];
+      const combined = following ? positions.get(text + following) ?? [] : [];
+      const candidates = combined.length ? [...exact, ...combined].sort(sourceOrder) : exact;
+      return candidates[occurrence - 1];
+    }
+    let afterText = anchor.afterAssistantText;
+    let node = match(afterText, anchor.afterOccurrence, anchor.followingAssistantText);
+    if (!node && anchor.afterAssistantTextConcat !== undefined) {
+      afterText = anchor.afterAssistantTextConcat;
+      node = match(afterText, anchor.afterConcatOccurrence ?? anchor.afterOccurrence, anchor.followingAssistantTextConcat);
+    }
+    if (!node || (previous && sourceOrder(node, previous) < 0)) continue;
+    previous = node;
+    const id = `omp-interjection-${anchor.id}`;
+    let boundary = ids.get(id);
+    // Newer builds already stored live interjections with random IDs. Match
+    // only the adjacent boundary, and consume each live row at most once.
+    if (!boundary) {
+      for (let live = node.next; live; live = live.next) {
+        const block = live.block;
+        if (block.role !== "system" || !block.interjection) break;
+        if (
+          !matchedLive.has(live) &&
+          !block.id.startsWith("omp-interjection-") &&
+          block.text === anchor.text &&
+          block.interjection.customType === anchor.customType &&
+          block.interjection.severity === (anchor.severity ?? undefined)
+        ) {
+          matchedLive.add(live);
+          boundary = live;
+          break;
+        }
+      }
+    }
+    if (!boundary) {
+      const end = boundaryEnds.get(node) ?? node;
+      boundary = {
+        block: {
+          id,
+          role: "system",
+          text: anchor.text,
+          interjection: {
+            customType: anchor.customType,
+            ...(anchor.severity ? { severity: anchor.severity } : {}),
+          },
+        },
+        index: node.index,
+        offset: node.offset,
+        next: end.next,
+      };
+      end.next = boundary;
+      ids.set(id, boundary);
+      changed = true;
+    }
+    boundaryEnds.set(node, boundary);
+    if (node.block.text !== afterText) {
+      const text = node.block.text;
+      const split = afterText.length;
+      let end = boundary;
+      while (end.next?.block.role === "system" && end.next.block.interjection) {
+        end = end.next;
+      }
+      const continuation: BoundaryNode = {
+        block: {
+          id: `${node.block.id}-${id}-continuation`,
+          role: "assistant",
+          text: text.slice(split),
+        },
+        index: node.index,
+        offset: node.offset + split,
+        next: end.next,
+      };
+      // The suffix belongs to this boundary, not to an insertion's old index.
+      // Index it now so later source anchors can target it in this same pass.
+      end.next = continuation;
+      positions.set(text, positions.get(text)!.filter(match => match !== node));
+      node.block = { ...node.block, text: afterText };
+      addPosition(node);
+      addPosition(continuation);
+      ids.set(continuation.block.id, continuation);
+      changed = true;
+    }
+  }
+  if (!changed) return blocks;
+  const repaired: Block[] = [];
+  for (let node: BoundaryNode | undefined = nodes[0]; node; node = node.next) {
+    repaired.push(node.block);
+  }
+  return repaired;
+}
diff --git a/src/lib/session.ts b/src/lib/session.ts
index e1261e4e..5477fabf 100644
--- a/src/lib/session.ts
+++ b/src/lib/session.ts
@@ -95,6 +95,15 @@ export type SecondOpinionMeta = {
   kind?: "handoff";
 };
 
+/** A mid-turn interjection the harness asked to surface, e.g. OMP advisor notes. */
+export type InterjectionSeverity = "nit" | "concern" | "blocker";
+
+export type InterjectionMeta = {
+  customType: string;
+  /** Highest severity among this interjection's retained notes, when any is known. */
+  severity?: InterjectionSeverity;
+};
+
 export type ToolPreviewKind = "read" | "write" | "shell" | "search";
 
 export type ToolPreviewLineKind = "add" | "del" | "context";
@@ -227,6 +236,8 @@ export type Block = {
   secondOpinion?: SecondOpinionMeta;
   /** Note chip shown on this user turn. Body is not stored; the harness already received it. */
   noteCard?: NoteCardMeta;
+  /** Mid-turn interjection chrome; system blocks only. Body lives in text. */
+  interjection?: InterjectionMeta;
 };
 
 export type RuntimeMode =
diff --git a/src/lib/sessionStore.test.ts b/src/lib/sessionStore.test.ts
index c09306e4..a762b648 100644
--- a/src/lib/sessionStore.test.ts
+++ b/src/lib/sessionStore.test.ts
@@ -194,6 +194,53 @@ describe("sanitizeSessionForPersist", () => {
     });
   });
 
+  it("keeps valid interjection chrome only on system blocks", () => {
+    const session = newSession("pi", "/tmp/project");
+    session.blocks = [
+      {
+        id: "i1",
+        role: "system",
+        text: "Review the fallback.",
+        interjection: { customType: " advisor ", severity: "blocker" },
+      },
+      {
+        id: "a1",
+        role: "assistant",
+        text: "Not chrome",
+        interjection: { customType: "advisor", severity: "nit" },
+      },
+    ];
+
+    const persisted = sanitizeSessionForPersist(session);
+    expect(persisted.blocks[0]).toMatchObject({
+      role: "system",
+      text: "Review the fallback.",
+      interjection: { customType: "advisor", severity: "blocker" },
+    });
+    expect(persisted.blocks[1]?.interjection).toBeUndefined();
+  });
+
+  it("drops malformed interjection metadata without dropping its system row", () => {
+    const session = newSession("pi", "/tmp/project");
+    session.blocks = [
+      {
+        id: "i1",
+        role: "system",
+        text: "Still visible",
+        interjection: {
+          customType: " ",
+          severity: "unknown",
+        } as unknown as Block["interjection"],
+      },
+    ];
+
+    expect(sanitizeSessionForPersist(session).blocks[0]).toEqual({
+      id: "i1",
+      role: "system",
+      text: "Still visible",
+    });
+  });
+
   it("keeps a second-opinion card on the user turn", () => {
     const session = newSession("codex", "/tmp/project");
     session.blocks = [
diff --git a/src/lib/sessionStore.ts b/src/lib/sessionStore.ts
index e55cd640..ae9170da 100644
--- a/src/lib/sessionStore.ts
+++ b/src/lib/sessionStore.ts
@@ -3,6 +3,8 @@ import { recoverCursorSubagents } from "./harness/cursorSubagents";
 import { persistableAttachment } from "./attachments";
 import type { ContextUsage } from "./contextUsage";
 import { normalizeProjectPath } from "./recents";
+import { ompActiveAssistantTexts, ompSessionInterjections } from "./fs";
+import { backfillOmpInterjections, ompStatusSplitTexts } from "./ompInterjections";
 import type {
   AgentRunMeta,
   AgentStep,
@@ -10,6 +12,7 @@ import type {
   HarnessId,
   HandoffMeta,
   HandoffStatus,
+  InterjectionMeta,
   LinkedWorkItem,
   RuntimeMode,
   SecondOpinionMeta,
@@ -278,7 +281,29 @@ export async function getSession(sessionId: string): Promise<Session | null> {
     sessionId,
   });
   if (!record) return null;
-  return recoverCursorSubagents(recordToSession(record));
+  const session = recordToSession(record);
+  if (session.harness !== "omp" || !session.providerSessionId) {
+    return recoverCursorSubagents(session);
+  }
+  try {
+    const anchors = await ompSessionInterjections(session.providerSessionId);
+    // Missing source order must not prevent the existing anchored repair.
+    const source = ompStatusSplitTexts(session.blocks).length
+      ? await ompActiveAssistantTexts(session.providerSessionId).catch(() => [])
+      : [];
+    const blocks = backfillOmpInterjections(session.blocks, anchors, source);
+    if (blocks !== session.blocks) {
+      session.blocks = blocks;
+      // Persist before exposing the restored session to a new live turn.
+      // Re-reading the source on later loads allows partial repairs to retry;
+      // deterministic IDs ensure already repaired transcripts are not written.
+      await upsertSession(session);
+    }
+  } catch {
+    // Source logs may be absent/unreadable. Even a failed write must not stop
+    // restore; the recovered in-memory boundaries can still be displayed.
+  }
+  return session;
 }
 
 export async function deleteSession(sessionId: string): Promise<void> {
@@ -413,6 +438,12 @@ function sanitizeBlock(block: Block): Block | null {
   if (secondOpinion) next.secondOpinion = secondOpinion;
   const noteCard = sanitizeNoteCard(block.noteCard);
   if (noteCard) next.noteCard = noteCard;
+  // Interjection chrome survives restarts only on system blocks; a malformed
+  // payload keeps the ordinary system row rather than losing its body.
+  if (block.role === "system") {
+    const interjection = sanitizeInterjection(block.interjection);
+    if (interjection) next.interjection = interjection;
+  }
   return next;
 }
 
@@ -468,6 +499,25 @@ function sanitizeTurnModel(value: unknown): TurnModel | undefined {
   return { harness: harness as HarnessId, id, name };
 }
 
+function sanitizeInterjection(
+  value: Block["interjection"],
+): InterjectionMeta | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const record = value as Record<string, unknown>;
+  const customType =
+    typeof record.customType === "string" ? record.customType.trim() : "";
+  if (!customType) return undefined;
+  const severity = record.severity;
+  return {
+    customType,
+    ...(severity === "nit" || severity === "concern" || severity === "blocker"
+      ? { severity }
+      : {}),
+  };
+}
+
 function sanitizePlan(value: unknown, text: string): PlanBlockMeta | null {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
diff --git a/src/surfaces/AgentTranscript.interjection.test.ts b/src/surfaces/AgentTranscript.interjection.test.ts
new file mode 100644
index 00000000..01ba5016
--- /dev/null
+++ b/src/surfaces/AgentTranscript.interjection.test.ts
@@ -0,0 +1,89 @@
+// @vitest-environment happy-dom
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Block } from "../lib/session";
+import { AgentTranscript } from "./AgentTranscript";
+
+let container: HTMLDivElement;
+let root: Root;
+let bodyHeight: number;
+let resize: () => void;
+
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  // happy-dom has no layout; supply the measured dimensions, not an estimate
+  // based on text length (a short string can wrap in a narrow transcript).
+  bodyHeight = 200;
+  vi.spyOn(HTMLElement.prototype, "scrollHeight", "get").mockImplementation(
+    () => bodyHeight,
+  );
+  vi.spyOn(HTMLElement.prototype, "clientHeight", "get").mockImplementation(
+    () => 40,
+  );
+  vi.stubGlobal("ResizeObserver", class {
+    constructor(private callback: () => void) {}
+    observe(el: Element) {
+      if (el.tagName === "PRE") resize = this.callback;
+    }
+    disconnect() {}
+  });
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function render(text: string, severity: "blocker" | "concern" = "concern") {
+  const blocks: Block[] = [{
+    id: "advisor",
+    role: "system",
+    text,
+    interjection: { customType: "advisor", severity },
+  }];
+  act(() => root.render(createElement(AgentTranscript, { blocks, busy: false })));
+}
+
+const note = "Check the fallback.\n```ts\nconst result = read();\nif (!result) throw new Error('missing');\n```";
+
+describe("AgentTranscript interjection preview", () => {
+  it("clamps long blocker bodies by default while retaining the label and full text", () => {
+    render(note, "blocker");
+    expect(container.querySelector("pre")?.classList.contains("line-clamp-2")).toBe(true);
+    expect(container.querySelector("pre")?.textContent).toBe(note);
+    expect(container.querySelector('[aria-label="Interjection: Advisor"]')?.textContent).toContain("Blocker");
+    expect(container.querySelector("button")?.getAttribute("aria-expanded")).toBe("false");
+  });
+
+  it("expands and reclamps without losing the collapse control", () => {
+    render(note);
+    const button = container.querySelector<HTMLButtonElement>("button")!;
+    act(() => button.click());
+    expect(button.getAttribute("aria-expanded")).toBe("true");
+    expect(container.querySelector("pre")?.classList.contains("line-clamp-2")).toBe(false);
+    expect(container.querySelector("pre")?.textContent).toBe(note);
+    act(() => resize());
+    expect(container.querySelector("button")).toBe(button);
+    act(() => button.click());
+    expect(button.getAttribute("aria-expanded")).toBe("false");
+    expect(container.querySelector("pre")?.classList.contains("line-clamp-2")).toBe(true);
+  });
+
+  it("omits the toggle for fitting text and remeasures when the transcript reflows", () => {
+    bodyHeight = 20;
+    render("Check this.");
+    expect(container.querySelector("button")).toBeNull();
+    bodyHeight = 60;
+    act(() => resize());
+    expect(container.querySelector("button")?.getAttribute("aria-expanded")).toBe("false");
+    bodyHeight = 40;
+    act(() => resize());
+    expect(container.querySelector("button")).toBeNull();
+  });
+});
diff --git a/src/surfaces/AgentTranscript.test.ts b/src/surfaces/AgentTranscript.test.ts
index 5df1d385..7088bb62 100644
--- a/src/surfaces/AgentTranscript.test.ts
+++ b/src/surfaces/AgentTranscript.test.ts
@@ -352,4 +352,25 @@ describe("AgentTranscript collapsed work", () => {
       markup.indexOf('aria-label="Worked for 1s"'),
     );
   });
+
+  it("renders an advisor interjection between answered work phases", () => {
+    const markup = render([
+      tool("before"),
+      { id: "answer", role: "assistant", text: "Complete answer." },
+      {
+        id: "advisor",
+        role: "system",
+        text: "Check the fallback.",
+        interjection: { customType: "advisor", severity: "concern" },
+      },
+      tool("after"),
+      { id: "ack", role: "assistant", text: "Checked." },
+    ]);
+
+    expect(markup).toContain("Complete answer.");
+    expect(markup).toContain('aria-label="Interjection: Advisor"');
+    expect(markup).toContain("Concern");
+    expect(markup).toContain("Check the fallback.");
+    expect(markup).toContain("Checked.");
+  });
 });
diff --git a/src/surfaces/AgentTranscript.tsx b/src/surfaces/AgentTranscript.tsx
index ebf36ba7..10a64c88 100644
--- a/src/surfaces/AgentTranscript.tsx
+++ b/src/surfaces/AgentTranscript.tsx
@@ -1055,6 +1055,9 @@ const TranscriptBlock = memo(function TranscriptBlock({
   }
 
   if (block.role === "system") {
+    if (block.interjection) {
+      return <InterjectionDivider block={block} />;
+    }
     return (
       <div className="px-4 py-2 text-content/50">
         <pre className="min-w-0 whitespace-pre-wrap break-words">
@@ -2676,6 +2679,94 @@ function HandoffDivider({ block }: { block: Block }) {
   );
 }
 
+/** A mid-turn interjection, e.g. OMP advisor notes: a labeled boundary with
+ * a collapsible advisory body below it. */
+function InterjectionDivider({ block }: { block: Block }) {
+  const [expanded, setExpanded] = useState(false);
+  const [overflows, setOverflows] = useState(false);
+  const textRef = useRef<HTMLPreElement>(null);
+
+  useLayoutEffect(() => {
+    const el = textRef.current;
+    if (!el || !block.text) {
+      setOverflows(false);
+      return;
+    }
+    const measure = () => {
+      if (!expanded) {
+        setOverflows(el.scrollHeight > el.clientHeight + 1);
+      }
+    };
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [block.text, expanded]);
+
+  const meta = block.interjection;
+  if (!meta) return null;
+  const label =
+    meta.customType === "advisor"
+      ? "Advisor"
+      : meta.customType === "custom"
+        ? "Notice"
+        : meta.customType;
+  const severityText =
+    meta.severity === "blocker"
+      ? "Blocker"
+      : meta.severity === "concern"
+        ? "Concern"
+        : meta.severity === "nit"
+          ? "Nit"
+          : undefined;
+  const severityClass =
+    meta.severity === "blocker"
+      ? "text-red-400"
+      : meta.severity === "concern"
+        ? "text-amber-400"
+        : "text-content/55";
+  return (
+    <div className="px-4 py-4">
+      <div className="flex items-center gap-3">
+        <div className="h-px min-w-4 flex-1 bg-content/12" />
+        <div
+          role="separator"
+          aria-label={`Interjection: ${label}`}
+          className="flex items-center gap-2 px-1.5 font-sans text-[12px] text-content/55"
+        >
+          <span>{label}</span>
+          {severityText ? (
+            <span className={`text-[11px] ${severityClass}`}>
+              {severityText}
+            </span>
+          ) : null}
+        </div>
+        <div className="h-px min-w-4 flex-1 bg-content/12" />
+      </div>
+      {block.text ? (
+        <div className="mt-2 px-2">
+          <pre
+            ref={textRef}
+            className={`min-w-0 whitespace-pre-wrap break-words font-sans text-[12.5px] leading-5 text-content/70 ${expanded ? "" : "line-clamp-2"}`}
+          >
+            {block.text}
+          </pre>
+          {overflows ? (
+            <button
+              type="button"
+              aria-expanded={expanded}
+              onClick={() => setExpanded((value) => !value)}
+              className="mt-1 py-1 font-sans text-xs text-content/55 hover:text-content"
+            >
+              {expanded ? "Show less" : "Show more"}
+            </button>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
 function lastUserBlockId(blocks: Block[]): string | undefined {
   return turnUserBlock(blocks)?.id;
 }
diff --git a/src/surfaces/transcriptActivity.test.ts b/src/surfaces/transcriptActivity.test.ts
index c20ad288..d3fe6a8b 100644
--- a/src/surfaces/transcriptActivity.test.ts
+++ b/src/surfaces/transcriptActivity.test.ts
@@ -791,6 +791,27 @@ describe("foldableWork", () => {
     expect(foldableWork(turn)).toEqual({ start: 3, end: 3 });
   });
 
+  it("uses an interjection as a hard boundary between answered work phases", () => {
+    const turn = items([
+      shell("before"),
+      note("answer", "The complete answer."),
+      {
+        id: "advisor",
+        role: "system",
+        text: "Check the fallback.",
+        interjection: { customType: "advisor", severity: "nit" },
+      },
+      shell("after"),
+      note("ack", "Checked."),
+    ]);
+    const fold = foldableWork(turn)!;
+
+    expect(fold).toEqual({ start: 3, end: 3 });
+    expect(foldedBlocks(turn, fold).map((block) => block.id)).toEqual([
+      "after",
+    ]);
+  });
+
   it("leaves an approval attached to earlier work outside the fold", () => {
     const turn = items([
       shell("pending", "pending", { requestId: 1 }),
diff --git a/src/surfaces/transcriptActivity.ts b/src/surfaces/transcriptActivity.ts
index d7e4abac..3b2ba00b 100644
--- a/src/surfaces/transcriptActivity.ts
+++ b/src/surfaces/transcriptActivity.ts
@@ -682,6 +682,10 @@ export type WorkFold = { start: number; end: number };
  * approval. As the turn streams, each new paragraph folds the work and running
  * commentary before it, leaving the final answer visible. A late approval can
  * reopen that boundary so its controls remain available.
+ *
+ * Persisted interjections (system blocks with interjection chrome) are neither
+ * prose nor work, so they stop the fold: an answer the harness already showed
+ * never folds behind an interjection that arrived after it.
  */
 export function foldableWork(items: TurnItem[]): WorkFold | undefined {
   let end = -1;

From 79facefdf96f6b9b2bfa66248af96462a40430bd Mon Sep 17 00:00:00 2001
From: Andrew <andrii.kartava@gmail.com>
Date: Mon, 14 Sep 2026 10:31:19 +0300
Subject: [PATCH 13/17] Add `Close All Tabs` on `Cmd+Shift+W` (#215)

* Add `Close All Tabs` on `Cmd+Shift+W`

* Address review feedback on Close All Tabs
---
 src-tauri/src/menu.rs   |  51 ++++++++------
 src/App.tsx             | 150 +++++++++++++++++++++++++++++++++++++++-
 src/chrome/MenuBar.tsx  |  12 ++++
 src/lib/layout.test.ts  |  65 +++++++++++++++++
 src/lib/layout.ts       |  28 ++++++++
 src/lib/settings.ts     |   1 +
 src/lib/tabKeys.test.ts |  10 +++
 src/lib/tabKeys.ts      |   3 +
 8 files changed, 297 insertions(+), 23 deletions(-)

diff --git a/src-tauri/src/menu.rs b/src-tauri/src/menu.rs
index 6c58ff7d..af79def9 100644
--- a/src-tauri/src/menu.rs
+++ b/src-tauri/src/menu.rs
@@ -25,30 +25,33 @@ pub fn dispatch(app: &AppHandle, id: &str) {
         | "open_model_picker" | "open_settings" | "check_for_updates" => {
             let _ = app.emit(id, ());
         }
-        "zoom_in" | "zoom_out" | "zoom_reset" => {
-            // Zoom targets one window: a broadcast would make every window
-            // increment the shared scale setting on a single menu click.
-            let mut windows: Vec<_> = app.webview_windows().into_values().collect();
-            windows.sort_by(|a, b| a.label().cmp(b.label()));
-            let target = windows
+        // Zoom and Close All Tabs target one window: a broadcast would make
+        // every window act on a single menu click.
+        "zoom_in" | "zoom_out" | "zoom_reset" | "close_all_tabs" => emit_to_focused(app, id),
+        _ => {}
+    }
+}
+
+/// Emit `id` to the focused window, falling back to a visible one, then any.
+fn emit_to_focused(app: &AppHandle, id: &str) {
+    let mut windows: Vec<_> = app.webview_windows().into_values().collect();
+    windows.sort_by(|a, b| a.label().cmp(b.label()));
+    let target = windows
+        .iter()
+        .find(|window| window.is_focused().unwrap_or(false))
+        .or_else(|| {
+            windows
                 .iter()
-                .find(|window| window.is_focused().unwrap_or(false))
-                .or_else(|| {
-                    windows
-                        .iter()
-                        .find(|window| window.is_visible().unwrap_or(false))
-                })
-                .or(windows.first());
-            match target {
-                Some(window) => {
-                    let _ = app.emit_to(window.label(), id, ());
-                }
-                None => {
-                    let _ = app.emit(id, ());
-                }
-            }
+                .find(|window| window.is_visible().unwrap_or(false))
+        })
+        .or(windows.first());
+    match target {
+        Some(window) => {
+            let _ = app.emit_to(window.label(), id, ());
+        }
+        None => {
+            let _ = app.emit(id, ());
         }
-        _ => {}
     }
 }
 
@@ -97,6 +100,9 @@ fn build(app: &AppHandle) -> tauri::Result<Menu<Wry>> {
     let close_other_tabs = MenuItemBuilder::with_id("close_other_tabs", "Close Other Tabs")
         .accelerator("CmdOrCtrl+Alt+T")
         .build(app)?;
+    let close_all_tabs = MenuItemBuilder::with_id("close_all_tabs", "Close All Tabs")
+        .accelerator("CmdOrCtrl+Shift+W")
+        .build(app)?;
     let next_tab = MenuItemBuilder::with_id("next_tab", "Next Tab")
         .accelerator("CmdOrCtrl+Shift+]")
         .build(app)?;
@@ -159,6 +165,7 @@ fn build(app: &AppHandle) -> tauri::Result<Menu<Wry>> {
         .item(&split_down)
         .item(&close_tab)
         .item(&close_other_tabs)
+        .item(&close_all_tabs)
         .separator()
         .item(&prev_tab)
         .item(&next_tab)
diff --git a/src/App.tsx b/src/App.tsx
index 9e5c1b58..c357e9e1 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -55,6 +55,7 @@ import {
 } from "./lib/fileIndex";
 import {
   closeLeaf,
+  closeSurfacePanes,
   findSurfacePane,
   firstLeafId,
   focusedFileTab,
@@ -78,6 +79,7 @@ import {
   openSessionChangesTab,
   openTerminalTab,
   removePane,
+  resetTabToSession,
   replaceLeafId,
   setSplitRatio,
   siblingLeafId,
@@ -2065,7 +2067,7 @@ export default function App({
   );
 
   const onCloseTabs = useCallback(
-    (ids: string[], fallbackId: string) => {
+    (ids: string[], fallbackId: string, opts?: { confirmed?: boolean }) => {
       const current = tabsRef.current;
       const closingIds = new Set(ids);
       const closing = current.filter((tab) => closingIds.has(tab.id));
@@ -2106,6 +2108,12 @@ export default function App({
         void refreshHistory(sidebarCwd);
       };
 
+      // The caller already confirmed unsaved files and terminals.
+      if (opts?.confirmed) {
+        finishClose();
+        return;
+      }
+
       void (async () => {
         if (unsaved.length > 0) {
           const ok = await confirmDiscardUnsaved(
@@ -2391,6 +2399,139 @@ export default function App({
     [tabs, persistSession, refreshHistory, sidebarCwd],
   );
 
+  const onCloseAllTabs = useCallback(() => {
+    const tab = tabsRef.current.find(
+      (entry) => entry.id === activeTabIdRef.current,
+    );
+    if (!tab) return;
+
+    const seedSession = (cwd: string) => {
+      const seed = sessionsRef.current[0];
+      return newSession(
+        seed?.harness ?? "claude",
+        cwd,
+        seed?.model,
+        seed?.runtimeMode,
+        seed?.modelSettings,
+      );
+    };
+
+    // Stage one: files open in the active tab's editor panes close first.
+    // Only when none are open does the command close every workspace tab.
+    const editorFiles = tab.editorPanes.flatMap((pane) => pane.files);
+    if (editorFiles.length > 0) {
+      const remaining = closeSurfacePanes(tab, "editor");
+      if (!remaining) {
+        const closePlan = planWorkspaceTabClose({
+          tabs: tabsRef.current,
+          sessions: sessionsRef.current,
+          closingTabId: tab.id,
+          scope: tabCloseScope,
+        });
+        if (closePlan.action === "close") {
+          onCloseTab(tab.id);
+          return;
+        }
+      }
+      const unsaved = editorFiles.filter(
+        (file) => isFilesystemTab(file) && dirtyFilesRef.current.has(file.id),
+      );
+
+      const finishClose = () => {
+        let nextTab: WorkspaceTab;
+        let focusesSession: boolean;
+        if (remaining) {
+          nextTab = remaining;
+          focusesSession = sessionsRef.current.some(
+            (session) => session.id === remaining.focusedId,
+          );
+        } else {
+          // The tab held only editor panes and must stay: seed a session.
+          const session = seedSession(editorFiles[0].cwd || projectCwd);
+          setSessions((prev) => [...prev, session]);
+          nextTab = resetTabToSession(tab, session.id);
+          focusesSession = true;
+        }
+        setTabs((prev) =>
+          prev.map((entry) => (entry.id === tab.id ? nextTab : entry)),
+        );
+        setDirtyFiles((prev) => {
+          const updated = new Set(prev);
+          for (const file of editorFiles) updated.delete(file.id);
+          return updated;
+        });
+        setComposerFocused(focusesSession);
+      };
+
+      void (async () => {
+        if (unsaved.length > 0) {
+          const ok = await confirmDiscardUnsaved(
+            "Close all open files with unsaved changes?",
+          );
+          if (!ok) return;
+        }
+        finishClose();
+      })();
+      return;
+    }
+
+    // Stage two: the workspace always keeps one tab, so close every other
+    // tab and reset the active one to a blank session. Every confirmation
+    // runs before any tab changes, so a cancelled prompt leaves all tabs.
+    const otherIds = tabsRef.current
+      .filter((entry) => entry.id !== tab.id)
+      .map((entry) => entry.id);
+    const terminalFiles = (tab.terminalPanes ?? []).flatMap(
+      (pane) => pane.files,
+    );
+    const closingFiles = [
+      ...tabsRef.current
+        .filter((entry) => otherIds.includes(entry.id))
+        .flatMap((entry) => [
+          ...entry.editorPanes.flatMap((pane) => pane.files),
+          ...(entry.terminalPanes ?? []).flatMap((pane) => pane.files),
+        ]),
+      ...terminalFiles,
+    ];
+    const unsaved = closingFiles.filter(
+      (file) => isFilesystemTab(file) && dirtyFilesRef.current.has(file.id),
+    );
+    const terminals = closingFiles.filter((file) => file.terminal);
+
+    void (async () => {
+      if (unsaved.length > 0) {
+        const ok = await confirmDiscardUnsaved(
+          "Close all tabs with unsaved files?",
+        );
+        if (!ok) return;
+      }
+      if (terminals.length > 0) {
+        const ok = await confirmCloseTerminals(terminals);
+        if (!ok) return;
+      }
+      if (otherIds.length > 0) {
+        onCloseTabs(otherIds, tab.id, { confirmed: true });
+      }
+      const hasSession = leafIds(tab.layout).some((paneId) =>
+        sessionsRef.current.some((session) => session.id === paneId),
+      );
+      if (hasSession) {
+        // No editor files remain, so this commits without a prompt.
+        onClearTabSession(tab.id);
+        return;
+      }
+      // The tab held no session: seed one so the workspace stays usable.
+      const session = seedSession(terminalFiles[0]?.cwd || projectCwd);
+      setSessions((prev) => [...prev, session]);
+      setTabs((prev) =>
+        prev.map((entry) =>
+          entry.id === tab.id ? resetTabToSession(entry, session.id) : entry,
+        ),
+      );
+      setComposerFocused(true);
+    })();
+  }, [onCloseTab, onCloseTabs, onClearTabSession, projectCwd, tabCloseScope]);
+
   const onClosePane = useCallback(
     (sessionId?: string) => {
       // The project terminal is shared by every workspace tab in the project.
@@ -5452,6 +5593,7 @@ export default function App({
     onNew,
     onArchiveFocusedSession,
     onCloseOtherTabs,
+    onCloseAllTabs,
     onClosePane,
     onNext,
     onPrev,
@@ -5479,6 +5621,7 @@ export default function App({
     onNew,
     onArchiveFocusedSession,
     onCloseOtherTabs,
+    onCloseAllTabs,
     onClosePane,
     onNext,
     onPrev,
@@ -5602,6 +5745,7 @@ export default function App({
         if (cmd === "new") run("new", a.onNew);
         else if (cmd === "close-others")
           run("close-others", a.onCloseOtherTabs);
+        else if (cmd === "close-all") run("close-all", a.onCloseAllTabs);
         else if (cmd === "close") run("close", a.onClosePane);
         else if (cmd === "next") run("next", a.onNext);
         else if (cmd === "prev") run("prev", a.onPrev);
@@ -5683,6 +5827,9 @@ export default function App({
       listen("close_other_tabs", () =>
         run("close-others", actions.current.onCloseOtherTabs),
       ),
+      listen("close_all_tabs", () =>
+        run("close-all", actions.current.onCloseAllTabs),
+      ),
       listen("close_tab", () => run("close", actions.current.onClosePane)),
       listen("next_tab", () => run("next", actions.current.onNext)),
       listen("prev_tab", () => run("prev", actions.current.onPrev)),
@@ -5961,6 +6108,7 @@ export default function App({
                 activeTabId ? () => onCloseTab(activeTabId) : undefined
               }
               onCloseOtherTabs={onCloseOtherTabs}
+              onCloseAllTabs={onCloseAllTabs}
               onPickProject={pickProject}
               onFindInProject={onFindInProject}
               onSearch={onOpenSearch}
diff --git a/src/chrome/MenuBar.tsx b/src/chrome/MenuBar.tsx
index fdc8f493..bfbcf9ac 100644
--- a/src/chrome/MenuBar.tsx
+++ b/src/chrome/MenuBar.tsx
@@ -15,6 +15,7 @@ type Props = {
   onShowSourceControl?: () => void;
   onCloseCurrentTab?: () => void;
   onCloseOtherTabs?: () => void;
+  onCloseAllTabs?: () => void;
   onPickProject?: () => void;
   onFindInProject?: () => void;
   onSearch?: () => void;
@@ -34,6 +35,7 @@ export function MenuBar({
   onShowSourceControl,
   onCloseCurrentTab,
   onCloseOtherTabs,
+  onCloseAllTabs,
   onPickProject,
   onFindInProject,
   onSearch,
@@ -141,6 +143,9 @@ export function MenuBar({
         case "close_other_tabs":
           onCloseOtherTabs?.();
           break;
+        case "close_all_tabs":
+          onCloseAllTabs?.();
+          break;
         case "toggle_sidebar":
           onToggleSidebar();
           break;
@@ -168,6 +173,7 @@ export function MenuBar({
       closeMenu,
       onCloseCurrentTab,
       onCloseOtherTabs,
+      onCloseAllTabs,
       onFindInProject,
       onGoToFile,
       onNew,
@@ -205,6 +211,12 @@ export function MenuBar({
             label: "Close Other Tabs",
             shortcut: `${MOD}${ALT}T`,
           },
+          {
+            kind: "item",
+            id: "close_all_tabs",
+            label: "Close All Tabs",
+            shortcut: `${MOD}${SHIFT}W`,
+          },
           { kind: "sep" },
           { kind: "item", id: "check_for_updates", label: "Check for Updates…" },
         ];
diff --git a/src/lib/layout.test.ts b/src/lib/layout.test.ts
index d864c40d..b25ccade 100644
--- a/src/lib/layout.test.ts
+++ b/src/lib/layout.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   closeLeaf,
+  closeSurfacePanes,
   editorTabKey,
   isChangesTab,
   isCommitTab,
@@ -22,6 +23,7 @@ import {
   newTerminalFile,
   newTerminalWorkspaceTab,
   nextTerminalTitle,
+  resetTabToSession,
   isolateTerminalPanes,
   movePane,
   openChangesTab,
@@ -329,6 +331,69 @@ describe("closeLeaf", () => {
   });
 });
 
+describe("closeSurfacePanes", () => {
+  it("keeps the chat and clears every editor pane", () => {
+    const tab = openEditorTab(
+      openEditorTab(newTab("session-a"), newFileTab("/repo/a.ts", "/repo")),
+      newFileTab("/repo/b.ts", "/repo"),
+      { split: "right" },
+    );
+    const next = closeSurfacePanes(tab, "editor");
+    expect(next).not.toBeNull();
+    expect(layoutLeaves(next!.layout).map((pane) => pane.id)).toEqual([
+      "session-a",
+    ]);
+    expect(next!.focusedId).toBe("session-a");
+    expect(next!.editorPanes).toEqual([]);
+  });
+
+  it("keeps a terminal pane when the editor panes go", () => {
+    const tab = openEditorTab(
+      openTerminalTab(newTab("session-a"), newTerminalFile("/repo")),
+      newFileTab("/repo/a.ts", "/repo"),
+    );
+    const next = closeSurfacePanes(closeLeaf(tab, "session-a")!, "editor");
+    expect(next).not.toBeNull();
+    expect(layoutLeaves(next!.layout).map((pane) => pane.id)).toEqual([
+      next!.terminalPanes[0]?.id,
+    ]);
+    expect(next!.editorPanes).toEqual([]);
+  });
+
+  it("returns null when only editor panes remain", () => {
+    const tab = closeLeaf(
+      openEditorTab(newTab("session-a"), newFileTab("/repo/a.ts", "/repo")),
+      "session-a",
+    )!;
+    expect(closeSurfacePanes(tab, "editor")).toBeNull();
+  });
+
+  it("leaves a tab without panes of that kind unchanged", () => {
+    const tab = newTab("session-a");
+    expect(closeSurfacePanes(tab, "editor")).toEqual(tab);
+  });
+});
+
+describe("resetTabToSession", () => {
+  it("keeps id and group, replaces contents with one session leaf", () => {
+    const tab = {
+      ...openEditorTab(newTab("session-a"), newFileTab("/repo/a.ts", "/repo")),
+      groupId: "group-1",
+      diffOpen: true,
+      diffFocused: true,
+    };
+    const next = resetTabToSession(tab, "session-b");
+    expect(next.id).toBe(tab.id);
+    expect(next.groupId).toBe("group-1");
+    expect(next.layout).toEqual(leaf("session-b"));
+    expect(next.focusedId).toBe("session-b");
+    expect(next.editorPanes).toEqual([]);
+    expect(next.terminalPanes).toEqual([]);
+    expect(next.diffOpen).toBe(false);
+    expect(next.diffFocused).toBe(false);
+  });
+});
+
 describe("openEditorTab", () => {
   it("does not open files into a terminal pane", () => {
     const terminal = openTerminalTab(
diff --git a/src/lib/layout.ts b/src/lib/layout.ts
index 2608971d..8d56f256 100644
--- a/src/lib/layout.ts
+++ b/src/lib/layout.ts
@@ -104,6 +104,22 @@ export function newTab(sessionId: string): WorkspaceTab {
   };
 }
 
+/** Keep the tab's identity and group; replace its contents with one session leaf. */
+export function resetTabToSession(
+  tab: WorkspaceTab,
+  sessionId: string,
+): WorkspaceTab {
+  return {
+    ...tab,
+    layout: leaf(sessionId),
+    focusedId: sessionId,
+    editorPanes: [],
+    terminalPanes: [],
+    diffOpen: false,
+    diffFocused: false,
+  };
+}
+
 export function newFileTab(
   path: string,
   cwd: string,
@@ -736,6 +752,18 @@ export function closeLeaf(
   return { ...tab, layout: nextLayout, focusedId: nextFocus };
 }
 
+/** Close every pane of one surface kind. Returns null only when nothing remains. */
+export function closeSurfacePanes(
+  tab: WorkspaceTab,
+  kind: SurfaceKind,
+): WorkspaceTab | null {
+  const remaining = surfacePanes(tab, kind).reduce<WorkspaceTab | null>(
+    (acc, pane) => acc && closeLeaf(acc, pane.id),
+    tab,
+  );
+  return remaining && withSurfacePanes(remaining, kind, []);
+}
+
 /** Move the sash between `index` and `index + 1` to `boundary` (0–1 of the group). */
 export function setSplitRatio(
   node: LayoutNode,
diff --git a/src/lib/settings.ts b/src/lib/settings.ts
index 83e3600e..901b100b 100644
--- a/src/lib/settings.ts
+++ b/src/lib/settings.ts
@@ -392,6 +392,7 @@ export const KEYBINDINGS: KeybindingRow[] = [
   { command: "View: Reset Zoom", keys: `${MOD}0`, when: "Always" },
   { command: "Tab: New", keys: `${MOD}T`, when: "Always" },
   { command: "Tab: Close Others", keys: `${MOD}${ALT}T`, when: "Always" },
+  { command: "Tab: Close All", keys: `${MOD}${SHIFT}W`, when: "Always" },
   { command: "Tab: Next", keys: `${MOD}${SHIFT}]`, when: "Always" },
   { command: "Tab: Previous", keys: `${MOD}${SHIFT}[`, when: "Always" },
   { command: "Tab: Cycle Next", keys: `${CTRL}Tab`, when: "Always" },
diff --git a/src/lib/tabKeys.test.ts b/src/lib/tabKeys.test.ts
index 55b575e9..28aa5e4c 100644
--- a/src/lib/tabKeys.test.ts
+++ b/src/lib/tabKeys.test.ts
@@ -74,6 +74,16 @@ describe("tabCommand", () => {
     ).toBe("new-terminal-tab");
   });
 
+  it("closes all tabs with Cmd+Shift+W or Ctrl+Shift+W", () => {
+    expect(
+      tabCommand(key({ key: "W", metaKey: true, shiftKey: true })),
+    ).toBe("close-all");
+    expect(
+      tabCommand(key({ key: "w", ctrlKey: true, shiftKey: true })),
+    ).toBe("close-all");
+    expect(tabCommand(key({ key: "w", metaKey: true }))).toBe("close");
+  });
+
   it("keeps existing tab chrome bindings", () => {
     expect(tabCommand(key({ key: "t", metaKey: true }))).toBe("new");
     expect(
diff --git a/src/lib/tabKeys.ts b/src/lib/tabKeys.ts
index b8bd6b53..783dc988 100644
--- a/src/lib/tabKeys.ts
+++ b/src/lib/tabKeys.ts
@@ -3,6 +3,7 @@
  *   New tab             cmd-t
  *   Close other tabs    cmd-opt-t
  *   Close tab           cmd-w
+ *   Close all tabs      shift-cmd-w
  *   Split pane right    cmd-d
  *   Split pane down     shift-cmd-d
  *   Next tab            shift-cmd-}
@@ -33,6 +34,7 @@ import type { FocusDir } from "./layout";
 export type TabCommand =
   | "new"
   | "close-others"
+  | "close-all"
   | "close"
   | "next"
   | "prev"
@@ -86,6 +88,7 @@ export function tabCommand(e: KeyboardEvent): TabCommand | null {
     if (e.key === "ArrowLeft") return "prev-project";
     if (e.key === "ArrowRight") return "next-project";
     if (key === "d") return "split-down";
+    if (key === "w") return "close-all";
     return null;
   }
 

From 89d9f28a98ad83c795490e577def0f5de69a3928 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 08:33:04 +0100
Subject: [PATCH 14/17] Add dark-mode lightness control

- Persist and apply configurable dark theme brightness
- Add Appearance settings slider and coverage for clamping/defaults
---
 index.html                    | 10 ++++++++-
 src/index.css                 |  3 ++-
 src/lib/appearance.test.ts    | 23 +++++++++++++++++++++
 src/lib/appearance.ts         | 36 ++++++++++++++++++++++++++++++++
 src/surfaces/SettingsView.tsx | 39 ++++++++++++++++++++++++++++++++++-
 5 files changed, 108 insertions(+), 3 deletions(-)

diff --git a/index.html b/index.html
index 28eb0578..9771ec7e 100644
--- a/index.html
+++ b/index.html
@@ -11,6 +11,9 @@
           var root = document.documentElement;
           var hue = localStorage.getItem("monocode.themeHue");
           var sat = localStorage.getItem("monocode.themeSaturation");
+          var darkLightness = localStorage.getItem(
+            "monocode.themeDarkLightness",
+          );
           var opacity = localStorage.getItem("monocode.sidebarOpacity");
           if (hue != null) {
             var h = Math.max(0, Math.min(360, Number(hue) || 0));
@@ -20,6 +23,10 @@
             var s = Math.max(0, Math.min(100, Number(sat) || 0));
             root.style.setProperty("--theme-saturation", s + "%");
           }
+          if (darkLightness != null) {
+            var l = Math.max(0, Math.min(30, Number(darkLightness) || 0));
+            root.style.setProperty("--theme-dark-lightness", l + "%");
+          }
           if (opacity != null) {
             var o = Math.max(0.15, Math.min(1, Number(opacity) || 0.85));
             root.style.setProperty("--sidebar-opacity", String(o));
@@ -50,8 +57,9 @@
       :root {
         --theme-hue: 240;
         --theme-saturation: 0%;
+        --theme-dark-lightness: 9%;
         --sidebar-opacity: 0.85;
-        --background-lightness: 9%;
+        --background-lightness: var(--theme-dark-lightness);
         --color-background-base: hsl(
           var(--theme-hue) var(--theme-saturation) var(--background-lightness)
         );
diff --git a/src/index.css b/src/index.css
index a41a96de..f73604d0 100644
--- a/src/index.css
+++ b/src/index.css
@@ -31,10 +31,11 @@
   --motion-ease-out: cubic-bezier(0.22, 1, 0.36, 1);
   --theme-hue: 240;
   --theme-saturation: 0%;
+  --theme-dark-lightness: 9%;
   --sidebar-opacity: 0.85;
   --chat-background-empty-opacity: 0.24;
   --chat-background-session-opacity: 0.24;
-  --background-lightness: 9%;
+  --background-lightness: var(--theme-dark-lightness);
   --content-lightness: 92%;
   --link-color: #7dd3fc;
   --color-skill: #e8c547;
diff --git a/src/lib/appearance.test.ts b/src/lib/appearance.test.ts
index dfca0c23..c286ce76 100644
--- a/src/lib/appearance.test.ts
+++ b/src/lib/appearance.test.ts
@@ -15,9 +15,12 @@ import {
   saveTranscriptAnchor,
   TRANSCRIPT_ANCHOR_DEFAULT,
   loadThemePreference,
+  loadThemeDarkLightness,
+  saveThemeDarkLightness,
   saveThemePreference,
   resolveColorScheme,
   THEME_PREFERENCE_DEFAULT,
+  THEME_DARK_LIGHTNESS_DEFAULT,
 } from "./appearance";
 
 const KEY = "monocode.transcriptLayout";
@@ -26,6 +29,7 @@ const ANCHOR_KEY = "monocode.transcriptAnchor";
 const CHAT_BACKGROUND_PATH_KEY = "monocode.chatBackgroundPath";
 const CHAT_BACKGROUND_OPACITY_KEY = "monocode.chatBackgroundOpacity";
 const CHAT_BACKGROUND_SCOPE_KEY = "monocode.chatBackgroundScope";
+const THEME_DARK_LIGHTNESS_KEY = "monocode.themeDarkLightness";
 
 function mockLocalStorage() {
   const data = new Map<string, string>();
@@ -186,3 +190,22 @@ describe("theme preference setting", () => {
     expect(resolveColorScheme("system")).toBe("dark");
   });
 });
+
+describe("dark theme lightness setting", () => {
+  beforeEach(mockLocalStorage);
+  afterEach(() => {
+    localStorage.removeItem(THEME_DARK_LIGHTNESS_KEY);
+  });
+
+  it("defaults to the existing dark background lightness", () => {
+    expect(THEME_DARK_LIGHTNESS_DEFAULT).toBe(9);
+    expect(loadThemeDarkLightness()).toBe(9);
+  });
+
+  it("persists true black and clamps overly light values", () => {
+    saveThemeDarkLightness(0);
+    expect(loadThemeDarkLightness()).toBe(0);
+    saveThemeDarkLightness(100);
+    expect(loadThemeDarkLightness()).toBe(30);
+  });
+});
diff --git a/src/lib/appearance.ts b/src/lib/appearance.ts
index be316c6a..a3a69e7b 100644
--- a/src/lib/appearance.ts
+++ b/src/lib/appearance.ts
@@ -4,6 +4,7 @@ import { applyUiScale, loadUiScale } from "./uiScale";
 
 const THEME_HUE_KEY = "monocode.themeHue";
 const THEME_SATURATION_KEY = "monocode.themeSaturation";
+const THEME_DARK_LIGHTNESS_KEY = "monocode.themeDarkLightness";
 const OPACITY_KEY = "monocode.sidebarOpacity";
 const BLUR_KEY = "monocode.sidebarBlur";
 const PROJECT_RAIL_OPEN_KEY = "monocode.projectRailOpen";
@@ -66,6 +67,10 @@ export const THEME_SATURATION_MIN = 0;
 export const THEME_SATURATION_MAX = 100;
 export const THEME_SATURATION_DEFAULT = 0;
 
+export const THEME_DARK_LIGHTNESS_MIN = 0;
+export const THEME_DARK_LIGHTNESS_MAX = 30;
+export const THEME_DARK_LIGHTNESS_DEFAULT = 9;
+
 export const SIDEBAR_OPACITY_MIN = 0.15;
 export const SIDEBAR_OPACITY_MAX = 1;
 export const SIDEBAR_OPACITY_DEFAULT = 0.85;
@@ -164,6 +169,36 @@ export function saveThemeSaturation(value: number) {
   );
 }
 
+export function loadThemeDarkLightness(): number {
+  return Math.round(
+    clamp(
+      readNumber(THEME_DARK_LIGHTNESS_KEY) ?? THEME_DARK_LIGHTNESS_DEFAULT,
+      THEME_DARK_LIGHTNESS_MIN,
+      THEME_DARK_LIGHTNESS_MAX,
+    ),
+  );
+}
+
+export function saveThemeDarkLightness(value: number) {
+  writeNumber(
+    THEME_DARK_LIGHTNESS_KEY,
+    Math.round(
+      clamp(value, THEME_DARK_LIGHTNESS_MIN, THEME_DARK_LIGHTNESS_MAX),
+    ),
+  );
+}
+
+export function applyThemeDarkLightness(value: number) {
+  const next = Math.round(
+    clamp(value, THEME_DARK_LIGHTNESS_MIN, THEME_DARK_LIGHTNESS_MAX),
+  );
+  document.documentElement.style.setProperty(
+    "--theme-dark-lightness",
+    `${next}%`,
+  );
+  return next;
+}
+
 export function applyThemeTint(hue: number, saturation: number) {
   const nextHue = Math.round(clamp(hue, THEME_HUE_MIN, THEME_HUE_MAX));
   const nextSaturation = Math.round(
@@ -184,6 +219,7 @@ export function initAppearance() {
     HAS_NATIVE_GLASS,
   );
   applyThemeTint(loadThemeHue(), loadThemeSaturation());
+  applyThemeDarkLightness(loadThemeDarkLightness());
   applyThemePreference(loadThemePreference());
   watchSystemColorScheme();
   applySidebarOpacity(loadSidebarOpacity());
diff --git a/src/surfaces/SettingsView.tsx b/src/surfaces/SettingsView.tsx
index 05b44846..b1767c1c 100644
--- a/src/surfaces/SettingsView.tsx
+++ b/src/surfaces/SettingsView.tsx
@@ -33,9 +33,10 @@ import {
   applyChatBackgroundSessionOpacity,
   applyChatBackgroundScope,
   applyBodyGlass,
-  applyThemePreference,
   applySidebarBlur,
   applySidebarOpacity,
+  applyThemeDarkLightness,
+  applyThemePreference,
   applyThemeTint,
   BODY_GLASS_DEFAULT,
   CHAT_BACKGROUND_EMPTY_OPACITY_DEFAULT,
@@ -50,6 +51,7 @@ import {
   loadChatBackgroundPath,
   loadChatBackgroundSessionOpacity,
   loadChatBackgroundScope,
+  loadThemeDarkLightness,
   loadThemePreference,
   loadSidebarBlur,
   loadSidebarOpacity,
@@ -62,6 +64,7 @@ import {
   saveChatBackgroundPath,
   saveChatBackgroundSessionOpacity,
   saveChatBackgroundScope,
+  saveThemeDarkLightness,
   saveThemePreference,
   saveSidebarBlur,
   saveSidebarOpacity,
@@ -76,6 +79,9 @@ import {
   SIDEBAR_OPACITY_DEFAULT,
   SIDEBAR_OPACITY_MAX,
   SIDEBAR_OPACITY_MIN,
+  THEME_DARK_LIGHTNESS_DEFAULT,
+  THEME_DARK_LIGHTNESS_MAX,
+  THEME_DARK_LIGHTNESS_MIN,
   THEME_HUE_DEFAULT,
   THEME_HUE_MAX,
   THEME_HUE_MIN,
@@ -1073,6 +1079,9 @@ function useAppearanceSettings() {
   const [blur, setBlur] = useState(loadSidebarBlur);
   const [themeHue, setThemeHue] = useState(loadThemeHue);
   const [themeSaturation, setThemeSaturation] = useState(loadThemeSaturation);
+  const [themeDarkLightness, setThemeDarkLightness] = useState(
+    loadThemeDarkLightness,
+  );
   const [bodyGlass, setBodyGlass] = useState(loadBodyGlass);
   const [chatBackgroundPath, setChatBackgroundPath] = useState(
     loadChatBackgroundPath,
@@ -1118,6 +1127,12 @@ function useAppearanceSettings() {
     setThemeSaturation(next.saturation);
   }, []);
 
+  const onDarkLightness = useCallback((value: number) => {
+    const next = applyThemeDarkLightness(value);
+    saveThemeDarkLightness(next);
+    setThemeDarkLightness(next);
+  }, []);
+
   const onBodyGlass = useCallback((next: boolean) => {
     applyBodyGlass(next);
     saveBodyGlass(next);
@@ -1188,6 +1203,7 @@ function useAppearanceSettings() {
     onOpacity(Math.round(SIDEBAR_OPACITY_DEFAULT * 100));
     onBlur(SIDEBAR_BLUR_DEFAULT);
     onTint(THEME_HUE_DEFAULT, THEME_SATURATION_DEFAULT);
+    onDarkLightness(THEME_DARK_LIGHTNESS_DEFAULT);
     onBodyGlass(BODY_GLASS_DEFAULT);
     onChatBackgroundEmptyOpacity(
       Math.round(CHAT_BACKGROUND_EMPTY_OPACITY_DEFAULT * 100),
@@ -1209,6 +1225,7 @@ function useAppearanceSettings() {
     onThemePreference,
     onOpacity,
     onTint,
+    onDarkLightness,
     onUiScale,
   ]);
 
@@ -1218,6 +1235,7 @@ function useAppearanceSettings() {
     blur,
     themeHue,
     themeSaturation,
+    themeDarkLightness,
     bodyGlass,
     chatBackgroundPath,
     chatBackgroundEmptyOpacity,
@@ -1230,6 +1248,7 @@ function useAppearanceSettings() {
     onOpacity,
     onBlur,
     onTint,
+    onDarkLightness,
     onBodyGlass,
     onChooseChatBackground,
     onClearChatBackground,
@@ -1323,6 +1342,24 @@ function AppearancePage({ appearance }: { appearance: AppearanceSettings }) {
           onChange={(value) => appearance.onTint(appearance.themeHue, value)}
         />
       </Row>
+      <Row
+        label="Dark-mode lightness"
+        description={
+          glassDisabled
+            ? "This only affects dark mode. Your dark-mode value is preserved."
+            : "Base brightness of the dark theme. Lower values are darker; zero is true black."
+        }
+      >
+        <Slider
+          label="Dark-mode lightness"
+          value={appearance.themeDarkLightness}
+          display={`${appearance.themeDarkLightness}%`}
+          min={THEME_DARK_LIGHTNESS_MIN}
+          max={THEME_DARK_LIGHTNESS_MAX}
+          onChange={appearance.onDarkLightness}
+          disabled={glassDisabled}
+        />
+      </Row>
       <Row
         label="Main pane glass"
         description={

From ed89e347af207b3639f1ed086f83f14201ed11b3 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 12:04:54 +0100
Subject: [PATCH 15/17] feat: add local agent orchestration v1 (#228)

* Add local agent orchestration workflow

- Add orchestrator UI, planning, delegation, and worker tracking
- Add authenticated local control CLI and loopback transport
- Persist orchestration history and group worker sessions in the sidebar

* Remove orchestration agents panel

- Delete the obsolete orchestration panel UI and related interactions

* Expand local agent orchestration and control flow

- Add robust CLI supervision, retries, approvals, and worker messaging
- Improve orchestration UI, session handling, and transcript behavior
- Extend orchestration protocol and coverage with comprehensive tests

* Add steer action to redirect agents mid-turn

- Adds steer CLI action to redirect running agents without losing work
- Validates agent is running before allowing steering
- Updates sidebar to consistently show lead agent model name

* Improve orchestration preview controls and model picker

- Add keyboard navigation and focus handling to model selection
- Improve task fields, worker controls, help tooltip, and transcript spacing
- Update orchestration flow tests

* Export scroll-lock helpers for testability

- Extract atScrollEdge, hasScrollRoom, and related helpers as exported functions
- Rewrite tests with happy-dom to directly test scroll logic
- Remove proposal.summary display from orchestration preview

* Add agent tabs for orchestration worker inspection

- Open orchestration workers as tabs beside their lead session
- Agent tabs are live-only, not persisted across restarts
- Show worker transcripts with orchestrator turns visible
- Drop agent tabs and agent-only panes from workspace snapshots
- New 'See details' button on agent rows to open the tab

* Simplify orchestration worker cards and add harness to agent tabs

- Drop sessions from OrchestrationWorkers; cards use summary tasks only
- Expand on needsInput and show harness icon plus model, not transcript ticker
- Pass harness when opening worker tabs; show HarnessIcon in the tab bar

* Open orchestration workers as editor tabs from View agents

- Route View agents through openAgents to open every worker beside the lead
- Hide monocode_assignment envelopes in managed worker transcripts
- Subscribe FilePane to agent tab sessions and move worker metadata to a footer

* Refine orchestrator UI styling and descriptions

- Use the Share icon and fuchsia styling for orchestrator controls
- Shorten and truncate composer option descriptions

* Add v1 badge to orchestrator composer option

* Fix orchestration sidebar expansion test expectations

* Fix orchestrator review findings and session cleanup
---
 Cargo.lock                                |    1 +
 src-tauri/Cargo.toml                      |    1 +
 src-tauri/src/control.rs                  |  552 +++++++
 src-tauri/src/control_cli.rs              |  373 +++++
 src-tauri/src/harness.rs                  |    2 +
 src-tauri/src/lib.rs                      |   13 +
 src-tauri/src/main.rs                     |    5 +
 src-tauri/src/session_store.rs            |  472 +++++-
 src/App.tsx                               | 1596 +++++++++++++++------
 src/chrome/Composer.tsx                   |   75 +-
 src/chrome/OrchestrationActions.ts        |   38 +
 src/chrome/OrchestrationFlow.test.ts      |  747 ++++++++++
 src/chrome/OrchestrationPreview.tsx       |  610 ++++++++
 src/chrome/OrchestrationSidebarAgents.tsx |  253 ++++
 src/chrome/Sidebar.tsx                    |  123 +-
 src/chrome/SidebarRename.test.ts          |  163 ++-
 src/chrome/SurfaceTabs.tsx                |   18 +
 src/chrome/icons.tsx                      |    4 +
 src/hooks/useLockOverscroll.test.ts       |  223 ++-
 src/hooks/useLockOverscroll.ts            |  104 +-
 src/lib/agentTabs.test.ts                 |   82 ++
 src/lib/approvalToast.test.ts             |   41 +-
 src/lib/approvalToast.ts                  |    2 +
 src/lib/harness/apply.ts                  |   12 +
 src/lib/harness/codex.ts                  |    3 +
 src/lib/harness/codexProtocol.test.ts     |   54 +
 src/lib/harness/codexProtocol.ts          |   58 +-
 src/lib/harness/registry.ts               |    9 +
 src/lib/harness/types.ts                  |    6 +
 src/lib/layout.ts                         |   33 +-
 src/lib/liveAgents.test.ts                |    5 +
 src/lib/liveAgents.ts                     |    2 +-
 src/lib/orchestration.test.ts             |  792 ++++++++++
 src/lib/orchestration.ts                  | 1391 ++++++++++++++++++
 src/lib/orchestrationCatalog.test.ts      |   68 +
 src/lib/orchestrationCatalog.ts           |   27 +
 src/lib/orchestrationPlan.test.ts         |  137 ++
 src/lib/orchestrationPlan.ts              |  267 ++++
 src/lib/orchestrationSummary.ts           |   57 +
 src/lib/orchestrationWorkspace.test.ts    |  139 ++
 src/lib/orchestrationWorkspace.ts         |  109 ++
 src/lib/promptOutline.ts                  |    2 +-
 src/lib/session.ts                        |   15 +-
 src/lib/sessionHistory.test.ts            |  124 +-
 src/lib/sessionHistory.ts                 |   46 +-
 src/lib/sessionStore.test.ts              |   29 +
 src/lib/sessionStore.ts                   |   47 +-
 src/lib/sessionStoreConcurrency.test.ts   |   31 +
 src/lib/workspaceSnapshot.test.ts         |   42 +
 src/lib/workspaceSnapshot.ts              |   33 +-
 src/surfaces/AgentTabView.tsx             |   61 +
 src/surfaces/AgentTranscript.test.ts      |   74 +
 src/surfaces/AgentTranscript.tsx          |   55 +-
 src/surfaces/FilePane.agent.test.ts       |   95 ++
 src/surfaces/FilePane.tsx                 |   16 +-
 src/surfaces/PaneTree.tsx                 |    4 +-
 src/surfaces/SessionPane.tsx              |  256 ++--
 src/surfaces/transcriptActivity.test.ts   |   20 +
 src/surfaces/transcriptActivity.ts        |   13 +-
 59 files changed, 8883 insertions(+), 747 deletions(-)
 create mode 100644 src-tauri/src/control.rs
 create mode 100644 src-tauri/src/control_cli.rs
 create mode 100644 src/chrome/OrchestrationActions.ts
 create mode 100644 src/chrome/OrchestrationFlow.test.ts
 create mode 100644 src/chrome/OrchestrationPreview.tsx
 create mode 100644 src/chrome/OrchestrationSidebarAgents.tsx
 create mode 100644 src/lib/agentTabs.test.ts
 create mode 100644 src/lib/orchestration.test.ts
 create mode 100644 src/lib/orchestration.ts
 create mode 100644 src/lib/orchestrationCatalog.test.ts
 create mode 100644 src/lib/orchestrationCatalog.ts
 create mode 100644 src/lib/orchestrationPlan.test.ts
 create mode 100644 src/lib/orchestrationPlan.ts
 create mode 100644 src/lib/orchestrationSummary.ts
 create mode 100644 src/lib/orchestrationWorkspace.test.ts
 create mode 100644 src/lib/orchestrationWorkspace.ts
 create mode 100644 src/surfaces/AgentTabView.tsx
 create mode 100644 src/surfaces/FilePane.agent.test.ts

diff --git a/Cargo.lock b/Cargo.lock
index ff03f048..d6f08232 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2238,6 +2238,7 @@ dependencies = [
  "tauri-plugin-window-state",
  "ureq",
  "url",
+ "uuid",
  "windows-sys 0.61.2",
 ]
 
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 24f74f07..4e06d4cc 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -20,6 +20,7 @@ tauri = { version = "2", features = ["protocol-asset", "macos-private-api"] }
 tauri-plugin-opener = "2"
 serde.workspace = true
 serde_json.workspace = true
+uuid = { version = "1", features = ["v4"] }
 base64 = "0.22"
 tauri-plugin-dialog = "2"
 rusqlite = { version = "0.40.2", features = ["bundled"], default-features = false }
diff --git a/src-tauri/src/control.rs b/src-tauri/src/control.rs
new file mode 100644
index 00000000..20542e53
--- /dev/null
+++ b/src-tauri/src/control.rs
@@ -0,0 +1,552 @@
+//! Authenticated loopback transport. App windows own execution; callers never
+//! receive arbitrary Tauri command access or direct database write access.
+use std::collections::HashMap;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{TcpListener, TcpStream};
+use std::path::{Component, Path};
+use std::process::Command;
+use std::sync::{mpsc, Arc, Mutex};
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use tauri::{AppHandle, Emitter, Manager, State, WebviewWindow};
+
+#[derive(Clone)]
+struct Grant {
+    window: String,
+    session: String,
+    cwd: String,
+    token: String,
+}
+struct Pending {
+    window: String,
+    reply: mpsc::Sender<Value>,
+}
+struct ActiveTurn {
+    window: String,
+    cwd: String,
+}
+#[derive(Default)]
+struct Inner {
+    grants: HashMap<String, Grant>,
+    pending: HashMap<String, Pending>,
+    workers: HashMap<String, String>,
+    active: HashMap<String, ActiveTurn>,
+}
+impl Inner {
+    fn window_sessions(&self, label: &str) -> Vec<String> {
+        let leads: Vec<String> = self
+            .grants
+            .values()
+            .filter(|grant| grant.window == label)
+            .map(|grant| grant.session.clone())
+            .collect();
+        let mut ids = leads.clone();
+        ids.extend(
+            self.workers
+                .iter()
+                .filter(|(_, lead)| leads.contains(lead))
+                .map(|(id, _)| id.clone()),
+        );
+        ids.extend(
+            self.active
+                .iter()
+                .filter(|(_, turn)| turn.window == label)
+                .map(|(id, _)| id.clone()),
+        );
+        ids.sort();
+        ids.dedup();
+        ids
+    }
+    fn close_window(&mut self, label: &str) -> Vec<String> {
+        let ids = self.window_sessions(label);
+        self.grants.retain(|id, _| !ids.contains(id));
+        self.workers.retain(|id, _| !ids.contains(id));
+        self.active.retain(|id, _| !ids.contains(id));
+        self.pending.retain(|_, pending| {
+            if pending.window != label {
+                return true;
+            }
+            let _ = pending
+                .reply
+                .send(json!({"ok":false,"error":"MonoCode window closed"}));
+            false
+        });
+        ids
+    }
+}
+pub struct ControlHost {
+    endpoint: String,
+    inner: Arc<Mutex<Inner>>,
+}
+
+fn paths_overlap(a: &str, b: &str) -> bool {
+    a == b || a.starts_with(&format!("{b}/")) || b.starts_with(&format!("{a}/"))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Request {
+    token: String,
+    action: String,
+    input: Value,
+    request_id: String,
+}
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct Event {
+    id: String,
+    session_id: String,
+    request_id: String,
+    action: String,
+    input: Value,
+}
+
+pub fn init(app: &AppHandle) -> Result<(), String> {
+    let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
+    let endpoint = listener
+        .local_addr()
+        .map_err(|e| e.to_string())?
+        .to_string();
+    let inner = Arc::new(Mutex::new(Inner::default()));
+    app.manage(ControlHost {
+        endpoint,
+        inner: inner.clone(),
+    });
+    let app = app.clone();
+    std::thread::spawn(move || {
+        // Limit concurrent readers, including unauthenticated sockets.
+        let (tx, rx) = mpsc::sync_channel::<TcpStream>(32);
+        let rx = Arc::new(Mutex::new(rx));
+        for _ in 0..8 {
+            let rx = rx.clone();
+            let app = app.clone();
+            let inner = inner.clone();
+            std::thread::spawn(move || loop {
+                let stream = match rx.lock() {
+                    Ok(rx) => rx.recv(),
+                    Err(_) => return,
+                };
+                let Ok(stream) = stream else { return };
+                serve(stream, &app, &inner);
+            });
+        }
+        for stream in listener.incoming().flatten() {
+            let _ = tx.try_send(stream);
+        }
+    });
+    Ok(())
+}
+
+fn serve(mut stream: TcpStream, app: &AppHandle, inner: &Arc<Mutex<Inner>>) {
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(3)));
+    let _ = stream.set_write_timeout(Some(Duration::from_secs(3)));
+    let result = (|| -> Result<Value, String> {
+        let mut raw = String::new();
+        BufReader::new(&mut stream)
+            .take(262_145)
+            .read_line(&mut raw)
+            .map_err(|e| e.to_string())?;
+        if raw.len() > 262_144 {
+            return Err("Request exceeds 256 KiB".into());
+        }
+        let request: Request = serde_json::from_str(&raw).map_err(|_| "Invalid control request")?;
+        if !request.input.is_object()
+            || request.request_id.is_empty()
+            || request.request_id.len() > 128
+        {
+            return Err("Invalid input or request ID".into());
+        }
+        let id = uuid::Uuid::new_v4().to_string();
+        let (tx, rx) = mpsc::channel();
+        let grant = {
+            let mut host = inner.lock().map_err(|_| "Control service unavailable")?;
+            let grant = host
+                .grants
+                .values()
+                .find(|g| g.token == request.token)
+                .cloned()
+                .ok_or("Connection revoked or unauthorized")?;
+            if host.pending.len() >= 24 {
+                return Err("Too many pending control requests".into());
+            }
+            host.pending.insert(
+                id.clone(),
+                Pending {
+                    window: grant.window.clone(),
+                    reply: tx,
+                },
+            );
+            grant
+        };
+        let event = Event {
+            id: id.clone(),
+            session_id: grant.session,
+            request_id: request.request_id,
+            action: request.action,
+            input: request.input,
+        };
+        let delivered = app.emit_to(grant.window.as_str(), "monocode-control-request", event);
+        let result = if delivered.is_err() {
+            Err("MonoCode executor is unavailable".into())
+        } else {
+            rx.recv_timeout(Duration::from_secs(35))
+                .map_err(|_| "Control request timed out. Retry with the same request ID.".into())
+        };
+        if let Ok(mut host) = inner.lock() {
+            host.pending.remove(&id);
+        }
+        result
+    })();
+    let response = result.unwrap_or_else(|error| json!({"ok": false, "error": error}));
+    let _ = writeln!(stream, "{response}");
+}
+
+#[tauri::command]
+pub fn control_enable(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+    cwd: String,
+) -> Result<String, String> {
+    let cwd = std::fs::canonicalize(crate::fs::expand_home(&cwd)).map_err(|e| e.to_string())?;
+    if !cwd.is_dir() {
+        return Err("Choose a project folder first".into());
+    }
+    let cwd = cwd.to_string_lossy().replace('\\', "/").to_lowercase();
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .active
+        .iter()
+        .any(|(id, turn)| id != &session_id && paths_overlap(&turn.cwd, &cwd))
+    {
+        return Err(
+            "Another session is running in this checkout. Stop it before enabling orchestration."
+                .into(),
+        );
+    }
+    if inner.grants.values().any(|g| {
+        paths_overlap(&g.cwd, &cwd) && (g.session != session_id || g.window != window.label())
+    }) {
+        return Err("This checkout already has an orchestrator in another session".into());
+    }
+    inner.grants.insert(
+        session_id.clone(),
+        Grant {
+            window: window.label().into(),
+            session: session_id,
+            cwd,
+            token: format!(
+                "{}{}",
+                uuid::Uuid::new_v4().simple(),
+                uuid::Uuid::new_v4().simple()
+            ),
+        },
+    );
+    let executable = std::env::current_exe().map_err(|e| e.to_string())?;
+    Ok(executable.to_string_lossy().into_owned())
+}
+
+#[tauri::command]
+pub fn control_disable(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .grants
+        .get(&session_id)
+        .is_some_and(|g| g.window == window.label())
+    {
+        inner.grants.remove(&session_id);
+        inner.workers.retain(|_, parent| parent != &session_id);
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_attach_worker(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    lead_id: String,
+    session_id: String,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if !inner
+        .grants
+        .get(&lead_id)
+        .is_some_and(|grant| grant.window == window.label())
+    {
+        return Err("Lead connection is inactive".into());
+    }
+    inner.workers.insert(session_id, lead_id);
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_authorize_turn(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+    cwd: String,
+) -> Result<(), String> {
+    let cwd = std::fs::canonicalize(crate::fs::expand_home(&cwd))
+        .map_err(|e| e.to_string())?
+        .to_string_lossy()
+        .replace('\\', "/")
+        .to_lowercase();
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if let Some(lead) = inner
+        .grants
+        .values()
+        .find(|grant| paths_overlap(&grant.cwd, &cwd))
+    {
+        if lead.window != window.label()
+            || (lead.session != session_id && inner.workers.get(&session_id) != Some(&lead.session))
+        {
+            return Err("This checkout is controlled by an orchestrator. Stop that run before starting independent work.".into());
+        }
+    }
+    inner.active.insert(
+        session_id,
+        ActiveTurn {
+            window: window.label().to_string(),
+            cwd,
+        },
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_turn_finished(host: State<'_, ControlHost>, session_id: String) {
+    if let Ok(mut inner) = host.inner.lock() {
+        inner.active.remove(&session_id);
+    }
+}
+
+pub fn window_closed(app: &AppHandle, label: &str) {
+    let host = app.state::<ControlHost>();
+    let ids = {
+        let Ok(inner) = host.inner.lock() else { return };
+        inner.window_sessions(label)
+    };
+    for id in &ids {
+        let _ = crate::harness::harness_kill(app.state(), id.clone());
+    }
+    if let Ok(mut inner) = host.inner.lock() {
+        inner.close_window(label);
+    };
+}
+
+pub fn configure_child(app: &AppHandle, session_id: &str, cmd: &mut Command) {
+    cmd.env_remove("MONOCODE_CONTROL_ENDPOINT")
+        .env_remove("MONOCODE_CONTROL_TOKEN");
+    let Some(host) = app.try_state::<ControlHost>() else {
+        return;
+    };
+    if let Ok(inner) = host.inner.lock() {
+        if let Some(grant) = inner.grants.get(session_id) {
+            cmd.env("MONOCODE_CONTROL_ENDPOINT", &host.endpoint)
+                .env("MONOCODE_CONTROL_TOKEN", &grant.token);
+        }
+    };
+}
+
+#[tauri::command]
+pub fn control_reply(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    id: String,
+    response: Value,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .pending
+        .get(&id)
+        .is_some_and(|p| p.window == window.label())
+    {
+        if let Some(pending) = inner.pending.remove(&id) {
+            let _ = pending.reply.send(response);
+        }
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_save(
+    store: State<'_, crate::session_store::SessionStore>,
+    lead_id: String,
+    state: String,
+) -> Result<(), String> {
+    if state.len() > 8_000_000 {
+        return Err("Orchestration history is too large".into());
+    }
+    let run: Value = serde_json::from_str(&state).map_err(|_| "Invalid run state")?;
+    let conn = store.lock_conn()?;
+    crate::session_store::save_orchestration(&conn, &lead_id, &run).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_load(
+    store: State<'_, crate::session_store::SessionStore>,
+    lead_id: String,
+) -> Result<Option<String>, String> {
+    use rusqlite::OptionalExtension;
+    store
+        .lock_conn()?
+        .query_row(
+            "SELECT state FROM orchestration_runs WHERE lead_id=?1",
+            [lead_id],
+            |r| r.get(0),
+        )
+        .optional()
+        .map_err(|e| e.to_string())
+}
+
+fn resolve_scope(root: &Path, value: &str) -> Result<String, String> {
+    let path = Path::new(value);
+    if value.is_empty()
+        || path.is_absolute()
+        || path
+            .components()
+            .any(|c| matches!(c, Component::ParentDir | Component::Prefix(_)))
+    {
+        return Err("Write scopes must be project-relative paths without '..'".into());
+    }
+    let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
+    let mut existing = root.join(path);
+    let mut missing = Vec::new();
+    while !existing.exists() {
+        missing.push(existing.file_name().ok_or("Invalid scope")?.to_os_string());
+        if !existing.pop() {
+            return Err("Invalid scope".into());
+        }
+    }
+    existing = std::fs::canonicalize(existing).map_err(|e| e.to_string())?;
+    if !existing.starts_with(&root) {
+        return Err("Write scope points outside the project".into());
+    }
+    for part in missing.into_iter().rev() {
+        existing.push(part);
+    }
+    Ok(existing.to_string_lossy().replace('\\', "/").to_lowercase())
+}
+
+#[tauri::command]
+pub fn control_scopes(cwd: String, files: Vec<String>) -> Result<Vec<String>, String> {
+    if files.len() > 64 {
+        return Err("At most 64 write scopes per task".into());
+    }
+    files
+        .iter()
+        .map(|file| resolve_scope(&crate::fs::expand_home(&cwd), file))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn closing_a_window_releases_ordinary_turns_and_owned_orchestration() {
+        let mut inner = Inner::default();
+        for (id, window) in [
+            ("ordinary", "closing"),
+            ("lead", "closing"),
+            ("other", "open"),
+        ] {
+            inner.active.insert(
+                id.into(),
+                ActiveTurn {
+                    window: window.into(),
+                    cwd: format!("/{id}"),
+                },
+            );
+        }
+        for (id, window) in [("lead", "closing"), ("other", "open")] {
+            inner.grants.insert(
+                id.into(),
+                Grant {
+                    window: window.into(),
+                    session: id.into(),
+                    cwd: format!("/{id}"),
+                    token: id.into(),
+                },
+            );
+        }
+        inner.workers.insert("worker".into(), "lead".into());
+        inner.workers.insert("other-worker".into(), "other".into());
+        let (reply, response) = mpsc::channel();
+        inner.pending.insert(
+            "pending".into(),
+            Pending {
+                window: "closing".into(),
+                reply,
+            },
+        );
+        let (reply, other_response) = mpsc::channel();
+        inner.pending.insert(
+            "other-pending".into(),
+            Pending {
+                window: "open".into(),
+                reply,
+            },
+        );
+
+        assert_eq!(
+            inner.close_window("closing"),
+            ["lead", "ordinary", "worker"]
+        );
+        assert_eq!(inner.active.len(), 1);
+        assert_eq!(inner.active["other"].window, "open");
+        assert_eq!(inner.grants.len(), 1);
+        assert!(inner.grants.contains_key("other"));
+        assert_eq!(inner.workers.len(), 1);
+        assert_eq!(inner.workers["other-worker"], "other");
+        assert_eq!(response.try_recv().unwrap()["ok"], false);
+        assert!(other_response.try_recv().is_err());
+        assert!(inner.pending.contains_key("other-pending"));
+        assert!(inner.close_window("closing").is_empty());
+    }
+
+    #[test]
+    fn scopes_reject_escape_and_resolve_new_files() {
+        let root = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+        std::fs::create_dir_all(&root).unwrap();
+        assert!(resolve_scope(&root, "../escape").is_err());
+        assert!(resolve_scope(&root, "/absolute").is_err());
+        assert!(resolve_scope(&root, "src/new.ts")
+            .unwrap()
+            .ends_with("/src/new.ts"));
+        #[cfg(unix)]
+        {
+            std::os::unix::fs::symlink(std::env::temp_dir(), root.join("outside")).unwrap();
+            assert!(resolve_scope(&root, "outside/file").is_err());
+        }
+        std::fs::remove_dir_all(root).unwrap();
+    }
+    #[test]
+    fn checkout_reservations_include_nested_folders() {
+        assert!(paths_overlap("/repo", "/repo/src"));
+        assert!(paths_overlap("/repo/src", "/repo"));
+        assert!(!paths_overlap("/repo", "/repo2"));
+    }
+}
diff --git a/src-tauri/src/control_cli.rs b/src-tauri/src/control_cli.rs
new file mode 100644
index 00000000..3856f5d4
--- /dev/null
+++ b/src-tauri/src/control_cli.rs
@@ -0,0 +1,373 @@
+//! The desktop executable also provides a small, JSON-only control client.
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{SocketAddr, TcpStream};
+use std::time::Duration;
+
+use serde_json::{json, Value};
+
+const USAGE: &str = r#"MonoCode local control — supervise this orchestration run from the lead agent.
+
+Usage: {exe} control ACTION [--json JSON | --input FILE|-] [--request-id ID]
+
+Actions, with the JSON object each one takes:
+  list      {}
+            The run, every task with its status and latest result, and the
+            harness/model IDs you may assign.
+  delegate  {"title":"Short title","harness":"<id from list>",
+             "model":"<id from list>","prompt":"Self-contained instructions",
+             "files":["src/feature"],"dependsOn":["<taskId>"]}
+            Queue a worker and return its taskId. "model" is optional and
+            defaults to the first model list allows for that harness.
+            "files" is the write scope: project-relative paths, where a
+            directory covers its descendants and ["."] reserves the whole
+            checkout. "dependsOn" holds taskIds that must be reviewed first.
+  get       {"taskId":"..."}
+            One task, including its latest result.
+  wait      {"timeoutSeconds":20}
+            Block until a task changes state, or until the timeout (0-25).
+            Returns at once when nothing is running or queued.
+  respond   {"taskId":"...","requestId":7,"decision":"allow"|"deny"}
+            Answer an approval an agent is blocked on. Agents never prompt the
+            user; list, get and wait report the prompt as that task's
+            "needsInput", and it stays stopped until you decide.
+  answer    {"taskId":"...","requestId":9,"answers":{"<questionId>":["<optionId>"]}}
+            Answer a question an agent asked, or pass "skip":true instead of
+            "answers". The question and its options come from needsInput.
+  steer     {"taskId":"...","text":"..."}
+            Redirect an agent that is still running, without discarding the
+            work it has already done. Use this the moment you see it going
+            the wrong way; message only lands once it has stopped.
+  message   {"taskId":"...","text":"..."}
+            Send a completed or failed worker another turn; it keeps its
+            session, scope and history.
+  cancel    {"taskId":"..."}
+            Cancel a task, whether it is running or still queued.
+  review    {"taskId":"..."}
+            Accept a completed task's result.
+  finish    {}
+            End the run, once every task is accepted or cancelled.
+
+Usual loop: list -> delegate ... -> wait or get -> steer an agent that drifts,
+unblock one with respond or answer -> inspect the changes yourself -> message
+for corrections -> review each task -> finish.
+
+Output is one JSON line: {"ok":true,"result":...} or {"ok":false,"error":"..."}.
+The exit code is 0 only when "ok" is true.
+
+Input must be a JSON object; unknown fields are rejected rather than ignored.
+--json takes it inline, --input FILE reads a file, --input - reads stdin.
+
+Every call carries a request ID, and the run applies each ID at most once. A
+failed response reports the ID it used whenever the outcome is unknown — a
+timeout, say. Retry that exact call with --request-id ID; retrying a delegate
+under a fresh ID instead would queue a second worker.
+
+Tasks run inside the MonoCode app, not in this process. Exiting this CLI, or a
+failure here, never cancels a task that was already accepted.
+
+MonoCode sets MONOCODE_CONTROL_ENDPOINT and MONOCODE_CONTROL_TOKEN for the lead
+agent's process only. They are already in your environment; never print them.
+"#;
+
+const ACTIONS: [&str; 11] = [
+    "list", "delegate", "get", "steer", "message", "cancel", "wait", "review", "finish", "respond",
+    "answer",
+];
+
+/// Quote for the shell the lead agent actually runs commands in, and only when
+/// the path needs it. The path is absolute, so a leading slash means a POSIX
+/// shell — where a backslash escapes rather than separates, and so is never
+/// safe bare.
+fn quoted(value: &str) -> String {
+    if !value.starts_with('/') {
+        return if value.contains([' ', '\t', '"']) {
+            format!("\"{}\"", value.replace('"', ""))
+        } else {
+            value.into()
+        };
+    }
+    if value
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || "._/-:".contains(c))
+    {
+        value.into()
+    } else {
+        format!("'{}'", value.replace('\'', r"'\''"))
+    }
+}
+
+pub fn help() -> String {
+    let exe = std::env::current_exe()
+        .map(|path| quoted(&path.to_string_lossy()))
+        .unwrap_or_else(|_| "monocode".into());
+    USAGE.replace("{exe}", &exe)
+}
+
+enum Parsed {
+    Help,
+    Call(String, Value, String),
+}
+
+pub fn run(args: Vec<String>) -> i32 {
+    let parsed = match parse_args(&args) {
+        Ok(parsed) => parsed,
+        Err(error) => {
+            println!("{}", json!({"ok": false, "error": error}));
+            return 1;
+        }
+    };
+    let (action, input, request_id) = match parsed {
+        Parsed::Help => {
+            println!("{}", help());
+            return 0;
+        }
+        Parsed::Call(action, input, request_id) => (action, input, request_id),
+    };
+    match send(&action, &input, &request_id) {
+        Ok(mut value) => {
+            if value.get("ok").and_then(Value::as_bool) == Some(true) {
+                println!("{value}");
+                return 0;
+            }
+            // MonoCode may have timed out waiting on its own executor, so a
+            // failure here is not proof the call was rejected either.
+            if let Some(object) = value.as_object_mut() {
+                object
+                    .entry("requestId")
+                    .or_insert_with(|| json!(request_id));
+                object
+                    .entry("retryWith")
+                    .or_insert_with(|| json!(format!("--request-id {request_id}")));
+            }
+            println!("{value}");
+            1
+        }
+        Err(Failure { error, sent }) => {
+            // The call may have reached the run even though its answer was
+            // lost. Hand back the request ID so a retry cannot duplicate it.
+            let mut response = json!({"ok": false, "error": error});
+            if sent {
+                response["requestId"] = json!(request_id);
+                response["retryWith"] = json!(format!("--request-id {request_id}"));
+            }
+            println!("{response}");
+            1
+        }
+    }
+}
+
+struct Failure {
+    error: String,
+    /// The request was already on the wire, so the run may have applied it.
+    sent: bool,
+}
+fn unsent(error: impl Into<String>) -> Failure {
+    Failure {
+        error: error.into(),
+        sent: false,
+    }
+}
+fn sent(error: impl Into<String>) -> Failure {
+    Failure {
+        error: error.into(),
+        sent: true,
+    }
+}
+
+fn send(action: &str, input: &Value, request_id: &str) -> Result<Value, Failure> {
+    let endpoint = std::env::var("MONOCODE_CONTROL_ENDPOINT").map_err(|_| {
+        unsent("No MonoCode connection. Confirm the Orchestrator proposal in MonoCode first.")
+    })?;
+    let token = std::env::var("MONOCODE_CONTROL_TOKEN")
+        .map_err(|_| unsent("No MonoCode session credential. Start the lead from MonoCode."))?;
+    let address: SocketAddr = endpoint
+        .parse()
+        .map_err(|_| unsent("Invalid MonoCode endpoint"))?;
+    if !address.ip().is_loopback() {
+        return Err(unsent("MonoCode control only connects to localhost"));
+    }
+    let mut stream = TcpStream::connect_timeout(&address, Duration::from_secs(3))
+        .map_err(|_| unsent("MonoCode is not running or this connection has expired."))?;
+    stream
+        .set_read_timeout(Some(Duration::from_secs(40)))
+        .map_err(|e| unsent(e.to_string()))?;
+    stream
+        .set_write_timeout(Some(Duration::from_secs(5)))
+        .map_err(|e| unsent(e.to_string()))?;
+    writeln!(
+        stream,
+        "{}",
+        json!({"token":token,"action":action,"input":input,"requestId":request_id})
+    )
+    .map_err(|e| sent(e.to_string()))?;
+    let mut line = String::new();
+    BufReader::new(stream)
+        .take(2_000_001)
+        .read_line(&mut line)
+        .map_err(|e| sent(format!("No reply from MonoCode: {e}")))?;
+    if line.len() > 2_000_000 {
+        return Err(sent("MonoCode response is too large"));
+    }
+    serde_json::from_str(&line).map_err(|_| sent("MonoCode returned an invalid response"))
+}
+
+fn read_capped(mut source: impl Read) -> Result<String, String> {
+    let mut raw = String::new();
+    source
+        .by_ref()
+        .take(262_145)
+        .read_to_string(&mut raw)
+        .map_err(|e| e.to_string())?;
+    if raw.len() > 262_144 {
+        return Err("Input exceeds 256 KiB".into());
+    }
+    Ok(raw)
+}
+
+fn parse_args(args: &[String]) -> Result<Parsed, String> {
+    let is_help = |value: &str| matches!(value, "help" | "--help" | "-h");
+    let Some(action) = args.first() else {
+        return Ok(Parsed::Help);
+    };
+    if is_help(action) {
+        return Ok(Parsed::Help);
+    }
+    let action = action.clone();
+    if !ACTIONS.contains(&action.as_str()) {
+        return Err(format!(
+            "Unknown action: {action}. Use one of: {}. Run control --help.",
+            ACTIONS.join(", ")
+        ));
+    }
+    let mut input = None;
+    let mut request_id = uuid::Uuid::new_v4().to_string();
+    let mut index = 1;
+    while index < args.len() {
+        let flag = &args[index];
+        // `control delegate --help` should explain the command, not fail.
+        if is_help(flag) {
+            return Ok(Parsed::Help);
+        }
+        if !flag.starts_with("--") {
+            return Err(format!(
+                "Unexpected argument: {flag}. Pass the JSON object as --json '<JSON>'."
+            ));
+        }
+        let value = args.get(index + 1).ok_or_else(|| {
+            format!("Missing value for {flag}. Run control --help for the argument list.")
+        })?;
+        match flag.as_str() {
+            "--request-id" => request_id = value.clone(),
+            "--json" | "--input" => {
+                if input.is_some() {
+                    return Err("Supply only one input".into());
+                }
+                let raw = if flag == "--json" {
+                    if value.len() > 262_144 {
+                        return Err("Input exceeds 256 KiB".into());
+                    }
+                    value.clone()
+                } else if value == "-" {
+                    read_capped(std::io::stdin())?
+                } else {
+                    read_capped(std::fs::File::open(value).map_err(|e| e.to_string())?)?
+                };
+                let parsed: Value = serde_json::from_str(&raw)
+                    .map_err(|e| format!("Invalid JSON: {e}. Pass one JSON object, e.g. --json '{{\"taskId\":\"...\"}}'."))?;
+                if !parsed.is_object() {
+                    return Err("Input must be a JSON object".into());
+                }
+                input = Some(parsed);
+            }
+            _ => {
+                return Err(format!(
+                    "Unknown option: {flag}. Supported: --json, --input, --request-id."
+                ))
+            }
+        }
+        index += 2;
+    }
+    if request_id.is_empty() || request_id.len() > 128 {
+        return Err("Invalid request ID".into());
+    }
+    Ok(Parsed::Call(
+        action,
+        input.unwrap_or_else(|| json!({})),
+        request_id,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn args(values: &[&str]) -> Vec<String> {
+        values.iter().map(|s| s.to_string()).collect()
+    }
+    fn call(values: &[&str]) -> Result<(String, Value, String), String> {
+        match parse_args(&args(values))? {
+            Parsed::Call(action, input, id) => Ok((action, input, id)),
+            Parsed::Help => Err("help".into()),
+        }
+    }
+    #[test]
+    fn validates_inputs_without_invoking_a_shell() {
+        let (_, input, id) = call(&[
+            "delegate",
+            "--json",
+            r#"{"prompt":"$(touch nope) `hello`\nnext"}"#,
+            "--request-id",
+            "retry-1",
+        ])
+        .unwrap();
+        assert_eq!(id, "retry-1");
+        assert_eq!(input["prompt"], "$(touch nope) `hello`\nnext");
+        assert!(call(&["delegate", "--json", "[]"]).is_err());
+        assert!(call(&["delegate", "--json", "{}", "--json", "{}"]).is_err());
+        assert!(call(&["unknown"]).is_err());
+    }
+    #[test]
+    fn explains_help_and_malformed_invocations() {
+        assert!(matches!(parse_args(&args(&[])), Ok(Parsed::Help)));
+        assert!(matches!(parse_args(&args(&["--help"])), Ok(Parsed::Help)));
+        // Agents commonly probe a subcommand for its own usage text.
+        assert!(matches!(
+            parse_args(&args(&["delegate", "--help"])),
+            Ok(Parsed::Help)
+        ));
+        assert!(call(&["get", r#"{"taskId":"x"}"#])
+            .unwrap_err()
+            .contains("--json"));
+        assert!(call(&["get", "--json"]).unwrap_err().contains("--help"));
+        assert!(call(&["get", "--taskId", "x"])
+            .unwrap_err()
+            .contains("Unknown option"));
+        assert!(call(&["get", "--json", "{taskId}"])
+            .unwrap_err()
+            .contains("Invalid JSON"));
+    }
+    #[test]
+    fn help_names_every_action_and_the_real_executable() {
+        let text = help();
+        for action in ACTIONS {
+            assert!(text.contains(action), "help omits {action}");
+        }
+        assert!(!text.contains("{exe}"));
+        assert!(text.contains("--request-id"));
+    }
+    #[test]
+    fn quotes_the_control_path_only_when_the_shell_needs_it() {
+        assert_eq!(
+            quoted("/Applications/MonoCode.app/Contents/MacOS/monocode"),
+            "/Applications/MonoCode.app/Contents/MacOS/monocode"
+        );
+        assert_eq!(quoted("/Users/a b/MonoCode"), "'/Users/a b/MonoCode'");
+        assert_eq!(quoted("C:\\Tools\\monocode.exe"), "C:\\Tools\\monocode.exe");
+        assert_eq!(
+            quoted("C:\\Program Files\\MonoCode\\monocode.exe"),
+            "\"C:\\Program Files\\MonoCode\\monocode.exe\""
+        );
+        // A backslash escapes in a POSIX shell, so bare would rewrite the path.
+        assert_eq!(quoted("/Users/a\\b/MonoCode"), "'/Users/a\\b/MonoCode'");
+        assert_eq!(quoted("/Users/it's/MonoCode"), r"'/Users/it'\''s/MonoCode'");
+    }
+}
diff --git a/src-tauri/src/harness.rs b/src-tauri/src/harness.rs
index b61fa28e..8c345fc9 100644
--- a/src-tauri/src/harness.rs
+++ b/src-tauri/src/harness.rs
@@ -348,6 +348,8 @@ pub fn harness_spawn(
         .stderr(Stdio::piped());
     prepare_child(&mut cmd, &command);
 
+    crate::control::configure_child(&app, &session_id, &mut cmd);
+
     let mut child =
         spawn_managed(&mut cmd).map_err(|e| format!("Failed to start {command}: {e}"))?;
     let pid = child.id();
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 09b39dcf..07181a3c 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -2,6 +2,8 @@ use tauri::Manager;
 
 mod chat_background;
 mod checkpoint;
+mod control;
+pub mod control_cli;
 mod cursor_store;
 mod fs;
 mod gitlab;
@@ -197,6 +199,7 @@ pub fn run() {
         .setup(|app| {
             harness::reap_orphaned_harness_processes();
             session_store::init(app.handle())?;
+            control::init(app.handle())?;
             reminders::init(app.handle());
             checkpoint::init(app.handle())?;
             menu::install(app.handle())?;
@@ -220,6 +223,15 @@ pub fn run() {
             menu::dispatch(app, event.id().as_ref());
         })
         .invoke_handler(tauri::generate_handler![
+            control::control_enable,
+            control::control_disable,
+            control::control_reply,
+            control::control_save,
+            control::control_load,
+            control::control_scopes,
+            control::control_attach_worker,
+            control::control_authorize_turn,
+            control::control_turn_finished,
             default_cwd,
             home_dir,
             notifications::notification_permission,
@@ -403,6 +415,7 @@ pub fn run() {
             ..
         } => {
             let other_window = handle.webview_windows().keys().any(|name| name != &label);
+            control::window_closed(handle, &label);
             if !other_window {
                 reap_harness_children(handle);
             }
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 3b2b9e17..8af4da08 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -1,6 +1,11 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
+    if std::env::args().nth(1).as_deref() == Some("control") {
+        std::process::exit(monocode_lib::control_cli::run(
+            std::env::args().skip(2).collect(),
+        ));
+    }
     #[cfg(all(debug_assertions, target_os = "macos"))]
     monocode_lib::ensure_macos_dev_bundle();
     monocode_lib::run()
diff --git a/src-tauri/src/session_store.rs b/src-tauri/src/session_store.rs
index 2090ad55..82e75647 100644
--- a/src-tauri/src/session_store.rs
+++ b/src-tauri/src/session_store.rs
@@ -4,7 +4,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use rusqlite::{params, Connection, OptionalExtension};
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{json, Value};
 use tauri::{AppHandle, Emitter, Manager, State};
 
 const MIGRATION_V1: &str = r#"
@@ -99,6 +99,10 @@ pub struct SessionUpsert {
 #[serde(rename_all = "camelCase")]
 pub struct SessionSummary {
     pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration_lead_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration: Option<Value>,
     pub cwd: String,
     pub harness: String,
     pub model: String,
@@ -126,6 +130,8 @@ pub struct SessionSummary {
 #[serde(rename_all = "camelCase")]
 pub struct SessionRecord {
     pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration_lead_id: Option<String>,
     pub cwd: String,
     pub harness: String,
     pub model: String,
@@ -603,9 +609,128 @@ fn migrate(conn: &Connection) -> rusqlite::Result<()> {
     )?;
     crate::notes::ensure_notes_table(conn)?;
     crate::reminders::ensure_table(conn)?;
+    ensure_orchestration_history(conn)?;
     Ok(())
 }
 
+fn ensure_orchestration_history(conn: &Connection) -> rusqlite::Result<()> {
+    let indexed: bool = conn.query_row(
+        "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name = 'orchestration_sidebar')",
+        [],
+        |row| row.get(0),
+    )?;
+    let tx = conn.unchecked_transaction()?;
+    tx.execute_batch(
+        "CREATE TABLE IF NOT EXISTS orchestration_runs (lead_id TEXT PRIMARY KEY, state TEXT NOT NULL);
+         CREATE TABLE IF NOT EXISTS orchestration_sidebar (lead_id TEXT PRIMARY KEY, summary TEXT NOT NULL);
+         CREATE TABLE IF NOT EXISTS orchestration_workers (session_id TEXT PRIMARY KEY, lead_id TEXT NOT NULL);",
+    )?;
+    if !indexed {
+        // One-time compatibility pass for the preview that listed workers as
+        // separate chats. Normal sidebar reads never scan transcripts/run blobs.
+        let runs = tx
+            .prepare("SELECT lead_id, state FROM orchestration_runs")?
+            .query_map([], |row| {
+                Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+            })?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
+        for (lead, state) in runs {
+            if let Ok(run) = serde_json::from_str::<Value>(&state) {
+                index_orchestration(&tx, &lead, &run)?;
+            }
+        }
+        let workers = tx.prepare("SELECT id, blocks_json FROM sessions WHERE blocks_json LIKE '%orchestrationLeadId%'")?
+            .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
+        for (id, blocks) in workers {
+            if let Ok(blocks) = serde_json::from_str::<Value>(&blocks) {
+                remember_worker_from_blocks(&tx, &id, &blocks)?;
+            }
+        }
+    }
+    tx.commit()
+}
+
+fn remember_worker(conn: &Connection, id: &str, lead: &str) -> rusqlite::Result<()> {
+    if id != lead && validate_id(id, "Worker").is_ok() && validate_id(lead, "Lead").is_ok() {
+        // Keep earlier workers indexed when a lead starts a subsequent run.
+        conn.execute(
+            "INSERT OR IGNORE INTO orchestration_workers(session_id, lead_id) VALUES (?1, ?2)",
+            params![id, lead],
+        )?;
+    }
+    Ok(())
+}
+
+fn remember_worker_from_blocks(
+    conn: &Connection,
+    id: &str,
+    blocks: &Value,
+) -> rusqlite::Result<()> {
+    if let Some(blocks) = blocks.as_array() {
+        for block in blocks {
+            if block["role"] == "user" {
+                if let Some(lead) = block["orchestrationLeadId"].as_str() {
+                    remember_worker(conn, id, lead)?;
+                    break;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn index_orchestration(conn: &Connection, lead: &str, run: &Value) -> rusqlite::Result<()> {
+    let Some(tasks) = run["tasks"].as_array() else {
+        return Ok(());
+    };
+    let mut summaries = Vec::new();
+    for task in tasks {
+        let Some(id) = task["sessionId"].as_str() else {
+            continue;
+        };
+        remember_worker(conn, id, lead)?;
+        summaries.push(serde_json::json!({
+            "sessionId": id, "title": task["title"], "harness": task["harness"],
+            "model": task["model"], "status": task["status"],
+        }));
+    }
+    let summary = serde_json::json!({ "status": run["status"], "tasks": summaries });
+    conn.execute("INSERT INTO orchestration_sidebar(lead_id, summary) VALUES (?1, ?2) ON CONFLICT(lead_id) DO UPDATE SET summary = excluded.summary", params![lead, summary.to_string()])?;
+    Ok(())
+}
+
+pub(crate) fn save_orchestration(
+    conn: &Connection,
+    lead: &str,
+    run: &Value,
+) -> rusqlite::Result<()> {
+    let tx = conn.unchecked_transaction()?;
+    tx.execute("INSERT INTO orchestration_runs(lead_id, state) VALUES (?1, ?2) ON CONFLICT(lead_id) DO UPDATE SET state = excluded.state", params![lead, run.to_string()])?;
+    index_orchestration(&tx, lead, run)?;
+    tx.commit()
+}
+
+fn worker_parent(conn: &Connection, id: &str) -> rusqlite::Result<Option<String>> {
+    conn.query_row(
+        "SELECT lead_id FROM orchestration_workers WHERE session_id = ?1",
+        [id],
+        |row| row.get(0),
+    )
+    .optional()
+}
+
+fn orchestration_summary(conn: &Connection, id: &str) -> rusqlite::Result<Option<Value>> {
+    Ok(optional_json(
+        conn.query_row(
+            "SELECT summary FROM orchestration_sidebar WHERE lead_id = ?1",
+            [id],
+            |row| row.get(0),
+        )
+        .optional()?,
+    ))
+}
+
 fn upsert_session(conn: &Connection, session: &SessionUpsert) -> rusqlite::Result<SessionSummary> {
     let now = now_millis();
     let model_settings = serde_json::to_string(&session.model_settings)
@@ -708,8 +833,11 @@ fn upsert_session(conn: &Connection, session: &SessionUpsert) -> rusqlite::Resul
         ],
     )?;
 
+    remember_worker_from_blocks(conn, &session.id, &session.blocks)?;
     Ok(SessionSummary {
         id: session.id.clone(),
+        orchestration_lead_id: worker_parent(conn, &session.id)?,
+        orchestration: orchestration_summary(conn, &session.id)?,
         cwd: session.cwd.clone(),
         harness: session.harness.clone(),
         model: session.model.clone(),
@@ -979,11 +1107,13 @@ fn list_by_project(conn: &Connection, cwd: &str) -> rusqlite::Result<Vec<Session
     let mut statement = conn.prepare(
         "SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                 created_at, updated_at, branch, archived, pinned,
-                linked_work_item_json
+                linked_work_item_json,
+                (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
          FROM sessions
          WHERE cwd = ?1
            AND has_user_message = 1
            AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+           AND id NOT IN (SELECT session_id FROM orchestration_workers)
          ORDER BY updated_at DESC, id ASC",
     )?;
     let rows = statement.query_map(params![cwd], |row| {
@@ -993,6 +1123,8 @@ fn list_by_project(conn: &Connection, cwd: &str) -> rusqlite::Result<Vec<Session
         let linked_work_item = optional_json(row.get(12)?);
         Ok(SessionSummary {
             id: row.get(0)?,
+            orchestration_lead_id: None,
+            orchestration: optional_json(row.get(13)?),
             cwd: row.get(1)?,
             harness: row.get(2)?,
             model: row.get(3)?,
@@ -1017,11 +1149,13 @@ fn list_linked(conn: &Connection) -> rusqlite::Result<Vec<SessionSummary>> {
     let mut statement = conn.prepare(
         "SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                 created_at, updated_at, branch, archived, pinned,
-                linked_work_item_json
+                linked_work_item_json,
+                (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
          FROM sessions
          WHERE has_user_message = 1
            AND linked_work_item_json IS NOT NULL
            AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+           AND id NOT IN (SELECT session_id FROM orchestration_workers)
          ORDER BY updated_at DESC, id ASC",
     )?;
     let rows = statement.query_map([], |row| {
@@ -1029,6 +1163,8 @@ fn list_linked(conn: &Connection) -> rusqlite::Result<Vec<SessionSummary>> {
         let pinned: i64 = row.get(11)?;
         Ok(SessionSummary {
             id: row.get(0)?,
+            orchestration_lead_id: None,
+            orchestration: optional_json(row.get(13)?),
             cwd: row.get(1)?,
             harness: row.get(2)?,
             model: row.get(3)?,
@@ -1075,8 +1211,114 @@ fn optional_json(raw: Option<String>) -> Option<Value> {
 }
 
 fn delete_session(conn: &Connection, session_id: &str) -> rusqlite::Result<()> {
-    conn.execute("DELETE FROM sessions WHERE id = ?1", params![session_id])?;
-    Ok(())
+    let tx = conn.unchecked_transaction()?;
+    let parent = worker_parent(&tx, session_id)?;
+    // Ownership is also carried in transcripts for older clients. Release
+    // that metadata along with the index so reopening a worker stays detached.
+    let workers = tx.prepare("SELECT id, blocks_json FROM sessions WHERE id IN (SELECT session_id FROM orchestration_workers WHERE lead_id = ?1)")?
+        .query_map([session_id], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    for (id, raw) in workers {
+        let mut blocks: Value = serde_json::from_str(&raw).map_err(|e| {
+            rusqlite::Error::FromSqlConversionFailure(0, rusqlite::types::Type::Text, Box::new(e))
+        })?;
+        if let Some(blocks) = blocks.as_array_mut() {
+            for block in blocks {
+                if block["orchestrationLeadId"] == session_id {
+                    if let Some(block) = block.as_object_mut() {
+                        block.remove("orchestrationLeadId");
+                    }
+                }
+            }
+        }
+        tx.execute(
+            "UPDATE sessions SET blocks_json = ?1 WHERE id = ?2",
+            params![blocks.to_string(), id],
+        )?;
+    }
+    tx.execute(
+        "DELETE FROM orchestration_runs WHERE lead_id = ?1",
+        [session_id],
+    )?;
+    tx.execute(
+        "DELETE FROM orchestration_sidebar WHERE lead_id = ?1",
+        [session_id],
+    )?;
+    if let Some(parent) = parent.filter(|id| id != session_id) {
+        let raw: Option<String> = tx
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = ?1",
+                [&parent],
+                |row| row.get(0),
+            )
+            .optional()?;
+        if let Some(raw) = raw {
+            let mut run: Value = serde_json::from_str(&raw).map_err(|e| {
+                rusqlite::Error::FromSqlConversionFailure(
+                    0,
+                    rusqlite::types::Type::Text,
+                    Box::new(e),
+                )
+            })?;
+            let mut removed = false;
+            if let Some(tasks) = run["tasks"].as_array_mut() {
+                let ids: Vec<String> = tasks
+                    .iter()
+                    .filter(|task| task["sessionId"] == session_id)
+                    .filter_map(|task| task["id"].as_str().map(str::to_string))
+                    .collect();
+                let before = tasks.len();
+                tasks.retain(|task| task["sessionId"] != session_id);
+                removed = before != tasks.len();
+                if removed {
+                    for task in tasks {
+                        if let Some(deps) = task["dependsOn"].as_array_mut() {
+                            deps.retain(|dep| !ids.iter().any(|id| dep == id));
+                        }
+                        // Removing a prerequisite must not release queued work.
+                        // The app stops the run before deleting any current member.
+                        if matches!(
+                            task["status"].as_str(),
+                            Some("queued" | "running" | "cancelling")
+                        ) {
+                            task["status"] = json!("cancelled");
+                            task["accepted"] = json!(false);
+                            task["delivered"] = json!(true);
+                        }
+                    }
+                }
+            }
+            if removed {
+                if matches!(run["status"].as_str(), Some("active" | "paused")) {
+                    run["status"] = json!("stopped");
+                    run["error"] =
+                        json!("A worker conversation was deleted. Start a new run to continue.");
+                }
+                run["requests"] = json!({});
+                tx.execute(
+                    "UPDATE orchestration_runs SET state = ?1 WHERE lead_id = ?2",
+                    params![run.to_string(), parent],
+                )?;
+                index_orchestration(&tx, &parent, &run)?;
+            }
+        }
+        // Also handle summaries left by an older client without a run record.
+        if let Some(mut summary) = orchestration_summary(&tx, &parent)? {
+            if let Some(tasks) = summary["tasks"].as_array_mut() {
+                tasks.retain(|task| task["sessionId"] != session_id);
+            }
+            tx.execute(
+                "UPDATE orchestration_sidebar SET summary = ?1 WHERE lead_id = ?2",
+                params![summary.to_string(), parent],
+            )?;
+        }
+    }
+    tx.execute(
+        "DELETE FROM orchestration_workers WHERE session_id = ?1 OR lead_id = ?1",
+        [session_id],
+    )?;
+    tx.execute("DELETE FROM sessions WHERE id = ?1", [session_id])?;
+    tx.commit()
 }
 
 fn set_archived(conn: &Connection, session_id: &str, archived: bool) -> rusqlite::Result<()> {
@@ -1123,6 +1365,7 @@ fn get_session(conn: &Connection, session_id: &str) -> rusqlite::Result<Option<S
             })?;
             Ok(SessionRecord {
                 id: row.get(0)?,
+                orchestration_lead_id: worker_parent(conn, session_id)?,
                 cwd: row.get(1)?,
                 harness: row.get(2)?,
                 model: row.get(3)?,
@@ -1285,6 +1528,90 @@ mod tests {
         assert_eq!(count, 2);
     }
 
+    #[test]
+    fn orchestration_history_groups_workers_and_keeps_their_transcripts() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker-a", "worker-b", "unrelated"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        let run = json!({"status": "active", "tasks": [
+            {"sessionId": "worker-a", "title": "UI", "harness": "codex", "model": "one", "status": "running", "prompt": "private instructions", "result": "large result"},
+            {"sessionId": "worker-b", "title": "Tests", "harness": "claude", "model": "two", "status": "queued"}
+        ]});
+        save_orchestration(&conn, "lead", &run).unwrap();
+        // Reopening/migration must not hydrate, pause or otherwise mutate runs.
+        migrate(&conn).unwrap();
+        let rows = list_by_project(&conn, "/tmp/a").unwrap();
+        assert_eq!(rows.len(), 2);
+        let lead = rows.iter().find(|row| row.id == "lead").unwrap();
+        let summary = lead.orchestration.as_ref().unwrap();
+        assert_eq!(summary["tasks"].as_array().unwrap().len(), 2);
+        assert_eq!(summary["status"], "active");
+        assert!(summary["tasks"][0].get("prompt").is_none());
+        assert!(summary["tasks"][0].get("result").is_none());
+        let worker = get_session(&conn, "worker-a").unwrap().unwrap();
+        assert_eq!(worker.orchestration_lead_id.as_deref(), Some("lead"));
+        assert!(has_user_block(&worker.blocks));
+        // A later run replaces the card's agents without resurfacing old chats.
+        save_orchestration(&conn, "lead", &json!({"status": "active", "tasks": []})).unwrap();
+        assert_eq!(list_by_project(&conn, "/tmp/a").unwrap().len(), 2);
+    }
+
+    #[test]
+    fn worker_upserts_carry_ownership_before_the_run_is_saved() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        let mut worker = sample("worker", "/tmp/a", "Worker");
+        worker.blocks =
+            json!([{"id": "u", "role": "user", "text": "Task", "orchestrationLeadId": "lead"}]);
+        worker.linked_work_item = Some(json!({"kind": "pr", "number": 1}));
+        let summary = upsert_session(&conn, &worker).unwrap();
+        assert_eq!(summary.orchestration_lead_id.as_deref(), Some("lead"));
+        assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
+        assert!(list_linked(&conn).unwrap().is_empty());
+        // An older renderer's next write cannot accidentally detach a worker.
+        worker.blocks = json!([{"id": "u", "role": "user", "text": "Task"}]);
+        upsert_session(&conn, &worker).unwrap();
+        assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
+    }
+
+    #[test]
+    fn migration_groups_workers_from_the_earlier_preview() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "old-worker", "current-worker"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        conn.execute(
+            "UPDATE sessions SET blocks_json = ?1 WHERE id = 'old-worker'",
+            [
+                json!([{"role": "user", "orchestrationLeadId": "lead", "text": "Old task"}])
+                    .to_string(),
+            ],
+        )
+        .unwrap();
+        conn.execute("INSERT INTO orchestration_runs(lead_id, state) VALUES ('lead', ?1)", [json!({"status": "paused", "tasks": [{"sessionId": "current-worker", "title": "Task", "harness": "codex", "model": "one", "status": "completed"}]}).to_string()]).unwrap();
+        conn.execute_batch("DROP TABLE orchestration_sidebar; DROP TABLE orchestration_workers;")
+            .unwrap();
+        migrate(&conn).unwrap();
+        let rows = list_by_project(&conn, "/tmp/a").unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].id, "lead");
+        assert_eq!(
+            rows[0].orchestration.as_ref().unwrap()["tasks"][0]["title"],
+            "Task"
+        );
+        assert_eq!(
+            worker_parent(&conn, "old-worker").unwrap().as_deref(),
+            Some("lead")
+        );
+        assert_eq!(
+            worker_parent(&conn, "current-worker").unwrap().as_deref(),
+            Some("lead")
+        );
+    }
+
     /// The sidebar query must stay answerable from the index alone. Selecting a
     /// column the index does not carry silently reintroduces a table seek per
     /// row, and every summary column sits behind a ~180 KB `blocks_json` blob
@@ -1299,11 +1626,13 @@ mod tests {
                 "EXPLAIN QUERY PLAN
                  SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                         created_at, updated_at, branch, archived, pinned,
-                        linked_work_item_json
+                        linked_work_item_json,
+                        (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
                  FROM sessions
                  WHERE cwd = ?1
                    AND has_user_message = 1
                    AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+                   AND id NOT IN (SELECT session_id FROM orchestration_workers)
                  ORDER BY updated_at DESC, id ASC",
                 params!["/tmp/a"],
                 |row| row.get(3),
@@ -1533,6 +1862,137 @@ mod tests {
         assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
     }
 
+    #[test]
+    fn deleting_a_lead_releases_current_and_earlier_workers() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "earlier", "current", "other-lead", "other-worker"] {
+            let mut session = sample(id, "/tmp/a", id);
+            session.linked_work_item = Some(json!({"kind": "pr", "number": 1}));
+            if ["earlier", "current"].contains(&id) {
+                session.blocks = json!([{"id":"u","role":"user","text":"Keep this transcript","orchestrationLeadId":"lead"}]);
+            }
+            upsert_session(&conn, &session).unwrap();
+        }
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"stopped","tasks":[{"id":"task","sessionId":"current"}]}),
+        )
+        .unwrap();
+        let other =
+            json!({"status":"active","tasks":[{"id":"other-task","sessionId":"other-worker"}]});
+        save_orchestration(&conn, "other-lead", &other).unwrap();
+        delete_session(&conn, "lead").unwrap();
+
+        for id in ["earlier", "current"] {
+            let worker = get_session(&conn, id).unwrap().unwrap();
+            assert!(worker.orchestration_lead_id.is_none());
+            assert!(worker.blocks[0].get("orchestrationLeadId").is_none());
+            assert_eq!(worker.blocks[0]["text"], "Keep this transcript");
+            assert!(list_by_project(&conn, "/tmp/a")
+                .unwrap()
+                .iter()
+                .any(|row| row.id == id));
+            assert!(list_linked(&conn).unwrap().iter().any(|row| row.id == id));
+        }
+        assert!(orchestration_summary(&conn, "lead").unwrap().is_none());
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM orchestration_runs WHERE lead_id = 'lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(count, 0);
+        assert_eq!(
+            worker_parent(&conn, "other-worker").unwrap().as_deref(),
+            Some("other-lead")
+        );
+        let raw: String = conn
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = 'other-lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(serde_json::from_str::<Value>(&raw).unwrap(), other);
+        migrate(&conn).unwrap();
+        assert!(worker_parent(&conn, "current").unwrap().is_none());
+    }
+
+    #[test]
+    fn deleting_a_worker_prunes_parent_state_and_does_not_release_dependencies() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker", "dependent", "earlier"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        remember_worker(&conn, "earlier", "lead").unwrap();
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"active", "requests":{"old":{"result":"worker"}}, "tasks":[
+                {"id":"task", "sessionId":"worker", "status":"running", "dependsOn":[]},
+                {"id":"next", "sessionId":"dependent", "status":"queued", "dependsOn":["task"]}
+            ]}),
+        )
+        .unwrap();
+        delete_session(&conn, "worker").unwrap();
+        assert!(get_session(&conn, "worker").unwrap().is_none());
+        assert!(worker_parent(&conn, "worker").unwrap().is_none());
+        assert_eq!(
+            worker_parent(&conn, "earlier").unwrap().as_deref(),
+            Some("lead")
+        );
+        let raw: String = conn
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = 'lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        let run: Value = serde_json::from_str(&raw).unwrap();
+        assert_eq!(run["status"], "stopped");
+        assert_eq!(run["requests"], json!({}));
+        assert_eq!(run["tasks"].as_array().unwrap().len(), 1);
+        assert_eq!(run["tasks"][0]["sessionId"], "dependent");
+        assert_eq!(run["tasks"][0]["status"], "cancelled");
+        assert_eq!(run["tasks"][0]["dependsOn"], json!([]));
+        let summary = orchestration_summary(&conn, "lead").unwrap().unwrap();
+        assert_eq!(summary["tasks"].as_array().unwrap().len(), 1);
+        assert_eq!(summary["tasks"][0]["sessionId"], "dependent");
+        assert_eq!(summary["tasks"][0]["status"], "cancelled");
+    }
+
+    #[test]
+    fn failed_session_deletion_rolls_back_orchestration_cleanup() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"stopped", "tasks":[{"id":"task", "sessionId":"worker"}]}),
+        )
+        .unwrap();
+        conn.execute_batch("CREATE TRIGGER reject_delete BEFORE DELETE ON sessions BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
+        for id in ["lead", "worker"] {
+            assert!(delete_session(&conn, id).is_err());
+            assert!(get_session(&conn, id).unwrap().is_some());
+            assert_eq!(
+                worker_parent(&conn, "worker").unwrap().as_deref(),
+                Some("lead")
+            );
+            assert_eq!(
+                orchestration_summary(&conn, "lead").unwrap().unwrap()["tasks"][0]["sessionId"],
+                "worker"
+            );
+        }
+    }
+
     #[test]
     fn migration_v6_adds_archived_column() {
         let store = SessionStore::open_in_memory().unwrap();
diff --git a/src/App.tsx b/src/App.tsx
index c357e9e1..0526ce4c 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,28 @@
 import { invoke } from "@tauri-apps/api/core";
+import { orchestrator, type ControlOutcome } from "./lib/orchestration";
+import { modelsFor } from "./lib/models";
+import { isHarnessAvailable } from "./lib/harness/availability";
+import {
+  completeOrchestrationProposal,
+  orchestrationPlanningPrompt,
+  proposalBlock,
+  validateOrchestrationSettings,
+  withOrchestrationProposal,
+  type OrchestrationProposal,
+} from "./lib/orchestrationPlan";
+import { discoverOrchestrationSettings } from "./lib/orchestrationCatalog";
+import {
+  attachOrchestrationWorkers,
+  consolidateOrchestrationTabs,
+  prepareOrchestrationWorkerDetails,
+  releaseOrchestrationWorker,
+} from "./lib/orchestrationWorkspace";
+import {
+  OrchestrationActions,
+  OrchestrationWorkers,
+  type OrchestrationWorkerDetail,
+} from "./chrome/OrchestrationActions";
+import { flushSync } from "react-dom";
 import { listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { ask, message } from "@tauri-apps/plugin-dialog";
@@ -75,6 +99,7 @@ import {
   nextTerminalTitle,
   openChangesTab,
   openCommitTab,
+  newAgentTab,
   openEditorTab,
   openSessionChangesTab,
   openTerminalTab,
@@ -232,6 +257,7 @@ import {
 } from "./lib/workspaceTabGroups";
 import { runSessionRemoval } from "./lib/sessionRemoval";
 import {
+  HARNESSES,
   HARNESS_LABEL,
   HARNESS_TITLE,
   canReplaceSessionTitle,
@@ -661,6 +687,20 @@ export default function App({
     useState<InboxSessionPortal | null>(null);
   const openingInboxSessions = useRef(new Map<string, Promise<string>>());
   const [notesViewOpen, setNotesViewOpen] = useState(false);
+  const [inspectedWorkerId, setInspectedWorkerId] = useState<string | null>(
+    null,
+  );
+  // Set while the lead's tab is still opening; the agent tab lands on the
+  // commit that brings it in.
+  const [workerDetailRequest, setWorkerDetailRequest] = useState<{
+    leadId: string;
+    workers: OrchestrationWorkerDetail[];
+  } | null>(null);
+  const orchestrationRuns = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
   const notesEnabled = useSyncExternalStore(
     subscribeNotesEnabled,
     loadNotesEnabled,
@@ -827,6 +867,7 @@ export default function App({
 
   const stopSessionForRemoval = useCallback(
     async (sessionId: string): Promise<Session | undefined> => {
+      await orchestrator.stopForSession(sessionId);
       const open = sessionsRef.current.find(
         (session) => session.id === sessionId,
       );
@@ -990,7 +1031,10 @@ export default function App({
   const nextBusySessionIds = useMemo(() => {
     const ids = new Set<string>();
     for (const session of sessions) {
-      if (session.busy) ids.add(session.id);
+      if (session.busy) {
+        ids.add(session.id);
+        if (session.orchestrationLeadId) ids.add(session.orchestrationLeadId);
+      }
     }
     return ids;
   }, [sessions]);
@@ -1036,7 +1080,10 @@ export default function App({
   const nextApprovalSessionIds = useMemo(() => {
     const ids = new Set<string>();
     for (const session of sessions) {
-      if (sessionNeedsInput(session)) ids.add(session.id);
+      if (sessionNeedsInput(session)) {
+        ids.add(session.id);
+        if (session.orchestrationLeadId) ids.add(session.orchestrationLeadId);
+      }
     }
     return ids;
   }, [sessions]);
@@ -1383,6 +1430,20 @@ export default function App({
     for (const session of sessions) {
       if (session.inboxAsk) visibleIds.add(session.id);
     }
+    // Internal workers stay attached to the lead, even while idle between
+    // turns. They must not be discarded merely because they have no tab.
+    for (const session of sessions) {
+      if (
+        session.orchestrationLeadId &&
+        (visibleIds.has(session.orchestrationLeadId) ||
+          orchestrationRuns.some(
+            (run) =>
+              run.leadId === session.orchestrationLeadId &&
+              ["active", "paused"].includes(run.status),
+          ))
+      )
+        visibleIds.add(session.id);
+    }
     for (const sessionId of visibleIds) {
       openingSessionIds.current.delete(sessionId);
       loadedSessionCache.current.delete(sessionId);
@@ -1416,12 +1477,13 @@ export default function App({
           skipForgetSessionIds.current.has(session.id),
       ),
     );
-  }, [sessions, tabs, persistSession, liveAgentsEnabled]);
+  }, [sessions, tabs, persistSession, liveAgentsEnabled, orchestrationRuns]);
 
   const activateTab = useCallback((id: string, paneId?: string) => {
     const tab = tabsRef.current.find((entry) => entry.id === id);
     const nextFocusedId =
-      tab && paneId &&
+      tab &&
+      paneId &&
       (leafIds(tab.layout).includes(paneId) ||
         tab.editorPanes.some((entry) => entry.id === paneId) ||
         (tab.terminalPanes ?? []).some((entry) => entry.id === paneId))
@@ -3197,29 +3259,30 @@ export default function App({
 
   const onSelectHistorySession = useCallback(
     async (sessionId: string) => {
-      const linkedUpdate = linkedSessionUpdatesRef.current.get(sessionId);
-      if (focusOpenSession(sessionId)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
-        return;
-      }
-      const session = await ensureOpenSession(sessionId);
+      let session = await ensureOpenSession(sessionId);
       if (!session || session.inboxAsk) return;
-      // A previous race may have left this tab pointing at a parked session.
-      // Once the session is restored, reuse that tab instead of creating a
-      // duplicate and leave the broken pane behind.
-      if (focusOpenSession(sessionId)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+      const parentId =
+        session.orchestrationLeadId ??
+        orchestrator.forSession(sessionId)?.leadId;
+      if (parentId && parentId !== sessionId) {
+        setInspectedWorkerId(sessionId);
+        session = await ensureOpenSession(parentId);
+        if (!session) return;
+      }
+      const linkedUpdate = linkedSessionUpdatesRef.current.get(session.id);
+      if (focusOpenSession(session.id)) {
+        if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
         return;
       }
       if (replaceBlankPaneWithSession(session)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+        if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
         return;
       }
       const tab = newTab(session.id);
       appendTab(tab, session.cwd);
       setActiveTabId(tab.id);
       setComposerFocused(true);
-      if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+      if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
     },
     [
       appendTab,
@@ -3267,7 +3330,9 @@ export default function App({
   const sessionReminders = useSessionReminders(
     openReminderSession,
     ensureReminderSessionsSaved,
-    sessions.filter((session) => !session.inboxAsk).map((session) => session.id),
+    sessions
+      .filter((session) => !session.inboxAsk)
+      .map((session) => session.id),
   );
 
   const dismissNoticesForContinuedSession = useCallback(
@@ -3445,6 +3510,10 @@ export default function App({
             );
           },
           stop: async () => {
+            const run =
+              mode === "delete" ? orchestrator.forSession(sessionId) : undefined;
+            if (run && (run.status === "active" || run.status === "paused"))
+              await orchestrator.stopRun(run.leadId);
             await stopSessionForRemoval(sessionId);
           },
           updateSession: (stopped) => {
@@ -3457,7 +3526,33 @@ export default function App({
           persist: async (latest) => {
             if (latest) await flushSessionCheckpoint(sessionId);
             if (mode === "delete") {
-              await deleteSession(sessionId);
+              await orchestrator.deleteSession(sessionId, () =>
+                deleteSession(sessionId),
+              );
+              const released = sessionsRef.current.map((session) =>
+                releaseOrchestrationWorker(session, sessionId),
+              );
+              sessionsRef.current = released;
+              setSessions(released);
+              for (const [id, cached] of loadedSessionCache.current) {
+                if (releaseOrchestrationWorker(cached, sessionId) !== cached)
+                  invalidateLoadedSession(id);
+              }
+              // Pending reads may still carry the deleted lead's ownership.
+              for (const id of sessionLoads.current.keys())
+                invalidateLoadedSession(id);
+              for (const [id, pending] of pendingPersist.current) {
+                pendingPersist.current.set(
+                  id,
+                  releaseOrchestrationWorker(pending, sessionId),
+                );
+              }
+              const releaseSummary = (entry: SessionSummary) =>
+                entry.orchestrationLeadId === sessionId
+                  ? { ...entry, orchestrationLeadId: undefined }
+                  : entry;
+              setHistory((current) => current.map(releaseSummary));
+              setStoredLinkedSessions((current) => current.map(releaseSummary));
               return;
             }
             if (latest && shouldPersistSession(latest)) {
@@ -4210,8 +4305,36 @@ export default function App({
         intent?: TurnIntent;
         planBlockId?: string;
         buildTarget?: PlanBuildTarget;
+        managed?: boolean;
+        onSettled?: (outcome: ControlOutcome) => void;
       },
     ) => {
+      const controlError = orchestrator.submissionError(
+        sessionId,
+        options?.managed,
+      );
+      if (controlError) {
+        enqueueHarnessEvent(sessionId, { type: "status", text: controlError });
+        flushHarnessEvents();
+        return;
+      }
+      if (options?.managed) {
+        const target = sessionsRef.current.find((s) => s.id === sessionId);
+        if (
+          !target ||
+          target.busy ||
+          target.pendingSwitch ||
+          isPreparingHandoff(target) ||
+          removingSessionIds.current.has(sessionId)
+        ) {
+          options.onSettled?.({
+            status: "failed",
+            text: "",
+            error: "Session is unavailable or already running",
+          });
+          return;
+        }
+      }
       if (removingSessionIds.current.has(sessionId)) return;
       const storedCurrent = sessionsRef.current.find((s) => s.id === sessionId);
       if (!storedCurrent) return;
@@ -4219,6 +4342,22 @@ export default function App({
         ? withPlanBuildTarget(storedCurrent, options.buildTarget)
         : storedCurrent;
       const intent = options?.intent ?? "default";
+      if (intent === "orchestrate") {
+        try {
+          const run = orchestrator.forSession(sessionId);
+          if (run && ["active", "paused"].includes(run.status))
+            throw new Error(
+              "Stop the current orchestration run before preparing another proposal.",
+            );
+        } catch (error) {
+          enqueueHarnessEvent(sessionId, {
+            type: "status",
+            text: error instanceof Error ? error.message : String(error),
+          });
+          flushHarnessEvents();
+          return;
+        }
+      }
       const approvedPlan = options?.planBlockId
         ? current.blocks.find(
             (block) =>
@@ -4263,7 +4402,7 @@ export default function App({
 
       if (current.busy && !pendingSwitch) {
         const followUpBehavior =
-          intent === "plan"
+          intent === "plan" || intent === "orchestrate"
             ? "queue"
             : (options?.followUpBehavior ?? loadFollowUpBehavior());
         if (followUpBehavior === "queue") {
@@ -4363,6 +4502,26 @@ export default function App({
 
       const gen = (turnGen.current.get(sessionId) ?? 0) + 1;
       turnGen.current.set(sessionId, gen);
+      const proposalId =
+        intent === "orchestrate" ? crypto.randomUUID() : undefined;
+      let proposalDraft: OrchestrationProposal | undefined = proposalId
+        ? {
+            version: 1,
+            leadId: sessionId,
+            cwd: current.cwd,
+            request: harnessText,
+            author: {
+              harness: current.harness,
+              model: current.model,
+              name: resolveModel(current.harness, current.model).name,
+            },
+            settings: { choices: [], maxWorkers: 2 },
+            status: "planning",
+            title: "Orchestration plan",
+            summary: "",
+            tasks: [],
+          }
+        : undefined;
       const isFirstTurn = current.blocks.length === 0;
       const placeholderTitle = canReplaceSessionTitle(
         current.title,
@@ -4386,7 +4545,11 @@ export default function App({
           : card
             ? SECOND_OPINION_TITLE
             : submittedText;
-      const cards = rawCommand ? undefined : userTurnCards(noteCard, card);
+      const cards = {
+        ...(rawCommand ? undefined : userTurnCards(noteCard, card)),
+        // The orchestrator writes these turns, not the user; hide them.
+        ...(options?.managed ? { internal: true } : {}),
+      };
       const live = isLiveHarness(current.harness);
       const queuedHandoff =
         live && !pendingSwitch ? pendingHandoff(current) : null;
@@ -4516,10 +4679,50 @@ export default function App({
         if (pendingSwitch) {
           void forgetHarnessSession(pendingSwitch.from, sessionId);
         }
+        options?.onSettled?.({
+          status: "failed",
+          text: "",
+          error: "Harness is not connected",
+        });
         return;
       }
 
+      if (proposalId && proposalDraft) {
+        const draft = proposalDraft;
+        setSessions((prev) =>
+          prev.map((session) =>
+            session.id === sessionId
+              ? {
+                  ...session,
+                  blocks: [...session.blocks, proposalBlock(proposalId, draft)],
+                }
+              : session,
+          ),
+        );
+      }
+
+      let controlOutcome: ControlOutcome = {
+        status: "failed",
+        text: "",
+        error: "Turn did not complete",
+      };
+      let controlText = "";
+      let proposalText = "";
+      let nativeProposalText = "";
       void (async () => {
+        if (proposalDraft && proposalId) {
+          const settings = await discoverOrchestrationSettings();
+          if (turnGen.current.get(sessionId) !== gen) return;
+          proposalDraft = { ...proposalDraft, settings };
+          const discovering = proposalDraft;
+          setSessions((prev) =>
+            prev.map((session) =>
+              session.id === sessionId
+                ? withOrchestrationProposal(session, proposalId, discovering)
+                : session,
+            ),
+          );
+        }
         let wrap = handoffCard
           ? {
               from: handoffCard.from,
@@ -4571,6 +4774,22 @@ export default function App({
         let providerFailureSeen = false;
         const routePlanEvent = (event: HarnessEvent): HarnessEvent | null => {
           if (event.type === "session.error") providerFailureSeen = true;
+          if (proposalDraft) {
+            if (event.type === "message.delta") {
+              proposalText = (proposalText + event.text).slice(-200_000);
+              return null;
+            }
+            if (event.type === "message.completed") {
+              proposalText += "\n";
+              return null;
+            }
+            if (event.type === "plan") {
+              nativeProposalText = event.append
+                ? nativeProposalText + event.text
+                : event.text;
+              return null;
+            }
+          }
           if (intent !== "plan") return event;
           if (event.type === "plan") {
             nativePlanSeen = true;
@@ -4582,7 +4801,7 @@ export default function App({
           return event;
         };
 
-        if (!current.inboxAsk) {
+        if (!current.inboxAsk && !orchestrator.forSession(sessionId)) {
           await beginSessionTurn(sessionId, workCwd).catch(() => undefined);
         }
         if (turnGen.current.get(sessionId) !== gen) return;
@@ -4597,8 +4816,11 @@ export default function App({
                   sessionId,
                   cwd: workCwd,
                 });
-          const turnPrompt =
-            intent === "plan" && !rawCommand ? planTurnPrompt(prompt) : prompt;
+          const turnPrompt = proposalDraft
+            ? orchestrationPlanningPrompt(prompt, proposalDraft.settings)
+            : intent === "plan" && !rawCommand
+              ? planTurnPrompt(prompt)
+              : prompt;
           const earlier = queuedHandoff
             ? userMessagesAfterHandoff(current)
             : [];
@@ -4609,21 +4831,34 @@ export default function App({
             model: current.model,
             modelSettings: current.modelSettings,
             runtimeMode: current.runtimeMode,
-            intent,
-            text: inboxAskPrompt(
-              rawCommand ? undefined : current.inboxAsk,
-              wrap && !rawCommand
-                ? wrapHandoffPrompt(
-                    wrap.text,
-                    wrap.from,
-                    turnPrompt.trim() || CONTINUE_PROMPT,
-                    earlier,
-                  )
-                : turnPrompt,
+            intent: intent === "orchestrate" ? "plan" : intent,
+            // A lead drives the control CLI over loopback; without this the
+            // harness sandbox denies the socket and it cannot supervise.
+            controlsAgents: orchestrator.run(sessionId)?.status === "active",
+            text: orchestrator.prompt(
+              sessionId,
+              inboxAskPrompt(
+                rawCommand ? undefined : current.inboxAsk,
+                wrap && !rawCommand
+                  ? wrapHandoffPrompt(
+                      wrap.text,
+                      wrap.from,
+                      turnPrompt.trim() || CONTINUE_PROMPT,
+                      earlier,
+                    )
+                  : turnPrompt,
+              ),
             ),
             attachments: prepared,
             onEvent: (event) => {
               if (turnGen.current.get(sessionId) !== gen) return;
+              orchestrator.observe(sessionId, event);
+              if (options?.onSettled && event.type === "message.delta")
+                controlText = (controlText + event.text).slice(-20_000);
+              if (options?.onSettled && event.type === "message.completed")
+                controlText += "\n";
+              if (event.type === "session.error")
+                controlOutcome.error = event.message;
               if (
                 wrap &&
                 (event.type === "session.started" ||
@@ -4632,7 +4867,8 @@ export default function App({
                 revealHandoff(wrap.text);
               }
               nudgeOpenEditors(event, workCwd);
-              trackSessionEdits(sessionId, workCwd, event);
+              if (!orchestrator.forSession(sessionId))
+                trackSessionEdits(sessionId, workCwd, event);
               const routed = routePlanEvent(event);
               if (routed) enqueueHarnessEvent(sessionId, routed);
             },
@@ -4658,6 +4894,7 @@ export default function App({
             error instanceof Error
               ? error.message
               : `${current.harness} adapter failed`;
+          controlOutcome.error = message;
           if (!providerFailureSeen) {
             enqueueHarnessEvent(sessionId, {
               type: "session.error",
@@ -4668,6 +4905,16 @@ export default function App({
         } finally {
           if (turnGen.current.get(sessionId) !== gen) return;
           flushHarnessEvents();
+          controlOutcome = {
+            status:
+              providerFailureSeen ||
+              isProviderFailureText(controlText) ||
+              !buildSucceeded
+                ? "failed"
+                : "completed",
+            text: controlText.trim(),
+            ...(providerFailureSeen ? { error: controlOutcome.error } : {}),
+          };
           // A failed provider can leave its process alive with a dead event
           // stream or poisoned turn state. Park it now; the next prompt will
           // reconnect and resume through a fresh transport.
@@ -4685,9 +4932,22 @@ export default function App({
                 providerFailureSeen ||
                 isProviderFailureText(lastAssistantTextInTurn(stopped));
               const finalized =
-                intent === "plan" && !nativePlanSeen && !providerFailed
-                  ? promoteLastAssistantToPlan(stopped, planEventKey)
-                  : stopped;
+                proposalDraft && proposalId
+                  ? withOrchestrationProposal(
+                      stopped,
+                      proposalId,
+                      completeOrchestrationProposal(
+                        proposalDraft,
+                        nativeProposalText || proposalText,
+                        providerFailed || !buildSucceeded
+                          ? (controlOutcome.error ??
+                              "The lead could not finish planning.")
+                          : undefined,
+                      ),
+                    )
+                  : intent === "plan" && !nativePlanSeen && !providerFailed
+                    ? promoteLastAssistantToPlan(stopped, planEventKey)
+                    : stopped;
               return approvedPlan && intent === "build"
                 ? withPlanStatus(
                     finalized,
@@ -4717,7 +4977,45 @@ export default function App({
           nudgeWatchedFiles();
           window.setTimeout(() => nudgeWatchedFiles(), 150);
         }
-      })();
+      })()
+        .catch((error: unknown) => {
+          controlOutcome = {
+            status: "failed",
+            text: controlText,
+            error: error instanceof Error ? error.message : String(error),
+          };
+          if (turnGen.current.get(sessionId) === gen) {
+            enqueueHarnessEvent(sessionId, {
+              type: "session.error",
+              message: controlOutcome.error!,
+            });
+            flushHarnessEvents();
+            setSessions((prev) =>
+              prev.map((session) =>
+                session.id === sessionId
+                  ? proposalId && proposalDraft
+                    ? withOrchestrationProposal(
+                        stopStreaming(session),
+                        proposalId,
+                        completeOrchestrationProposal(
+                          proposalDraft,
+                          "",
+                          controlOutcome.error,
+                        ),
+                      )
+                    : stopStreaming(session)
+                  : session,
+              ),
+            );
+          }
+        })
+        .finally(() => {
+          options?.onSettled?.(
+            turnGen.current.get(sessionId) !== gen
+              ? { status: "cancelled", text: controlText }
+              : controlOutcome,
+          );
+        });
     },
     [
       dismissNoticesForContinuedSession,
@@ -4772,6 +5070,7 @@ export default function App({
         !session ||
         session.busy ||
         block?.role !== "plan" ||
+        !!block.orchestration ||
         !block.text.trim() ||
         block.plan?.status === "streaming" ||
         block.plan?.status === "building" ||
@@ -4903,14 +5202,23 @@ export default function App({
         ? queuedMessageForSubmit(session, messageId, "steer")
         : undefined;
       if (!session || !message) return;
+      if (message.intent === "orchestrate" && session.busy) {
+        enqueueHarnessEvent(sessionId, {
+          type: "status",
+          text: "Orchestration planning will start after the current turn finishes.",
+        });
+        flushHarnessEvents();
+        return;
+      }
       onSubmit(sessionId, message.text, message.attachments, {
         followUpBehavior: "steer",
         queuedMessageId: message.id,
         noteCard: message.noteCard,
         handoffCard: message.handoffCard,
+        intent: message.intent,
       });
     },
-    [onSubmit],
+    [onSubmit, enqueueHarnessEvent, flushHarnessEvents],
   );
 
   const onResumeQueue = useCallback(
@@ -5153,7 +5461,14 @@ export default function App({
   );
 
   const onStop = useCallback(
-    (sessionId: string) => {
+    (sessionId: string, managed = false) => {
+      if (!managed) {
+        const stopping = orchestrator.stopForSession(sessionId);
+        if (stopping) {
+          void stopping.catch(console.error);
+          return;
+        }
+      }
       const session = sessionsRef.current.find((s) => s.id === sessionId);
       turnGen.current.set(sessionId, (turnGen.current.get(sessionId) ?? 0) + 1);
       flushHarnessEvents();
@@ -5252,20 +5567,414 @@ export default function App({
   const onQuestionInteraction = useCallback(
     (sessionId: string, requestId: number) => {
       const session = sessionsRef.current.find((s) => s.id === sessionId);
-      if (session) keepHarnessQuestionOpen(session.harness, sessionId, requestId);
+      if (session)
+        keepHarnessQuestionOpen(session.harness, sessionId, requestId);
     },
     [],
   );
 
   const onOpenApprovalSession = useCallback(
     (sessionId: string) => {
-      if (!focusOpenSession(sessionId)) {
+      const parentId =
+        sessionsRef.current.find((session) => session.id === sessionId)
+          ?.orchestrationLeadId ?? orchestrator.forSession(sessionId)?.leadId;
+      if (parentId && parentId !== sessionId) {
+        setInspectedWorkerId(sessionId);
+        if (!focusOpenSession(parentId)) void onSelectHistorySession(parentId);
+      } else if (!focusOpenSession(sessionId)) {
         void onSelectHistorySession(sessionId);
       }
     },
     [focusOpenSession, onSelectHistorySession],
   );
 
+  useEffect(() => {
+    setSessions((prev) => attachOrchestrationWorkers(prev, orchestrationRuns));
+  }, [orchestrationRuns]);
+
+  useEffect(() => {
+    const next = consolidateOrchestrationTabs(
+      tabs,
+      activeTabId,
+      orchestrationRuns,
+    );
+    if (next.tabs !== tabs) setTabs(next.tabs);
+    if (next.activeTabId !== activeTabId) setActiveTabId(next.activeTabId);
+  }, [tabs, activeTabId, orchestrationRuns]);
+
+  useLayoutEffect(() => {
+    orchestrator.bind({
+      session: (id) => sessionsRef.current.find((session) => session.id === id),
+      sessions: () => sessionsRef.current,
+      choices: () =>
+        HARNESSES.filter(isHarnessAvailable).map((harness) => ({
+          harness,
+          models: modelsFor(harness).map(({ id, name }) => ({ id, name })),
+        })),
+      createWorker: async (run, task) => {
+        await invoke("control_attach_worker", {
+          leadId: run.leadId,
+          sessionId: task.sessionId,
+        });
+        const existing = sessionsRef.current.find(
+          (session) => session.id === task.sessionId,
+        );
+        const lead = sessionsRef.current.find(
+          (session) => session.id === run.leadId,
+        );
+        if (!lead) throw new Error("Lead session is unavailable");
+        if (existing) {
+          if (
+            existing.harness !== task.harness ||
+            existing.model !== task.model ||
+            existing.cwd !== run.cwd
+          )
+            throw new Error(
+              "This worker's configuration changed. Restore its approved harness, model and project before retrying.",
+            );
+          // The lead's runtime mode governs its agents, including across a
+          // change mid-run: auto stays auto, supervised asks the lead.
+          if (existing.runtimeMode !== lead.runtimeMode) {
+            const synced = { ...existing, runtimeMode: lead.runtimeMode };
+            await upsertSession(synced);
+            const next = sessionsRef.current.map((session) =>
+              session.id === synced.id ? synced : session,
+            );
+            sessionsRef.current = next;
+            setSessions(next);
+          }
+          return;
+        }
+        const restored = await getSession(task.sessionId);
+        if (
+          restored &&
+          (restored.harness !== task.harness || restored.model !== task.model)
+        )
+          throw new Error(
+            "The saved worker no longer matches its approved model. Create a new assignment.",
+          );
+        const base = restored
+          ? {
+              ...restored,
+              busy: false,
+              cwd: run.cwd,
+              worktreeCwd: undefined,
+              runtimeMode: lead.runtimeMode,
+            }
+          : {
+              ...newSession(
+                task.harness,
+                run.cwd,
+                task.model,
+                lead.runtimeMode,
+              ),
+              id: task.sessionId,
+              title: task.title,
+            };
+        const worker = { ...base, orchestrationLeadId: run.leadId };
+        if (worker.providerSessionId)
+          bindHarnessSession(
+            worker.harness,
+            worker.id,
+            worker.providerSessionId,
+            worker.cwd,
+          );
+        await upsertSession(worker);
+        const next = [...sessionsRef.current, worker];
+        sessionsRef.current = next;
+        setSessions(next);
+        // Workers belong to the lead's agent panel; no workspace tab is created.
+      },
+      submit: (id, text, done) => {
+        // Commit the new turn before the scheduler or confirmation updates
+        // another session snapshot in the same event loop.
+        flushSync(() =>
+          onSubmit(id, text, [], { managed: true, onSettled: done }),
+        );
+      },
+      steer: async (id, text) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (!session) throw new Error("This agent is no longer available");
+        if (!session.busy)
+          throw new Error(
+            "This agent is not running a turn; send it a fresh one with message.",
+          );
+        if (
+          !isLiveHarness(session.harness) ||
+          !canSteerHarness(session.harness)
+        )
+          throw new Error(
+            `${session.harness} cannot take guidance mid-turn. Wait for the turn to finish, then use message.`,
+          );
+        // Record it on the worker before dispatch, so its own transcript shows
+        // why it changed course even if the harness call then fails.
+        const next = sessionsRef.current.map((entry) =>
+          entry.id === id ? appendSteerUser(entry, text) : entry,
+        );
+        sessionsRef.current = next;
+        setSessions(next);
+        await steerHarnessTurn({
+          harness: session.harness,
+          sessionId: id,
+          cwd: sessionWorkCwd(session),
+          model: session.model,
+          modelSettings: session.modelSettings,
+          text,
+        });
+      },
+      respondApproval: (id, requestId, decision) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (session)
+          respondHarnessApproval(session.harness, id, requestId, decision);
+      },
+      answerQuestion: (id, requestId, reply) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (session)
+          respondHarnessQuestion(session.harness, id, requestId, reply);
+      },
+      stop: async (id) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        onStop(id, true);
+        try {
+          if (session)
+            await Promise.all(
+              sessionChildHarnesses(session).map((harness) =>
+                stopHarnessSession(harness, id),
+              ),
+            );
+        } finally {
+          // Also reap processes left behind by a renderer reload, before the
+          // corresponding session has been restored in this window.
+          await invoke("harness_kill", { sessionId: id });
+          await invoke("control_turn_finished", { sessionId: id });
+        }
+      },
+    });
+  }, [onSubmit, onStop]);
+
+  useEffect(() => {
+    orchestrator.sync();
+  }, [sessions]);
+
+  useEffect(() => {
+    const listening = listen<{
+      id: string;
+      sessionId: string;
+      requestId: string;
+      action: string;
+      input: Record<string, unknown>;
+    }>("monocode-control-request", ({ payload }) => {
+      void orchestrator
+        .handle(
+          payload.sessionId,
+          payload.requestId,
+          payload.action,
+          payload.input,
+        )
+        .then(
+          (result) =>
+            invoke("control_reply", {
+              id: payload.id,
+              response: { ok: true, result },
+            }),
+          (error: unknown) =>
+            invoke("control_reply", {
+              id: payload.id,
+              response: {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+              },
+            }),
+        )
+        .catch(console.error);
+    });
+    return () => {
+      void listening.then((unlisten) => unlisten());
+    };
+  }, []);
+
+  const confirmingOrchestration = useRef(new Set<string>());
+  const queueWorkerPanes = useCallback(
+    (workers: OrchestrationWorkerDetail[]) => {
+      // Finished workers are not open; load stored transcripts before the
+      // tabs appear so the pane does not flash the empty state.
+      void prepareOrchestrationWorkerDetails(workers, {
+        openLead: async (leadId) => {
+          if (!focusOpenSession(leadId)) await onSelectHistorySession(leadId);
+        },
+        openWorker: ensureOpenSession,
+        hasSession: (id) =>
+          sessionsRef.current.some((session) => session.id === id),
+      })
+        .then((request) => {
+          if (request?.workers.length) setWorkerDetailRequest(request);
+        })
+        .catch(console.error);
+    },
+    [ensureOpenSession, focusOpenSession, onSelectHistorySession],
+  );
+  const onOpenWorkerDetails = useCallback(
+    (worker: OrchestrationWorkerDetail) => {
+      setInspectedWorkerId(worker.sessionId);
+      queueWorkerPanes([worker]);
+    },
+    [queueWorkerPanes],
+  );
+  useEffect(() => {
+    if (!workerDetailRequest) return;
+    const { leadId, workers } = workerDetailRequest;
+    const tab = tabs.find((entry) => leafIds(entry.layout).includes(leadId));
+    if (!tab) {
+      // Still opening: this runs again on the commit that lands the lead. If
+      // the lead never arrived at all, drop the request rather than let it
+      // fire against some later tab change.
+      if (!sessionsRef.current.some((entry) => entry.id === leadId)) {
+        setWorkerDetailRequest(null);
+      }
+      return;
+    }
+    setWorkerDetailRequest(null);
+    // Every agent of a run shares one pane, the way files do: `openEditorTab`
+    // focuses an open tab, adds to the pane already beside the lead, or splits
+    // one off when there is none.
+    const cwd =
+      sessionsRef.current.find((entry) => entry.id === leadId)?.cwd ??
+      projectCwdRef.current;
+    const files = workers.map((worker) =>
+      newAgentTab(worker.title, cwd, {
+        sessionId: worker.sessionId,
+        leadId,
+        harness: worker.harness,
+      }),
+    );
+    setTabs((prev) =>
+      prev.map((entry) => {
+        if (entry.id !== tab.id) return entry;
+        const opened = files.reduce(
+          (next, file) => openEditorTab(next, file),
+          entry,
+        );
+        // Leave the first worker focused so View agents lands on the start
+        // of the run rather than the last tab added.
+        return files[0] ? openEditorTab(opened, files[0]) : opened;
+      }),
+    );
+    setActiveTabId(tab.id);
+    setComposerFocused(false);
+  }, [tabs, workerDetailRequest]);
+  const orchestrationWorkers = useMemo(
+    () => ({
+      selectedId: inspectedWorkerId,
+      inspect: setInspectedWorkerId,
+      openDetails: onOpenWorkerDetails,
+    }),
+    [inspectedWorkerId, onOpenWorkerDetails],
+  );
+  const updateOrchestrationCard = useCallback(
+    (leadId: string, blockId: string, proposal: OrchestrationProposal) => {
+      const next = sessionsRef.current.map((session) =>
+        session.id === leadId
+          ? withOrchestrationProposal(session, blockId, proposal)
+          : session,
+      );
+      sessionsRef.current = next;
+      setSessions(next);
+      return next.find((session) => session.id === leadId);
+    },
+    [],
+  );
+  const orchestrationActions = useMemo(
+    () => ({
+      open: onOpenApprovalSession,
+      openAgents: queueWorkerPanes,
+      update: (
+        leadId: string,
+        blockId: string,
+        edited: OrchestrationProposal,
+      ) => {
+        const session = sessionsRef.current.find(
+          (entry) => entry.id === leadId,
+        );
+        const proposal = session?.blocks.find(
+          (block) => block.id === blockId,
+        )?.orchestration;
+        if (
+          !session ||
+          session.busy ||
+          proposal?.status !== "ready" ||
+          confirmingOrchestration.current.has(leadId)
+        )
+          return;
+        // Keep the discovered catalog authoritative while allowing task and parallelism edits.
+        const settings = validateOrchestrationSettings({
+          ...proposal.settings,
+          maxWorkers: edited.settings.maxWorkers,
+        });
+        updateOrchestrationCard(leadId, blockId, {
+          ...proposal,
+          settings,
+          tasks: edited.tasks,
+        });
+      },
+      confirm: async (leadId: string, blockId: string) => {
+        if (confirmingOrchestration.current.has(leadId)) return;
+        confirmingOrchestration.current.add(leadId);
+        let proposal: OrchestrationProposal | undefined;
+        try {
+          await orchestrator.hydrate(leadId);
+          const session = sessionsRef.current.find(
+            (entry) => entry.id === leadId,
+          );
+          proposal = session?.blocks.find(
+            (block) => block.id === blockId,
+          )?.orchestration;
+          if (!session || session.busy || proposal?.status !== "ready")
+            throw new Error(
+              "Wait for the proposal to finish before confirming.",
+            );
+          if (
+            session.harness !== proposal.author.harness ||
+            session.model !== proposal.author.model
+          )
+            throw new Error(
+              "The lead model has changed. Switch back to the model shown on this card, or generate a new proposal.",
+            );
+          const starting = updateOrchestrationCard(leadId, blockId, {
+            ...proposal,
+            status: "starting",
+          })!;
+          // Save the edited card before anything can execute.
+          await upsertSession(starting);
+          await orchestrator.startApproved(leadId, blockId, proposal);
+          updateOrchestrationCard(leadId, blockId, {
+            ...proposal,
+            status: "approved",
+          });
+        } catch (error) {
+          if (proposal)
+            updateOrchestrationCard(leadId, blockId, {
+              ...proposal,
+              status: "ready",
+            });
+          throw error;
+        } finally {
+          confirmingOrchestration.current.delete(leadId);
+        }
+      },
+      retry: (leadId: string, blockId: string) => {
+        const session = sessionsRef.current.find(
+          (entry) => entry.id === leadId,
+        );
+        const proposal = session?.blocks.find(
+          (block) => block.id === blockId,
+        )?.orchestration;
+        if (!session || session.busy || !proposal) return;
+        onSubmit(leadId, proposal.request, [], { intent: "orchestrate" });
+      },
+    }),
+    [onOpenApprovalSession, queueWorkerPanes, onSubmit, updateOrchestrationCard],
+  );
+
   const onSelectLiveAgent = useCallback(
     (sessionId: string) => {
       setSearchViewOpen(false);
@@ -5297,15 +6006,21 @@ export default function App({
 
   const sidebarHistory = useMemo(
     () =>
-      historyWithLiveSessions(history, sessions, sidebarCwd, {
-        ...(projectBranches?.current
-          ? { branch: projectBranches.current }
-          : {}),
-        ...(sidebarCwd && sidebarCwd !== "~"
-          ? { repo: projectName(sidebarCwd) }
-          : {}),
-      }),
-    [history, projectBranches, sessions, sidebarCwd],
+      historyWithLiveSessions(
+        history,
+        sessions,
+        sidebarCwd,
+        {
+          ...(projectBranches?.current
+            ? { branch: projectBranches.current }
+            : {}),
+          ...(sidebarCwd && sidebarCwd !== "~"
+            ? { repo: projectName(sidebarCwd) }
+            : {}),
+        },
+        orchestrationRuns,
+      ),
+    [history, projectBranches, sessions, sidebarCwd, orchestrationRuns],
   );
   const {
     unseen: inboxUnseen,
@@ -5347,7 +6062,9 @@ export default function App({
       sessions
         .filter(
           (session) =>
-            !session.inboxAsk && sameProjectPath(session.cwd, sidebarCwd),
+            !session.inboxAsk &&
+            !session.orchestrationLeadId &&
+            sameProjectPath(session.cwd, sidebarCwd),
         )
         .map((session) =>
           summaryFromSession(session, {
@@ -5983,410 +6700,421 @@ export default function App({
   };
 
   return (
-    <div
-      className={`flex h-full text-content ${
-        HAS_NATIVE_GLASS ? "bg-background-base/40" : "bg-background-base"
-      }`}
-    >
-      <Sidebar
-        cwd={sidebarCwd}
-        gitCwd={gitCwd}
-        open
-        tab={sidebarTab}
-        onTabChange={setSidebarTab}
-        filesSearchOpen={filesSearchOpen}
-        onFilesSearchOpenChange={setFilesSearchOpen}
-        onOpenFilesSearch={onFindInProject}
-        searchFocusToken={searchFocusToken}
-        sessions={sidebarHistory}
-        busySessionIds={busySessionIds}
-        approvalSessionIds={approvalSessionIds}
-        activeSessionId={active?.id}
-        status={historyFailed ? "error" : "idle"}
-        pending={historyPending}
-        onSelectSession={onSelectHistorySession}
-        onPrefetchSession={onPrefetchHistorySession}
-        onSessionNavigationOrder={onSessionNavigationOrder}
-        onPlaceSessionOnPane={onPlaceSessionOnPane}
-        onRenameSession={onRenameHistorySession}
-        onArchiveSession={onArchiveHistorySession}
-        onArchiveSessions={onArchiveHistorySessions}
-        onPinSession={onPinHistorySession}
-        onPinSessions={onPinHistorySessions}
-        reminders={sessionReminders.reminders}
-        onSetReminders={sessionReminders.schedule}
-        onCancelReminders={sessionReminders.cancel}
-        onDeleteSession={onDeleteHistorySession}
-        onDeleteSessions={onDeleteHistorySessions}
-        onOpenFile={onOpenFile}
-        onOpenTerminal={onOpenTerminal}
-        onFileMoved={onFileMoved}
-        onFileDeleted={onFileDeleted}
-        canGoBack={
-          tabVisitNav.canBack ||
-          searchViewOpen ||
-          settingsOpen ||
-          inboxViewOpen ||
-          notesViewOpen
-        }
-        canGoForward={tabVisitNav.canForward}
-        onGoBack={onRailBack}
-        onGoForward={onRailForward}
-        onOpenDiff={onOpenWorkingTreeDiff}
-        onOpenAllChanges={onOpenAllChanges}
-        onOpenCommit={onOpenCommit}
-        onShowSourceControl={onToggleChanges}
-        selectedDiffPath={
-          activeTab ? selectedChangePath(activeTab, gitCwd) : undefined
-        }
-        selectedDiffKind={activeTab ? selectedChangeKind(activeTab) : undefined}
-        selectedCommitSha={activeTab ? selectedCommitSha(activeTab) : undefined}
-        textHarness={pickTextHarness(active?.harness)}
-        recents={recents}
-        busyProjectPaths={sessions.flatMap((session) =>
-          session.busy && session.cwd ? [session.cwd] : [],
-        )}
-        liveAgents={liveAgents}
-        onSelectAgent={onSelectLiveAgent}
-        onSelectProject={onSelectProject}
-        onOpenProject={pickProject}
-        onRemoveProject={onRemoveProject}
-        onNew={onNew}
-        openSessions={openProjectSessions}
-        onNewTerminal={onNewTerminal}
-        onSearch={onOpenSearch}
-        onOpenInbox={onOpenInbox}
-        onOpenInboxItem={onOpenLinkedWorkItem}
-        onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-        onGoToFile={onGoToFile}
-        searchActive={searchViewOpen}
-        inboxActive={inboxViewOpen}
-        notesActive={notesViewOpen}
-        notesEnabled={notesEnabled}
-        projectRailOpen={projectRailOpen}
-        onToggleProjectRail={onToggleProjectRail}
-        unseenFinishedIds={unseenFinishedIds}
-        inboxUnseen={inboxUnseen}
-        linkedSessionUpdateIds={linkedSessionUpdateIds}
-        settingsOpen={settingsOpen}
-        settingsSection={settingsSection}
-        onOpenSettings={onOpenSettings}
-        onSelectSettingsSection={onSelectSettingsSection}
-        onCloseSettings={onCloseSettings}
-        updateNotice={updateNotice}
-        onOpenWhatsNew={onOpenWhatsNew}
-        onDismissUpdate={() => setUpdateNotice(null)}
-      />
-
-      <div className="body-glass flex min-h-0 min-w-0 flex-1 flex-col">
+    <OrchestrationActions.Provider value={orchestrationActions}>
+      <OrchestrationWorkers.Provider value={orchestrationWorkers}>
         <div
-          className={
-            searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
-              ? "hidden"
-              : "flex min-h-0 min-w-0 flex-1 flex-col"
-          }
-          aria-hidden={
-            searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
-          }
-          inert={
-            searchViewOpen ||
-            settingsOpen ||
-            inboxViewOpen ||
-            notesViewOpen ||
-            undefined
-          }
+          className={`flex h-full text-content ${
+            HAS_NATIVE_GLASS ? "bg-background-base/40" : "bg-background-base"
+          }`}
         >
-          {!IS_MAC ? (
-            <MenuBar
-              onNew={onNew}
-              onNewTerminal={onNewTerminal}
-              onToggleTerminal={onToggleProjectTerminal}
-              onGoToFile={onGoToFile}
-              onToggleSidebar={onToggleSidebar}
-              onShowSourceControl={onToggleChanges}
-              onCloseCurrentTab={
-                activeTabId ? () => onCloseTab(activeTabId) : undefined
-              }
-              onCloseOtherTabs={onCloseOtherTabs}
-              onCloseAllTabs={onCloseAllTabs}
-              onPickProject={pickProject}
-              onFindInProject={onFindInProject}
-              onSearch={onOpenSearch}
-              onOpenInbox={onOpenInbox}
-              onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-              onZoomIn={() => {
-                const next = saveUiScale(zoomInUiScale(loadUiScale()));
-                void applyUiScale(next);
-              }}
-              onZoomOut={() => {
-                const next = saveUiScale(zoomOutUiScale(loadUiScale()));
-                void applyUiScale(next);
-              }}
-              onZoomReset={() => {
-                saveUiScale(UI_SCALE_DEFAULT);
-                void applyUiScale(UI_SCALE_DEFAULT);
-              }}
-            />
-          ) : null}
-          <TitleBar
-            tabs={titleTabs}
-            activeId={activeTabId}
+          <Sidebar
             cwd={sidebarCwd}
-            projectRailOpen={projectRailOpen}
-            onToggleSidebar={onToggleSidebar}
-            onSelect={activateTab}
+            gitCwd={gitCwd}
+            open
+            tab={sidebarTab}
+            onTabChange={setSidebarTab}
+            filesSearchOpen={filesSearchOpen}
+            onFilesSearchOpenChange={setFilesSearchOpen}
+            onOpenFilesSearch={onFindInProject}
+            searchFocusToken={searchFocusToken}
+            sessions={sidebarHistory}
+            busySessionIds={busySessionIds}
+            approvalSessionIds={approvalSessionIds}
+            activeSessionId={active?.id}
+            status={historyFailed ? "error" : "idle"}
+            pending={historyPending}
+            onSelectSession={onSelectHistorySession}
+            onPrefetchSession={onPrefetchHistorySession}
+            onSessionNavigationOrder={onSessionNavigationOrder}
+            onPlaceSessionOnPane={onPlaceSessionOnPane}
+            onRenameSession={onRenameHistorySession}
+            onArchiveSession={onArchiveHistorySession}
+            onArchiveSessions={onArchiveHistorySessions}
+            onPinSession={onPinHistorySession}
+            onPinSessions={onPinHistorySessions}
+            reminders={sessionReminders.reminders}
+            onSetReminders={sessionReminders.schedule}
+            onCancelReminders={sessionReminders.cancel}
+            onDeleteSession={onDeleteHistorySession}
+            onDeleteSessions={onDeleteHistorySessions}
+            onOpenFile={onOpenFile}
+            onOpenTerminal={onOpenTerminal}
+            onFileMoved={onFileMoved}
+            onFileDeleted={onFileDeleted}
+            canGoBack={
+              tabVisitNav.canBack ||
+              searchViewOpen ||
+              settingsOpen ||
+              inboxViewOpen ||
+              notesViewOpen
+            }
+            canGoForward={tabVisitNav.canForward}
+            onGoBack={onRailBack}
+            onGoForward={onRailForward}
+            onOpenDiff={onOpenWorkingTreeDiff}
+            onOpenAllChanges={onOpenAllChanges}
+            onOpenCommit={onOpenCommit}
+            onShowSourceControl={onToggleChanges}
+            selectedDiffPath={
+              activeTab ? selectedChangePath(activeTab, gitCwd) : undefined
+            }
+            selectedDiffKind={
+              activeTab ? selectedChangeKind(activeTab) : undefined
+            }
+            selectedCommitSha={
+              activeTab ? selectedCommitSha(activeTab) : undefined
+            }
+            textHarness={pickTextHarness(active?.harness)}
+            recents={recents}
+            busyProjectPaths={sessions.flatMap((session) =>
+              session.busy && session.cwd ? [session.cwd] : [],
+            )}
+            liveAgents={liveAgents}
+            onSelectAgent={onSelectLiveAgent}
+            onSelectProject={onSelectProject}
+            onOpenProject={pickProject}
+            onRemoveProject={onRemoveProject}
             onNew={onNew}
+            openSessions={openProjectSessions}
             onNewTerminal={onNewTerminal}
-            onShowTerminal={onShowProjectTerminal}
-            projectTerminalActive={
-              !!currentProjectDock && currentProjectDock.pane.files.length > 0
-            }
-            onOpenSettings={onOpenSettings}
+            onSearch={onOpenSearch}
             onOpenInbox={onOpenInbox}
+            onOpenInboxItem={onOpenLinkedWorkItem}
             onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-            onClose={onCloseTitleTab}
-            onCloseMany={onCloseTabs}
-            onReorder={onReorderTabs}
             onGoToFile={onGoToFile}
-            recents={recents}
-            onSelectProject={onSelectProject}
+            searchActive={searchViewOpen}
+            inboxActive={inboxViewOpen}
+            notesActive={notesViewOpen}
+            notesEnabled={notesEnabled}
+            projectRailOpen={projectRailOpen}
+            onToggleProjectRail={onToggleProjectRail}
+            unseenFinishedIds={unseenFinishedIds}
+            inboxUnseen={inboxUnseen}
+            linkedSessionUpdateIds={linkedSessionUpdateIds}
+            settingsOpen={settingsOpen}
+            settingsSection={settingsSection}
+            onOpenSettings={onOpenSettings}
+            onSelectSettingsSection={onSelectSettingsSection}
+            onCloseSettings={onCloseSettings}
+            updateNotice={updateNotice}
+            onOpenWhatsNew={onOpenWhatsNew}
+            onDismissUpdate={() => setUpdateNotice(null)}
           />
 
-          <main className="relative min-h-0 min-w-0 flex-1">
+          <div className="body-glass flex min-h-0 min-w-0 flex-1 flex-col">
             <div
-              ref={dockGridRef}
-              className="absolute inset-0 grid h-full min-h-0 min-w-0"
+              className={
+                searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
+                  ? "hidden"
+                  : "flex min-h-0 min-w-0 flex-1 flex-col"
+              }
+              aria-hidden={
+                searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
+              }
+              inert={
+                searchViewOpen ||
+                settingsOpen ||
+                inboxViewOpen ||
+                notesViewOpen ||
+                undefined
+              }
             >
-              {projectTerminals.map((dock) => {
-                const show =
-                  dock.open && sameProjectPath(dock.projectPath, projectCwd);
-                return (
-                  <div
-                    key={dock.projectPath}
-                    className={
-                      show
-                        ? "h-full min-h-0 min-w-0 w-full overflow-hidden"
-                        : "hidden"
-                    }
-                    style={show ? { gridArea: "dock" } : undefined}
-                    aria-hidden={!show}
-                  >
-                    <ProjectTerminalDock
-                      dock={dock}
-                      focused={show && projectTerminalFocused}
-                      onFocus={focusProjectTerminal}
-                      onHide={onHideProjectTerminal}
-                      onSideChange={onProjectTerminalSide}
-                      onSizePaint={paintDockSize}
-                      onSizeCommit={commitDockSize}
-                      onAddTerminal={() =>
-                        onOpenTerminal(active?.cwd ?? projectCwd)
-                      }
-                      onSelectTerminal={onSelectProjectTerminal}
-                      onCloseTerminal={onCloseProjectTerminal}
-                      onCloseOtherTerminals={onCloseOtherProjectTerminals}
-                      onReorderTerminals={onReorderProjectTerminals}
-                      onTerminalMetaChange={onTerminalMetaChange}
-                    />
-                  </div>
-                );
-              })}
-              <div
-                className="relative flex min-h-0 min-w-0 flex-row"
-                style={{ gridArea: "main" }}
-              >
-                <div className="relative min-h-0 min-w-0 flex-1">
-                  {tabs.map((tab) => (
-                    <div
-                      key={tab.id}
-                      aria-hidden={tab.id !== activeTabId}
-                      className={
-                        tab.id === activeTabId
-                          ? "absolute inset-0 flex h-full min-h-0 flex-col"
-                          : "hidden"
-                      }
-                    >
-                      <div className="flex h-full min-h-0 min-w-0 flex-1 flex-col">
-                        <PaneTree
-                          {...sessionPaneProps}
-                          visible={tab.id === activeTabId && !inboxViewOpen}
-                          layout={tab.layout}
-                          sessions={sessions}
-                          editorPanes={[
-                            ...tab.editorPanes,
-                            ...(tab.terminalPanes ?? []),
-                          ]}
-                          dirtyFileIds={dirtyFiles}
-                          fileErrorCounts={fileErrorCounts}
-                          focusedId={
-                            tab.id === activeTabId &&
-                            !inboxViewOpen &&
-                            !tab.diffFocused &&
-                            !projectTerminalFocused
-                              ? tab.focusedId
-                              : ""
-                          }
-                          addToChatSessionId={
-                            tab.id === activeTabId ? active?.id : undefined
-                          }
-                          composerFocused={
-                            composerFocused && !projectTerminalFocused
-                          }
-                          onSelectFile={onSelectFileSurface}
-                          onCloseFile={onCloseFile}
-                          onCloseOtherFiles={onCloseOtherFiles}
-                          onReorderFiles={onReorderFiles}
-                          onFileDirtyChange={onFileDirtyChange}
-                          onFileErrorCountChange={onFileErrorCountChange}
-                          onRatio={(splitId, index, ratio) =>
-                            onRatio(tab.id, splitId, index, ratio)
+              {!IS_MAC ? (
+                <MenuBar
+                  onNew={onNew}
+                  onNewTerminal={onNewTerminal}
+                  onToggleTerminal={onToggleProjectTerminal}
+                  onGoToFile={onGoToFile}
+                  onToggleSidebar={onToggleSidebar}
+                  onShowSourceControl={onToggleChanges}
+                  onCloseCurrentTab={
+                    activeTabId ? () => onCloseTab(activeTabId) : undefined
+                  }
+                  onCloseOtherTabs={onCloseOtherTabs}
+                  onCloseAllTabs={onCloseAllTabs}
+                  onPickProject={pickProject}
+                  onFindInProject={onFindInProject}
+                  onSearch={onOpenSearch}
+                  onOpenInbox={onOpenInbox}
+                  onOpenNotes={notesEnabled ? onOpenNotes : undefined}
+                  onZoomIn={() => {
+                    const next = saveUiScale(zoomInUiScale(loadUiScale()));
+                    void applyUiScale(next);
+                  }}
+                  onZoomOut={() => {
+                    const next = saveUiScale(zoomOutUiScale(loadUiScale()));
+                    void applyUiScale(next);
+                  }}
+                  onZoomReset={() => {
+                    saveUiScale(UI_SCALE_DEFAULT);
+                    void applyUiScale(UI_SCALE_DEFAULT);
+                  }}
+                />
+              ) : null}
+              <TitleBar
+                tabs={titleTabs}
+                activeId={activeTabId}
+                cwd={sidebarCwd}
+                projectRailOpen={projectRailOpen}
+                onToggleSidebar={onToggleSidebar}
+                onSelect={activateTab}
+                onNew={onNew}
+                onNewTerminal={onNewTerminal}
+                onShowTerminal={onShowProjectTerminal}
+                projectTerminalActive={
+                  !!currentProjectDock &&
+                  currentProjectDock.pane.files.length > 0
+                }
+                onOpenSettings={onOpenSettings}
+                onOpenInbox={onOpenInbox}
+                onOpenNotes={notesEnabled ? onOpenNotes : undefined}
+                onClose={onCloseTitleTab}
+                onCloseMany={onCloseTabs}
+                onReorder={onReorderTabs}
+                onGoToFile={onGoToFile}
+                recents={recents}
+                onSelectProject={onSelectProject}
+              />
+
+              <main className="relative min-h-0 min-w-0 flex-1">
+                <div
+                  ref={dockGridRef}
+                  className="absolute inset-0 grid h-full min-h-0 min-w-0"
+                >
+                  {projectTerminals.map((dock) => {
+                    const show =
+                      dock.open &&
+                      sameProjectPath(dock.projectPath, projectCwd);
+                    return (
+                      <div
+                        key={dock.projectPath}
+                        className={
+                          show
+                            ? "h-full min-h-0 min-w-0 w-full overflow-hidden"
+                            : "hidden"
+                        }
+                        style={show ? { gridArea: "dock" } : undefined}
+                        aria-hidden={!show}
+                      >
+                        <ProjectTerminalDock
+                          dock={dock}
+                          focused={show && projectTerminalFocused}
+                          onFocus={focusProjectTerminal}
+                          onHide={onHideProjectTerminal}
+                          onSideChange={onProjectTerminalSide}
+                          onSizePaint={paintDockSize}
+                          onSizeCommit={commitDockSize}
+                          onAddTerminal={() =>
+                            onOpenTerminal(active?.cwd ?? projectCwd)
                           }
-                          editorNavigation={editorNavigation}
-                          onUpdatePlan={onUpdatePlan}
-                          onMovePane={onMovePane}
+                          onSelectTerminal={onSelectProjectTerminal}
+                          onCloseTerminal={onCloseProjectTerminal}
+                          onCloseOtherTerminals={onCloseOtherProjectTerminals}
+                          onReorderTerminals={onReorderProjectTerminals}
                           onTerminalMetaChange={onTerminalMetaChange}
                         />
                       </div>
+                    );
+                  })}
+                  <div
+                    className="relative flex min-h-0 min-w-0 flex-row"
+                    style={{ gridArea: "main" }}
+                  >
+                    <div className="relative min-h-0 min-w-0 flex-1">
+                      {tabs.map((tab) => (
+                        <div
+                          key={tab.id}
+                          aria-hidden={tab.id !== activeTabId}
+                          className={
+                            tab.id === activeTabId
+                              ? "absolute inset-0 flex h-full min-h-0 flex-col"
+                              : "hidden"
+                          }
+                        >
+                          <div className="flex h-full min-h-0 min-w-0 flex-1 flex-col">
+                            <PaneTree
+                              {...sessionPaneProps}
+                              visible={tab.id === activeTabId && !inboxViewOpen}
+                              layout={tab.layout}
+                              sessions={sessions}
+                              editorPanes={[
+                                ...tab.editorPanes,
+                                ...(tab.terminalPanes ?? []),
+                              ]}
+                              dirtyFileIds={dirtyFiles}
+                              fileErrorCounts={fileErrorCounts}
+                              focusedId={
+                                tab.id === activeTabId &&
+                                !inboxViewOpen &&
+                                !tab.diffFocused &&
+                                !projectTerminalFocused
+                                  ? tab.focusedId
+                                  : ""
+                              }
+                              addToChatSessionId={
+                                tab.id === activeTabId ? active?.id : undefined
+                              }
+                              composerFocused={
+                                composerFocused && !projectTerminalFocused
+                              }
+                              onSelectFile={onSelectFileSurface}
+                              onCloseFile={onCloseFile}
+                              onCloseOtherFiles={onCloseOtherFiles}
+                              onReorderFiles={onReorderFiles}
+                              onFileDirtyChange={onFileDirtyChange}
+                              onFileErrorCountChange={onFileErrorCountChange}
+                              onRatio={(splitId, index, ratio) =>
+                                onRatio(tab.id, splitId, index, ratio)
+                              }
+                              editorNavigation={editorNavigation}
+                              onUpdatePlan={onUpdatePlan}
+                              onMovePane={onMovePane}
+                              onTerminalMetaChange={onTerminalMetaChange}
+                            />
+                          </div>
+                        </div>
+                      ))}
                     </div>
-                  ))}
+                  </div>
                 </div>
-              </div>
+              </main>
             </div>
-          </main>
-        </div>
-        {searchViewOpen ? (
-          <SearchView
-            open
-            cwd={sidebarCwd}
-            recents={recents}
-            history={projectHistory}
-            sessions={sessions.filter((session) => !session.inboxAsk)}
-            focusToken={searchViewFocusToken}
-            besideRail={projectRailOpen}
-            onClose={onLeaveSearch}
-            onToggleSidebar={onToggleSidebar}
-            onOpenFile={onOpenFile}
-            onOpenSession={onSelectHistorySession}
-            onOpenProject={onSelectProject}
-          />
-        ) : null}
-        <div className="hidden" aria-hidden>
-          {sessions
-            .filter((session) => session.inboxAsk)
-            .map((session) => {
-              const visible =
-                inboxViewOpen && inboxAskPortal?.sessionId === session.id;
-              return (
-                <SessionSurface
-                  key={session.id}
-                  host={visible ? inboxAskPortal.host : undefined}
-                >
-                  <SessionPane
-                    {...sessionPaneProps}
-                    session={session}
-                    visible={visible}
-                    focused={visible}
-                    inSplit={false}
-                    composerFocused={composerFocused}
-                  />
-                </SessionSurface>
-              );
-            })}
-        </div>
-        {inboxViewOpen ? (
-          <InboxView
-            cwd={sidebarCwd}
-            recents={recents}
-            besideRail={projectRailOpen}
-            onClose={onLeaveInbox}
-            onToggleSidebar={onToggleSidebar}
-            onStart={onStartInboxItem}
-            onAsk={onAskInboxItem}
-            onAskRestart={onRestartInboxAsk}
-            onAskMount={setInboxAskPortal}
-            sessions={inboxRelatedSessions}
-            onOpenSession={onOpenInboxSession}
-            target={inboxTarget}
-            onOpenIntegrations={onOpenInboxIntegrations}
-          />
-        ) : null}
-        {notesViewOpen ? (
-          <NotesView
-            besideRail={projectRailOpen}
-            cwd={projectCwd}
-            recents={recents}
-            onClose={onLeaveNotes}
-            onToggleSidebar={onToggleSidebar}
-          />
-        ) : null}
-        {settingsOpen ? (
-          <SettingsView
-            section={settingsSection}
-            anchor={settingsAnchor}
-            cwd={sidebarCwd}
-            sessions={sidebarHistory}
-            besideRail
-            onClose={onCloseSettings}
-            onOpenSession={onOpenArchivedSession}
-            onArchiveSession={onArchiveHistorySession}
-            onDeleteSession={onDeleteHistorySession}
-            onRestoreProject={onRestoreProject}
-            onDeleteProject={(path) =>
-              onRemoveProject(path, { purgeData: true })
+            {searchViewOpen ? (
+              <SearchView
+                open
+                cwd={sidebarCwd}
+                recents={recents}
+                history={projectHistory}
+                sessions={sessions.filter((session) => !session.inboxAsk)}
+                focusToken={searchViewFocusToken}
+                besideRail={projectRailOpen}
+                onClose={onLeaveSearch}
+                onToggleSidebar={onToggleSidebar}
+                onOpenFile={onOpenFile}
+                onOpenSession={onSelectHistorySession}
+                onOpenProject={onSelectProject}
+              />
+            ) : null}
+            <div className="hidden" aria-hidden>
+              {sessions
+                .filter((session) => session.inboxAsk)
+                .map((session) => {
+                  const visible =
+                    inboxViewOpen && inboxAskPortal?.sessionId === session.id;
+                  return (
+                    <SessionSurface
+                      key={session.id}
+                      host={visible ? inboxAskPortal.host : undefined}
+                    >
+                      <SessionPane
+                        {...sessionPaneProps}
+                        session={session}
+                        visible={visible}
+                        focused={visible}
+                        inSplit={false}
+                        composerFocused={composerFocused}
+                      />
+                    </SessionSurface>
+                  );
+                })}
+            </div>
+            {inboxViewOpen ? (
+              <InboxView
+                cwd={sidebarCwd}
+                recents={recents}
+                besideRail={projectRailOpen}
+                onClose={onLeaveInbox}
+                onToggleSidebar={onToggleSidebar}
+                onStart={onStartInboxItem}
+                onAsk={onAskInboxItem}
+                onAskRestart={onRestartInboxAsk}
+                onAskMount={setInboxAskPortal}
+                sessions={inboxRelatedSessions}
+                onOpenSession={onOpenInboxSession}
+                target={inboxTarget}
+                onOpenIntegrations={onOpenInboxIntegrations}
+              />
+            ) : null}
+            {notesViewOpen ? (
+              <NotesView
+                besideRail={projectRailOpen}
+                cwd={projectCwd}
+                recents={recents}
+                onClose={onLeaveNotes}
+                onToggleSidebar={onToggleSidebar}
+              />
+            ) : null}
+            {settingsOpen ? (
+              <SettingsView
+                section={settingsSection}
+                anchor={settingsAnchor}
+                cwd={sidebarCwd}
+                sessions={sidebarHistory}
+                besideRail
+                onClose={onCloseSettings}
+                onOpenSession={onOpenArchivedSession}
+                onArchiveSession={onArchiveHistorySession}
+                onDeleteSession={onDeleteHistorySession}
+                onRestoreProject={onRestoreProject}
+                onDeleteProject={(path) =>
+                  onRemoveProject(path, { purgeData: true })
+                }
+                onOpenWhatsNew={onOpenWhatsNew}
+              />
+            ) : null}
+            {searchViewOpen ||
+            inboxViewOpen ||
+            notesViewOpen ||
+            settingsOpen ? null : (
+              <UsageFooter
+                providers={usageProviders}
+                session={usageSession}
+                terminals={runningTerminals}
+                terminalOpen={runningTerminalOpen}
+                onToggleTerminal={onToggleRunningTerminal}
+              />
+            )}
+          </div>
+
+          {filePickerOpen ? (
+            <FilePicker
+              open
+              cwd={gitCwd}
+              openPaths={openFilePaths}
+              onOpenFile={onOpenFile}
+              onClose={() => setFilePickerOpen(false)}
+            />
+          ) : null}
+
+          <ApprovalToasts
+            notices={hiddenApprovalToasts}
+            topOffset={
+              12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)
             }
-            onOpenWhatsNew={onOpenWhatsNew}
+            onFocusSession={onOpenApprovalSession}
+            onApproval={onApproval}
           />
-        ) : null}
-        {searchViewOpen ||
-        inboxViewOpen ||
-        notesViewOpen ||
-        settingsOpen ? null : (
-          <UsageFooter
-            providers={usageProviders}
-            session={usageSession}
-            terminals={runningTerminals}
-            terminalOpen={runningTerminalOpen}
-            onToggleTerminal={onToggleRunningTerminal}
+          <ReminderNotices
+            reminders={sessionReminders.due}
+            error={sessionReminders.error}
+            onOpen={sessionReminders.open}
+            onSnooze={sessionReminders.schedule}
+            onDismiss={sessionReminders.cancel}
+            onRetry={sessionReminders.refresh}
+            onOpenSettings={() => openSettings()}
+            onHeightChange={setReminderNoticesHeight}
           />
-        )}
-      </div>
-
-      {filePickerOpen ? (
-        <FilePicker
-          open
-          cwd={gitCwd}
-          openPaths={openFilePaths}
-          onOpenFile={onOpenFile}
-          onClose={() => setFilePickerOpen(false)}
-        />
-      ) : null}
-
-      <ApprovalToasts
-        notices={hiddenApprovalToasts}
-        topOffset={12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)}
-        onFocusSession={onOpenApprovalSession}
-        onApproval={onApproval}
-      />
-      <ReminderNotices
-        reminders={sessionReminders.due}
-        error={sessionReminders.error}
-        onOpen={sessionReminders.open}
-        onSnooze={sessionReminders.schedule}
-        onDismiss={sessionReminders.cancel}
-        onRetry={sessionReminders.refresh}
-        onOpenSettings={() => openSettings()}
-        onHeightChange={setReminderNoticesHeight}
-      />
-      {whatsNewVersion ? (
-        <WhatsNewDialog
-          version={whatsNewVersion}
-          onClose={() => setWhatsNewVersion(null)}
-        />
-      ) : null}
-    </div>
+          {whatsNewVersion ? (
+            <WhatsNewDialog
+              version={whatsNewVersion}
+              onClose={() => setWhatsNewVersion(null)}
+            />
+          ) : null}
+        </div>
+      </OrchestrationWorkers.Provider>
+    </OrchestrationActions.Provider>
   );
 }
-
 function conversationTitle(session: Session): string {
   const title = sessionDisplayTitle(session.title, session.harness);
   return title === "New session" ? "" : title;
diff --git a/src/chrome/Composer.tsx b/src/chrome/Composer.tsx
index d2a0283a..4c811e75 100644
--- a/src/chrome/Composer.tsx
+++ b/src/chrome/Composer.tsx
@@ -9,6 +9,7 @@ import {
   Pencil,
   Play,
   Plus,
+  Share,
   Square,
   StickyNote,
   Trash2,
@@ -66,7 +67,7 @@ import type {
   MessageQueueStatus,
   QueuedMessage,
   RuntimeMode,
-  TurnIntent,
+  ComposerTurnOptions,
 } from "../lib/session";
 import { HARNESS_TITLE, harnessSupportsAttachments } from "../lib/session";
 import type {
@@ -181,7 +182,7 @@ type Props = {
   onSubmit: (
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop?: () => void;
   onCompactContext?: () => boolean;
@@ -467,6 +468,7 @@ export function Composer({
   const [fileDrag, setFileDrag] = useState(false);
   const [plusOpen, setPlusOpen] = useState(false);
   const [planSelected, setPlanSelected] = useState(false);
+  const [orchestrationSelected, setOrchestrationSelected] = useState(false);
   const [slash, setSlash] = useState<SlashToken | null>(null);
   const [skillActive, setSkillActive] = useState(0);
   const [creatingSkill, setCreatingSkill] = useState(false);
@@ -830,7 +832,10 @@ export function Composer({
       syncHasValue(next, attachmentsRef.current);
       setSlash(null);
       setCreatingSkill(false);
-      if (planCommand) setPlanSelected(true);
+      if (planCommand) {
+        setPlanSelected(true);
+        setOrchestrationSelected(false);
+      }
       el.focus();
     },
     [onPlaceInFolder, openSessionFolderPicker, syncHasValue],
@@ -1005,7 +1010,12 @@ export function Composer({
     const files = attachments;
     if (!text && files.length === 0 && !noteCard && !handoffCard) return;
     onSubmit(text, files, {
-      intent: planSelected || command.planning ? "plan" : "default",
+      intent:
+        planSelected || command.planning
+          ? "plan"
+          : orchestrationSelected
+            ? "orchestrate"
+            : "default",
     });
     if (!ref.current) return;
     ref.current.value = "";
@@ -1014,6 +1024,7 @@ export function Composer({
     onDraftChange?.("");
     setAttachments([]);
     setPlanSelected(false);
+    setOrchestrationSelected(false);
     setSessionFolderSelected(false);
     setSessionFolderOpen(false);
     setPlusOpen(false);
@@ -1443,9 +1454,9 @@ export function Composer({
                     <FilePlus className="mt-0.5 size-4 shrink-0" />
                     <span className="min-w-0">
                       <span className="block text-[13px]">Upload file</span>
-                      <span className="block text-[11px] leading-4 text-content/45">
+                      <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
                         {attachmentsSupported
-                          ? "Attach files or images to this message"
+                          ? "Attach files or images"
                           : `${HARNESS_TITLE[harness]} does not support attachments`}
                       </span>
                     </span>
@@ -1456,6 +1467,7 @@ export function Composer({
                     onMouseDown={(e) => e.preventDefault()}
                     onClick={() => {
                       setPlanSelected((selected) => !selected);
+                      setOrchestrationSelected(false);
                       setPlusOpen(false);
                       ref.current?.focus();
                     }}
@@ -1464,17 +1476,64 @@ export function Composer({
                     <AiIdea className="mt-0.5 size-4 shrink-0 text-yellow-300/80" />
                     <span className="min-w-0 flex-1">
                       <span className="block text-[13px]">Plan mode</span>
-                      <span className="block text-[11px] leading-4 text-content/45">
-                        Create a plan to review before building
+                      <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
+                        Review a plan before building
                       </span>
                     </span>
                     {planSelected ? (
                       <Check className="mt-0.5 size-3.5 shrink-0 text-accent" />
                     ) : null}
                   </button>
+                  {!hideTopBar && (
+                    <button
+                      type="button"
+                      aria-pressed={orchestrationSelected}
+                      onMouseDown={(event) => event.preventDefault()}
+                      onClick={() => {
+                        setOrchestrationSelected((selected) => !selected);
+                        setPlanSelected(false);
+                        setPlusOpen(false);
+                        ref.current?.focus();
+                      }}
+                      className="flex w-full items-start gap-2.5 rounded-lg px-2 py-2 text-left text-content hover:bg-content/10"
+                    >
+                      <Share className="mt-0.5 size-4 shrink-0 text-fuchsia-300/65" />
+                      <span className="min-w-0 flex-1">
+                        <span className="flex items-center gap-1.5">
+                          <span className="text-[13px]">Orchestrator</span>
+                          <span className="rounded-full bg-fuchsia-300/10 px-1.5 py-0.5 text-[9px] font-medium leading-none tracking-wide text-fuchsia-200/55 mb-px">
+                            v1
+                          </span>
+                        </span>
+                        <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
+                          Plan and coordinate agent work
+                        </span>
+                      </span>
+                      {orchestrationSelected && (
+                        <Check className="mt-0.5 size-3.5 shrink-0 text-fuchsia-300/80" />
+                      )}
+                    </button>
+                  )}
                 </Popover>
               ) : null}
             </div>
+            {orchestrationSelected && (
+              <button
+                type="button"
+                title="Turn off Orchestrator mode"
+                aria-label="Turn off Orchestrator mode"
+                onMouseDown={(event) => event.preventDefault()}
+                onClick={() => {
+                  setOrchestrationSelected(false);
+                  ref.current?.focus();
+                }}
+                className="flex h-6.5 shrink-0 items-center gap-1 rounded-md bg-fuchsia-400/10 px-1.5 text-[11px] text-fuchsia-200/80 hover:bg-fuchsia-400/15"
+              >
+                <Share className="size-3.5" />
+                Orchestrator
+                <X className="size-3" />
+              </button>
+            )}
             {planSelected ? (
               <button
                 type="button"
diff --git a/src/chrome/OrchestrationActions.ts b/src/chrome/OrchestrationActions.ts
new file mode 100644
index 00000000..05d6ee45
--- /dev/null
+++ b/src/chrome/OrchestrationActions.ts
@@ -0,0 +1,38 @@
+import { createContext } from "react";
+import type { OrchestrationProposal } from "../lib/orchestrationPlan";
+import type { HarnessId } from "../lib/session";
+
+export type OrchestrationWorkerDetail = {
+  sessionId: string;
+  leadId: string;
+  title: string;
+  harness: HarnessId;
+};
+
+/**
+ * The lead's sidebar card lists workers. Approvals still go to the lead, not
+ * to the user; `openDetails` is the one way to watch a worker's transcript.
+ */
+export const OrchestrationWorkers = createContext<{
+  selectedId: string | null;
+  inspect(sessionId: string | null): void;
+  /**
+   * Open this worker beside its lead, for when the card's model line is not
+   * enough. Absent wherever the card renders without a workspace behind it.
+   */
+  openDetails?(worker: OrchestrationWorkerDetail): void;
+}>({ selectedId: null, inspect: () => {} });
+
+// Shared by transcript cards in both ordinary and split session panes.
+export const OrchestrationActions = createContext<{
+  update(
+    leadId: string,
+    blockId: string,
+    proposal: OrchestrationProposal,
+  ): void;
+  confirm(leadId: string, blockId: string): Promise<void>;
+  retry(leadId: string, blockId: string): void;
+  open(sessionId: string): void;
+  /** Open every worker of a run as tabs beside the lead, not sidebar rows. */
+  openAgents?(workers: OrchestrationWorkerDetail[]): void;
+} | null>(null);
diff --git a/src/chrome/OrchestrationFlow.test.ts b/src/chrome/OrchestrationFlow.test.ts
new file mode 100644
index 00000000..f61e3863
--- /dev/null
+++ b/src/chrome/OrchestrationFlow.test.ts
@@ -0,0 +1,747 @@
+// @vitest-environment happy-dom
+import { act, createElement, useState } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn(async () => []),
+  isTauri: () => false,
+  convertFileSrc: (path: string) => path,
+}));
+vi.mock("@tauri-apps/api/event", () => ({ listen: async () => () => {} }));
+vi.mock("@tauri-apps/api/webview", () => ({
+  getCurrentWebview: () => ({ onDragDropEvent: async () => () => {} }),
+}));
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({ onFocusChanged: async () => () => {} }),
+}));
+vi.mock("../lib/harness/availability", () => ({
+  getHarnessAvailabilitySnapshot: () => 0,
+  hasProbedHarnessAvailability: () => true,
+  isHarnessAvailable: () => true,
+  harnessUnavailableHint: () => "",
+  probeHarnessAvailability: async () => {},
+  subscribeHarnessAvailability: () => () => {},
+}));
+vi.mock("../lib/harness/registry", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../lib/harness/registry")>()),
+  refreshHarnessCatalogs: async () => {},
+  isLiveHarness: () => true,
+}));
+vi.mock("./ModelPicker", () => ({ ModelPicker: () => null }));
+vi.mock("./SessionReview", () => ({
+  SessionReview: ({ undoLocked }: { undoLocked: boolean }) =>
+    createElement("div", { "data-review-undo-locked": String(undoLocked) }),
+}));
+vi.mock("../lib/orchestration", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../lib/orchestration")>()),
+  orchestrator: {
+    subscribe: () => () => {},
+    snapshot: () => emptyRuns,
+    hydrate: async () => {},
+    waitingFor: () => undefined,
+  },
+}));
+
+import { Composer } from "./Composer";
+import { AgentTranscript } from "../surfaces/AgentTranscript";
+import { SessionPane } from "../surfaces/SessionPane";
+import {
+  OrchestrationActions,
+  OrchestrationWorkers,
+} from "./OrchestrationActions";
+import { newSession } from "../lib/session";
+import type { OrchestrationRun, OrchestrationTask } from "../lib/orchestration";
+import type { OrchestrationSummary } from "../lib/orchestrationSummary";
+import { OrchestrationSidebarAgents } from "./OrchestrationSidebarAgents";
+import {
+  modelsFor,
+  setHarnessModels,
+  resetHarnessModelOverlays,
+} from "../lib/models";
+import type { OrchestrationProposal } from "../lib/orchestrationPlan";
+import { invoke } from "@tauri-apps/api/core";
+
+const emptyRuns: OrchestrationRun[] = [];
+let container: HTMLDivElement;
+let root: Root;
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  localStorage.clear();
+  setHarnessModels("codex", [
+    { id: "codex:one", harness: "codex", name: "Worker One" },
+    { id: "codex:two", harness: "codex", name: "Worker Two" },
+  ]);
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  resetHarnessModelOverlays();
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+  emptyRuns.length = 0;
+});
+const button = (text: string) =>
+  [...document.querySelectorAll("button")].find((element) =>
+    element.textContent?.includes(text),
+  )!;
+async function click(element: Element) {
+  expect(element).toBeTruthy();
+  await act(async () => {
+    (element as HTMLElement).click();
+  });
+}
+async function press(element: Element, key: string) {
+  await act(async () => {
+    element.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true }));
+  });
+}
+async function input(
+  element: HTMLInputElement | HTMLTextAreaElement,
+  value: string,
+) {
+  const prototype =
+    element instanceof HTMLTextAreaElement
+      ? HTMLTextAreaElement.prototype
+      : HTMLInputElement.prototype;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(prototype, "value")!.set!.call(
+      element,
+      value,
+    );
+    element.dispatchEvent(new Event("input", { bubbles: true }));
+  });
+}
+
+describe("orchestration composer and card", () => {
+  it("toggles a badge through the plus menu and submits without a team setup or execution", async () => {
+    const model = modelsFor("codex")[0];
+    const submit = vi.fn();
+    await act(async () =>
+      root.render(
+        createElement(Composer, {
+          focused: false,
+          harness: "codex",
+          model: model.id,
+          runtimeMode: "supervised",
+          cwd: "/repo",
+          executionCwd: "/repo",
+          sessionId: "lead",
+          initialDraft: "Build settings",
+          hideProjectPicker: true,
+          hideBranchPicker: true,
+          onFocus: () => {},
+          onCwdChange: () => {},
+          onModelChange: () => {},
+          onRuntimeModeChange: () => {},
+          onSubmit: submit,
+        }),
+      ),
+    );
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    expect(button("Plan mode")).toBeTruthy();
+    await click(button("Orchestrator"));
+    expect(document.querySelector('[role="dialog"]')).toBeNull();
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).not.toBeNull();
+    await click(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]')!,
+    );
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).toBeNull();
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    await click(button("Plan mode"));
+    expect(
+      document.querySelector('[title="Turn off Plan mode"]'),
+    ).not.toBeNull();
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    await click(button("Orchestrator"));
+    expect(document.querySelector('[title="Turn off Plan mode"]')).toBeNull();
+    const textarea = container.querySelector("textarea")!;
+    await act(async () =>
+      textarea.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      ),
+    );
+    expect(submit).toHaveBeenCalledWith("Build settings", [], {
+      intent: "orchestrate",
+    });
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).toBeNull();
+    expect(
+      vi
+        .mocked(invoke)
+        .mock.calls.some(([command]) => command === "control_enable"),
+    ).toBe(false);
+  });
+  it("lets the user change an assignment's model and waits for explicit confirmation", async () => {
+    const choices = [
+      { harness: "codex" as const, model: "codex:one", name: "Worker One" },
+      { harness: "claude" as const, model: "claude:two", name: "Worker Two" },
+    ];
+    const initial: OrchestrationProposal = {
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      request: "Build",
+      author: choices[0],
+      settings: { choices, maxWorkers: 2 },
+      status: "ready",
+      title: "Build settings",
+      summary: "Split UI and persistence",
+      tasks: [
+        {
+          id: "ui",
+          title: "Settings UI",
+          prompt: "Build the form",
+          harness: "codex",
+          model: "codex:one",
+          files: ["src/settings"],
+          dependsOn: [],
+        },
+      ],
+    };
+    const confirm = vi.fn(async (_proposal: OrchestrationProposal) => {});
+    function Card() {
+      const [proposal, setProposal] = useState(initial);
+      return createElement(
+        OrchestrationActions.Provider,
+        {
+          value: {
+            update: (_id, _block, edited) => setProposal(edited),
+            confirm: async () => confirm(proposal),
+            retry: () => {},
+            open: () => {},
+          },
+        },
+        createElement(AgentTranscript, {
+          blocks: [
+            {
+              id: "card",
+              role: "plan",
+              text: "Readable plan",
+              orchestration: proposal,
+            },
+          ],
+        }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    expect(container.textContent).toContain("Settings UI");
+    expect(
+      container.querySelector("[data-orchestration-review]"),
+    ).not.toBeNull();
+    expect(container.textContent).not.toContain("Readable plan");
+    // The lead's summary stays out of the card; the task rows carry the plan.
+    expect(container.textContent).not.toContain("Split UI and persistence");
+    expect(confirm).not.toHaveBeenCalled();
+    await click(
+      document.querySelector('[aria-label="Model for Settings UI"]')!,
+    );
+    expect(document.activeElement).toBe(
+      document.querySelector('[aria-label="Search assignment models"]'),
+    );
+    // Marks the surface as a picker, which is what keeps the composer from
+    // pulling focus straight back out of the search field.
+    expect(
+      document
+        .querySelector('[aria-label="Search assignment models"]')
+        ?.closest("[data-model-picker]"),
+    ).not.toBeNull();
+    await input(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Claude",
+    );
+    expect(
+      document.querySelector("[data-popover-side]")?.textContent,
+    ).not.toContain("Worker One");
+    // Arrows walk the list from the search field and Enter takes the highlight.
+    await input(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Worker",
+    );
+    await press(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "ArrowDown",
+    );
+    await press(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Enter",
+    );
+    expect(container.textContent).toContain("Worker Two");
+    // The pointer reaches the same rows.
+    await click(
+      document.querySelector('[aria-label="Model for Settings UI"]')!,
+    );
+    await click(
+      [...document.querySelectorAll('[role="option"]')].find((row) =>
+        row.textContent?.includes("Worker Two"),
+      )!,
+    );
+    expect(container.textContent).toContain("Worker Two");
+    expect(container.querySelector("textarea")).toBeNull();
+    await click(
+      document.querySelector('[aria-label="Details for Settings UI"]')!,
+    );
+    await input(
+      document.querySelector('[aria-label="Instructions for task 1"]')!,
+      "Build the accessible form and check keyboard navigation",
+    );
+    await click(
+      [
+        ...document.querySelectorAll('[aria-label="Parallel workers"] button'),
+      ].find((option) => option.textContent === "1")!,
+    );
+    expect(confirm).not.toHaveBeenCalled();
+    await click(button("Confirm & start"));
+    expect(confirm).toHaveBeenCalledWith(
+      expect.objectContaining({
+        settings: expect.objectContaining({ maxWorkers: 1 }),
+        tasks: [
+          expect.objectContaining({
+            harness: "claude",
+            model: "claude:two",
+            prompt: "Build the accessible form and check keyboard navigation",
+          }),
+        ],
+      }),
+    );
+  });
+  it("never offers confirmation for a proposal that is still being generated", async () => {
+    const proposal: OrchestrationProposal = {
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      request: "Build",
+      author: { harness: "codex", model: "test", name: "Lead" },
+      settings: { choices: [], maxWorkers: 2 },
+      status: "planning",
+      title: "Planning",
+      summary: "",
+      tasks: [],
+    };
+    await act(async () =>
+      root.render(
+        createElement(AgentTranscript, {
+          busy: true,
+          blocks: [
+            {
+              id: "draft",
+              role: "plan",
+              text: "",
+              orchestration: proposal,
+            },
+          ],
+        }),
+      ),
+    );
+    expect(container.querySelector("[data-orchestration-review]")).toBeNull();
+    expect(container.textContent).not.toContain("Confirm & start");
+  });
+  it("opens worker panes from View agents instead of the sidebar", async () => {
+    const open = vi.fn();
+    const openAgents = vi.fn();
+    const task: OrchestrationTask = {
+      id: "engine",
+      sessionId: "worker-a",
+      title: "Audit engine",
+      harness: "codex",
+      model: "codex:two",
+      prompt: "Review the engine",
+      files: [],
+      scopes: [],
+      dependsOn: [],
+      status: "cancelled",
+      accepted: false,
+      delivered: false,
+      result: "",
+    };
+    emptyRuns.push({
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      status: "stopped",
+      allowedHarnesses: ["codex", "cursor"],
+      proposalId: "card",
+      maxWorkers: 2,
+      cli: "monocode",
+      tasks: [
+        task,
+        {
+          ...task,
+          id: "ui",
+          sessionId: "worker-b",
+          title: "Audit UI",
+          harness: "cursor",
+          model: "cursor:composer-2.5",
+          status: "completed",
+        },
+      ],
+      continuations: 0,
+      requests: {},
+    });
+    await act(async () =>
+      root.render(
+        createElement(
+          OrchestrationActions.Provider,
+          {
+            value: {
+              update: () => {},
+              confirm: async () => {},
+              retry: () => {},
+              open,
+              openAgents,
+            },
+          },
+          createElement(AgentTranscript, {
+            blocks: [
+              {
+                id: "card",
+                role: "plan",
+                text: "",
+                orchestration: {
+                  version: 1,
+                  leadId: "lead",
+                  cwd: "/repo",
+                  request: "Review",
+                  author: {
+                    harness: "codex",
+                    model: "codex:one",
+                    name: "Lead",
+                  },
+                  settings: { choices: [], maxWorkers: 2 },
+                  status: "approved",
+                  title: "Review local-agent orchestration branch",
+                  summary: "",
+                  tasks: [
+                    {
+                      id: "engine",
+                      title: "Audit engine",
+                      prompt: "Review the engine",
+                      harness: "codex",
+                      model: "codex:two",
+                      files: [],
+                      dependsOn: [],
+                    },
+                    {
+                      id: "ui",
+                      title: "Audit UI",
+                      prompt: "Review the UI",
+                      harness: "cursor",
+                      model: "cursor:composer-2.5",
+                      files: [],
+                      dependsOn: [],
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        ),
+      ),
+    );
+    await click(button("View agents"));
+    expect(open).not.toHaveBeenCalled();
+    expect(openAgents).toHaveBeenCalledWith([
+      {
+        sessionId: "worker-a",
+        leadId: "lead",
+        title: "Audit engine",
+        harness: "codex",
+      },
+      {
+        sessionId: "worker-b",
+        leadId: "lead",
+        title: "Audit UI",
+        harness: "cursor",
+      },
+    ]);
+  });
+  it("gives the lead's transcript and composer the whole pane", async () => {
+    const lead = {
+      ...newSession("codex", "/repo", "codex:one"),
+      id: "lead",
+      blocks: [
+        { id: "user", role: "user" as const, text: "Build the feature" },
+        {
+          id: "answer",
+          role: "assistant" as const,
+          text: "I am coordinating the work.",
+        },
+      ],
+    };
+    const task: OrchestrationTask = {
+      id: "task",
+      sessionId: "worker",
+      title: "UI worker",
+      harness: "codex",
+      model: "codex:two",
+      prompt: "Build UI",
+      files: ["ui"],
+      scopes: ["/repo/ui"],
+      dependsOn: [],
+      status: "running",
+      accepted: false,
+      delivered: false,
+      result: "",
+    };
+    emptyRuns.push({
+      version: 1,
+      leadId: lead.id,
+      cwd: lead.cwd,
+      status: "active",
+      allowedHarnesses: ["codex"],
+      maxWorkers: 2,
+      cli: "monocode",
+      tasks: [
+        task,
+        {
+          ...task,
+          id: "second-task",
+          sessionId: "second",
+          title: "Check worker",
+        },
+      ],
+      continuations: 0,
+      requests: {},
+    });
+    const submit = vi.fn();
+    const approve = vi.fn();
+    const reply = vi.fn();
+    const open = vi.fn();
+    const noop = () => {};
+    function LeadPane({ id = lead.id, undoLocked = false } = {}) {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationActions.Provider,
+        { value: { update: noop, confirm: async () => {}, retry: noop, open } },
+        createElement(
+          OrchestrationWorkers.Provider,
+          { value: { selectedId, inspect } },
+          createElement(SessionPane, {
+            session: { ...lead, id },
+            reviewUndoLocked: undoLocked,
+            visible: true,
+            focused: true,
+            inSplit: false,
+            composerFocused: true,
+            recents: [],
+            onFocus: noop,
+            onClose: noop,
+            onCwdChange: noop,
+            onBranchChange: noop,
+            onModelChange: noop,
+            onModelSettingsChange: noop,
+            onRuntimeModeChange: noop,
+            onSubmit: submit,
+            onStop: noop,
+            onCompactContext: () => false,
+            onPlaceSessionInFolder: noop,
+            onDeleteQueuedMessage: noop,
+            onEditQueuedMessage: noop,
+            onQueuedMessageEditingChange: noop,
+            onSteerQueuedMessage: noop,
+            onResumeQueue: noop,
+            onApproval: approve,
+            onQuestionReply: reply,
+            onOpenFile: noop,
+            onOpenDiff: noop,
+            onOpenPlan: noop,
+            onBuildPlan: noop,
+            onNewTerminal: noop,
+          }),
+        ),
+      );
+    }
+    await act(async () => root.render(createElement(LeadPane)));
+    // Agents live on the sidebar card now; nothing narrows the lead's pane.
+    expect(container.querySelector("[data-orchestration-agents]")).toBeNull();
+    expect(container.textContent).toContain("I am coordinating the work.");
+    expect(container.textContent).not.toContain("UI worker");
+    expect(open).not.toHaveBeenCalled();
+    const composer = container.querySelector("textarea")!;
+    await input(composer, "Ask the UI worker to check keyboard navigation.");
+    await act(async () => {
+      composer.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+    });
+    expect(submit).toHaveBeenCalledWith(
+      "lead",
+      "Ask the UI worker to check keyboard navigation.",
+      [],
+      { intent: "default" },
+    );
+    for (const status of ["active", "paused", "finished", "stopped"] as const) {
+      emptyRuns[0] = { ...emptyRuns[0], status };
+      for (const id of ["lead", "worker", "unrelated"]) {
+        await act(async () => root.render(createElement(LeadPane, { id })));
+        expect(
+          container
+            .querySelector("[data-review-undo-locked]")
+            ?.getAttribute("data-review-undo-locked"),
+        ).toBe(
+          String(
+            id !== "unrelated" && (status === "active" || status === "paused"),
+          ),
+        );
+      }
+    }
+    await act(async () =>
+      root.render(createElement(LeadPane, { undoLocked: true })),
+    );
+    expect(
+      container
+        .querySelector("[data-review-undo-locked]")
+        ?.getAttribute("data-review-undo-locked"),
+    ).toBe("true");
+  });
+
+  it("shows a blocked agent as the lead's to answer, not the user's", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "UI worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+          needsInput: true,
+        },
+        {
+          sessionId: "second",
+          title: "Check worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+          needsInput: true,
+        },
+      ],
+    };
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationWorkers.Provider,
+        { value: { selectedId, inspect } },
+        createElement(OrchestrationSidebarAgents, { leadId: "lead", summary }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    expect(container.textContent).toContain("UI worker");
+    // A blocked agent expands itself so its model is visible, but the
+    // approval still belongs to the lead, not to this card.
+    expect(
+      container.querySelector(
+        '[data-orchestration-agent="worker"] [aria-expanded="true"]',
+      ),
+    ).not.toBeNull();
+    expect(container.textContent).toContain("Worker Two");
+    expect(button("Allow")).toBeUndefined();
+    expect(button("Deny")).toBeUndefined();
+    expect(container.textContent).not.toContain("Which check should I run?");
+  });
+
+  it("inspects an agent without taking the card's click or its tab", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "UI worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+        },
+      ],
+    };
+    const selectCard = vi.fn();
+    const openDetails = vi.fn();
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        "div",
+        { onClick: selectCard },
+        createElement(
+          OrchestrationWorkers.Provider,
+          { value: { selectedId, inspect, openDetails } },
+          createElement(OrchestrationSidebarAgents, {
+            leadId: "lead",
+            summary,
+          }),
+        ),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    await click(
+      container.querySelector('[aria-label="Agent details: UI worker"]')!,
+    );
+    // Expanding a row is not a request to open the lead's tab.
+    expect(selectCard).not.toHaveBeenCalled();
+    await click(button("See details"));
+    expect(openDetails).toHaveBeenCalledWith({
+      sessionId: "worker",
+      leadId: "lead",
+      title: "UI worker",
+      harness: "codex",
+    });
+    expect(selectCard).not.toHaveBeenCalled();
+  });
+
+  it("expands any number of agents at once", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: ["one", "two", "three"].map((id) => ({
+        sessionId: id,
+        title: `Agent ${id}`,
+        harness: "codex" as const,
+        model: "codex:two",
+        status: "running" as const,
+      })),
+    };
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationWorkers.Provider,
+        { value: { selectedId, inspect } },
+        createElement(OrchestrationSidebarAgents, { leadId: "lead", summary }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    const row = (id: string) =>
+      container.querySelector<HTMLElement>(
+        `[data-orchestration-agent="${id}"] button`,
+      )!;
+    const openIds = () =>
+      [...container.querySelectorAll("[data-orchestration-agent]")]
+        .filter((entry) => entry.querySelector("[aria-expanded=true]"))
+        .map((entry) => entry.getAttribute("data-orchestration-agent"));
+    await click(row("one"));
+    await click(row("three"));
+    expect(openIds()).toEqual(["one", "three"]);
+    // Collapsing one leaves the other where it was.
+    await click(row("one"));
+    expect(openIds()).toEqual(["three"]);
+  });
+});
diff --git a/src/chrome/OrchestrationPreview.tsx b/src/chrome/OrchestrationPreview.tsx
new file mode 100644
index 00000000..ebd5ae3a
--- /dev/null
+++ b/src/chrome/OrchestrationPreview.tsx
@@ -0,0 +1,610 @@
+import {
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  type KeyboardEvent as ReactKeyboardEvent,
+} from "react";
+import { HARNESS_TITLE, type Block } from "../lib/session";
+import type {
+  OrchestrationChoice,
+  ProposedTask,
+} from "../lib/orchestrationPlan";
+import { orchestrator } from "../lib/orchestration";
+import { resizeComposer } from "../lib/composerResize";
+import { useLockOverscroll } from "../hooks/useLockOverscroll";
+import { OrchestrationActions } from "./OrchestrationActions";
+import { HarnessIcon } from "./HarnessIcon";
+import { Popover } from "./Popover";
+import {
+  Check,
+  ChevronDown,
+  ChevronRight,
+  CircleDashed,
+  CircleHelp,
+  MessageMultiple,
+  Play,
+  Search,
+} from "./icons";
+
+function AssignmentModel({
+  task,
+  choices,
+  onChange,
+}: {
+  task: ProposedTask;
+  choices: OrchestrationChoice[];
+  onChange(choice: OrchestrationChoice): void;
+}) {
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [active, setActive] = useState(0);
+  const anchor = useRef<HTMLButtonElement>(null);
+  const search = useRef<HTMLInputElement>(null);
+  const activeRef = useRef<HTMLButtonElement>(null);
+  const listOverscroll = useLockOverscroll<HTMLDivElement>();
+  const selected = choices.find(
+    (choice) => choice.harness === task.harness && choice.model === task.model,
+  );
+  const matches = choices.filter((choice) =>
+    `${choice.name} ${choice.model} ${HARNESS_TITLE[choice.harness]}`
+      .toLowerCase()
+      .includes(query.trim().toLowerCase()),
+  );
+  // Two things fought this field for focus. The composer takes focus back
+  // unless a picker surface is in the DOM, which `data-model-picker` below
+  // now declares; and the popover measures itself with `visibility: hidden`
+  // on its first pass, where nothing can be focused. Placement flushes in a
+  // layout effect ahead of this one, so focus now for the pass that is
+  // already on screen and again next frame, once placement has landed.
+  // Re-focusing a focused field is a no-op.
+  useEffect(() => {
+    if (!open) return;
+    search.current?.focus({ preventScroll: true });
+    const frame = requestAnimationFrame(() =>
+      search.current?.focus({ preventScroll: true }),
+    );
+    return () => cancelAnimationFrame(frame);
+  }, [open]);
+  useEffect(() => {
+    activeRef.current?.scrollIntoView({ block: "nearest" });
+  }, [active]);
+  const pick = (choice: OrchestrationChoice) => {
+    onChange(choice);
+    setOpen(false);
+    anchor.current?.focus();
+  };
+  // Arrows walk the list from the search field, the way the app's other
+  // pickers work. The keys stop here so the transcript underneath does not
+  // scroll along with the highlight.
+  const onSearchKey = (event: ReactKeyboardEvent<HTMLInputElement>) => {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      event.stopPropagation();
+      if (!matches.length) return;
+      const step = event.key === "ArrowDown" ? 1 : -1;
+      setActive((index) =>
+        Math.min(matches.length - 1, Math.max(0, index + step)),
+      );
+      return;
+    }
+    if (event.key === "Enter") {
+      event.preventDefault();
+      event.stopPropagation();
+      const choice = matches[active];
+      if (choice) pick(choice);
+    }
+  };
+  return (
+    <div className="relative min-w-0">
+      <button
+        type="button"
+        ref={anchor}
+        aria-label={`Model for ${task.title}`}
+        aria-expanded={open}
+        onClick={() => {
+          setQuery("");
+          setActive(selected ? choices.indexOf(selected) : 0);
+          setOpen(!open);
+        }}
+        className="flex h-7 max-w-full items-center gap-1.5 rounded-md bg-content/5 px-2 text-[11px] text-content/60 hover:bg-content/10 hover:text-content"
+      >
+        <HarnessIcon harness={task.harness} className="size-3.5 shrink-0" />
+        <span className="truncate">
+          {selected?.name ?? task.model} · {HARNESS_TITLE[task.harness]}
+        </span>
+        <ChevronDown className="size-3 shrink-0" />
+      </button>
+      {open && (
+        <Popover
+          anchor={anchor}
+          side="bottom"
+          align="start"
+          width={260}
+          maxHeight={320}
+          onDismiss={() => setOpen(false)}
+          data-model-picker
+          className="flex flex-col overflow-hidden"
+        >
+          <label className="flex shrink-0 items-center gap-2 border-b border-content/10 px-3 py-2.5 text-content/50">
+            <Search className="size-3.5 shrink-0" strokeWidth={1.75} />
+            <input
+              ref={search}
+              type="text"
+              aria-label="Search assignment models"
+              placeholder="Search models or harnesses…"
+              spellCheck={false}
+              autoComplete="off"
+              value={query}
+              onChange={(event) => {
+                setQuery(event.target.value);
+                setActive(0);
+              }}
+              onKeyDown={onSearchKey}
+              className="min-w-0 flex-1 bg-transparent text-[13px] text-content outline-none placeholder:text-content/40"
+            />
+          </label>
+          <div
+            ref={listOverscroll}
+            role="listbox"
+            aria-label="Assignment models"
+            className="min-h-0 flex-1 overflow-y-auto overscroll-none p-1"
+          >
+            {matches.map((choice, index) => (
+              <button
+                key={`${choice.harness}:${choice.model}`}
+                ref={index === active ? activeRef : undefined}
+                type="button"
+                role="option"
+                aria-selected={choice === selected}
+                onMouseDown={(event) => event.preventDefault()}
+                onMouseEnter={() => setActive(index)}
+                onClick={() => pick(choice)}
+                className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left ${
+                  index === active ? "bg-content/10" : ""
+                }`}
+              >
+                <HarnessIcon
+                  harness={choice.harness}
+                  className="size-4 shrink-0"
+                />
+                <span className="min-w-0 flex-1">
+                  <span className="block truncate text-[13px] leading-tight text-content">
+                    {choice.name}
+                  </span>
+                  <span className="mt-0.5 block truncate text-[11px] leading-tight text-content/45">
+                    {HARNESS_TITLE[choice.harness]}
+                  </span>
+                </span>
+                {choice === selected && (
+                  <Check
+                    className="size-3.5 shrink-0 text-content/55"
+                    strokeWidth={2}
+                  />
+                )}
+              </button>
+            ))}
+            {!matches.length && (
+              <p className="px-2 py-3 text-[12px] text-content/45">
+                No matching models
+              </p>
+            )}
+          </div>
+        </Popover>
+      )}
+    </div>
+  );
+}
+
+function WorkerHelp() {
+  const [hovered, setHovered] = useState(false);
+  const [open, setOpen] = useState(false);
+  const anchor = useRef<HTMLButtonElement>(null);
+  return (
+    <>
+      <button
+        type="button"
+        ref={anchor}
+        aria-label="What parallel workers means"
+        aria-expanded={open}
+        onClick={() => setOpen((value) => !value)}
+        onMouseEnter={() => setHovered(true)}
+        onMouseLeave={() => setHovered(false)}
+        onFocus={() => setHovered(true)}
+        onBlur={() => setHovered(false)}
+        className="grid size-4 shrink-0 place-items-center rounded-full text-content/35 hover:text-content/70"
+      >
+        <CircleHelp className="size-3.5" strokeWidth={1.75} />
+      </button>
+      {(hovered || open) && (
+        <Popover
+          anchor={anchor}
+          side="top"
+          align="start"
+          width={250}
+          onDismiss={() => setOpen(false)}
+          className={`px-2.5 py-2 ${open ? "" : "pointer-events-none"}`}
+        >
+          <div className="text-[12px] leading-4 text-content">
+            How many workers run at once
+          </div>
+          <div className="mt-1 text-[11px] leading-4 text-content/50">
+            The rest of the tasks wait their turn, and a task that depends on
+            another waits for it either way. Every worker edits this same
+            project folder, so a lower number means fewer changes landing in it
+            at the same time.
+          </div>
+        </Popover>
+      )}
+    </>
+  );
+}
+
+function InstructionsField({
+  label,
+  value,
+  className,
+  onChange,
+}: {
+  label: string;
+  value: string;
+  className: string;
+  onChange(value: string): void;
+}) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  const lockOverscroll = useLockOverscroll<HTMLTextAreaElement>();
+  // The same growth the composer uses: fit the text, stop at `max-h-40` and
+  // scroll from there. The value is controlled, so one layout effect covers
+  // typing and edits that arrive from the lead alike.
+  useLayoutEffect(() => {
+    if (ref.current) resizeComposer(ref.current);
+  }, [value]);
+  return (
+    <textarea
+      ref={(el) => {
+        ref.current = el;
+        lockOverscroll(el);
+      }}
+      rows={1}
+      aria-label={label}
+      className={`${className} max-h-40 resize-none overscroll-none`}
+      value={value}
+      onChange={(event) => onChange(event.target.value)}
+    />
+  );
+}
+
+export function OrchestrationPreview({
+  block,
+  busy,
+}: {
+  block: Block;
+  busy?: boolean;
+}) {
+  const actions = useContext(OrchestrationActions);
+  const runs = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const proposal = block.orchestration!;
+  const run = runs.find(
+    (entry) =>
+      entry.leadId === proposal.leadId && entry.proposalId === block.id,
+  );
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState<string>();
+  const [expanded, setExpanded] = useState<string[]>([]);
+  const [showAll, setShowAll] = useState(false);
+  useEffect(() => {
+    if (actions)
+      void orchestrator
+        .hydrate(proposal.leadId)
+        .catch((reason: unknown) => setError(String(reason)));
+  }, [actions, proposal.leadId]);
+  const editable =
+    proposal.status === "ready" && !run && !pending && !busy && !!actions;
+  const planning = proposal.status === "planning";
+  const starting = pending || proposal.status === "starting";
+  const visible = showAll ? proposal.tasks : proposal.tasks.slice(0, 3);
+  const perform = async (fn: () => Promise<void>) => {
+    setPending(true);
+    setError(undefined);
+    try {
+      await fn();
+    } catch (reason) {
+      setError(reason instanceof Error ? reason.message : String(reason));
+    } finally {
+      setPending(false);
+    }
+  };
+  const change = (id: string, patch: Partial<ProposedTask>) => {
+    setError(undefined);
+    actions?.update(proposal.leadId, block.id, {
+      ...proposal,
+      tasks: proposal.tasks.map((task) =>
+        task.id === id ? { ...task, ...patch } : task,
+      ),
+    });
+  };
+  const secondary =
+    "flex h-7 items-center gap-1.5 rounded-md px-2.5 text-[11px] text-content/50 hover:bg-content/8 hover:text-content disabled:opacity-35";
+  const field =
+    "w-full rounded-md border border-content/12 bg-background-base/40 px-2 py-1.5 text-[12px] leading-5 text-content outline-none placeholder:text-content/35 focus:border-content/30";
+  const fieldLabel = "mb-1 block text-[11px] leading-tight text-content/45";
+  return (
+    <div
+      className="mb-2 overflow-hidden rounded-xl border border-content/10 bg-content/3 font-sans"
+      aria-label="Orchestration proposal"
+      data-orchestration-review
+    >
+      <div className="flex min-w-0 flex-wrap items-center gap-2.5 px-3 py-2.5">
+        <span className="grid size-8 shrink-0 place-items-center rounded-lg bg-content/8 text-content/55">
+          {planning || proposal.status === "starting" ? (
+            <CircleDashed className="size-4 animate-spin" />
+          ) : (
+            <MessageMultiple className="size-4" strokeWidth={1.75} />
+          )}
+        </span>
+        <div className="min-w-0 flex-1">
+          <div className="truncate text-[13px] font-medium leading-tight text-content/90">
+            {planning ? "Planning assignments…" : proposal.title}
+          </div>
+          <div className="mt-1 flex items-center gap-1.5 text-[11px] leading-tight text-content/45">
+            <HarnessIcon
+              harness={proposal.author.harness}
+              className="size-3 shrink-0"
+            />
+            <span
+              className="truncate"
+              title={HARNESS_TITLE[proposal.author.harness]}
+            >
+              Lead · {proposal.author.name}
+            </span>
+            {!!proposal.tasks.length && (
+              <span className="shrink-0">
+                · {proposal.tasks.length}{" "}
+                {proposal.tasks.length === 1 ? "task" : "tasks"}
+              </span>
+            )}
+          </div>
+        </div>
+        <div className="ml-auto flex shrink-0 items-center gap-0.5">
+          {!run && proposal.status === "invalid" && (
+            <button
+              className={secondary}
+              disabled={busy || !actions}
+              onClick={() => actions?.retry(proposal.leadId, block.id)}
+            >
+              Try again
+            </button>
+          )}
+          {!run && ["ready", "starting"].includes(proposal.status) && (
+            <button
+              className="flex h-7 items-center gap-1.5 rounded-md bg-content px-2.5 text-[11px] font-medium text-background-base hover:bg-content/80 disabled:opacity-40"
+              disabled={!editable}
+              onClick={() =>
+                void perform(() => actions!.confirm(proposal.leadId, block.id))
+              }
+            >
+              <Play className="size-3" strokeWidth={1.75} />
+              {starting ? "Starting…" : "Confirm & start"}
+            </button>
+          )}
+          {run && (
+            <button
+              className={secondary}
+              onClick={() =>
+                actions?.openAgents?.(
+                  run.tasks.map((task) => ({
+                    sessionId: task.sessionId,
+                    leadId: run.leadId,
+                    title: task.title,
+                    harness: task.harness,
+                  })),
+                )
+              }
+            >
+              View agents
+            </button>
+          )}
+        </div>
+      </div>
+      {planning && (
+        <p className="px-3 pb-2.5 text-[12px] leading-5 text-content/50">
+          {proposal.settings.choices.length
+            ? "Your lead is choosing tasks and worker models. Review the assignments here before starting."
+            : "Checking available harnesses and models…"}
+        </p>
+      )}
+      {!!proposal.tasks.length && (
+        <ul className="border-t border-content/10 py-1">
+          {visible.map((task) => {
+            const index = proposal.tasks.indexOf(task);
+            const open = expanded.includes(task.id);
+            return (
+              <li key={task.id}>
+                <div className="flex min-h-9 min-w-0 flex-wrap items-center gap-x-2 gap-y-1 px-3 py-1 hover:bg-content/5">
+                  <button
+                    type="button"
+                    aria-label={`Details for ${task.title}`}
+                    aria-expanded={open}
+                    onClick={() =>
+                      setExpanded((prev) =>
+                        open
+                          ? prev.filter((id) => id !== task.id)
+                          : [...prev, task.id],
+                      )
+                    }
+                    className="flex min-w-0 flex-1 items-center gap-2 py-1 text-left text-content/65 hover:text-content"
+                  >
+                    {open ? (
+                      <ChevronDown className="size-3.5 shrink-0" />
+                    ) : (
+                      <ChevronRight className="size-3.5 shrink-0" />
+                    )}
+                    <span className="truncate text-[12px]" title={task.title}>
+                      {task.title}
+                    </span>
+                  </button>
+                  <div className="max-w-[60%] min-w-0">
+                    {editable ? (
+                      <AssignmentModel
+                        task={task}
+                        choices={proposal.settings.choices}
+                        onChange={(choice) =>
+                          change(task.id, {
+                            harness: choice.harness,
+                            model: choice.model,
+                          })
+                        }
+                      />
+                    ) : (
+                      <span
+                        className="flex min-w-0 items-center gap-1.5 text-[11px] text-content/50"
+                        title={HARNESS_TITLE[task.harness]}
+                      >
+                        <HarnessIcon
+                          harness={task.harness}
+                          className="size-3 shrink-0"
+                        />
+                        <span className="truncate">
+                          {proposal.settings.choices.find(
+                            (choice) =>
+                              choice.harness === task.harness &&
+                              choice.model === task.model,
+                          )?.name ?? task.model}
+                        </span>
+                      </span>
+                    )}
+                  </div>
+                </div>
+                {open && (
+                  <div className="space-y-2.5 px-3 pb-3 pl-8 text-[11px] leading-4 text-content/45">
+                    {editable ? (
+                      <>
+                        <label className="block">
+                          <span className={fieldLabel}>Task</span>
+                          <input
+                            aria-label={`Title for task ${index + 1}`}
+                            className={field}
+                            value={task.title}
+                            onChange={(event) =>
+                              change(task.id, { title: event.target.value })
+                            }
+                          />
+                        </label>
+                        <label className="block">
+                          <span className={fieldLabel}>Instructions</span>
+                          <InstructionsField
+                            label={`Instructions for task ${index + 1}`}
+                            value={task.prompt}
+                            className={field}
+                            onChange={(prompt) => change(task.id, { prompt })}
+                          />
+                        </label>
+                      </>
+                    ) : (
+                      <p className="whitespace-pre-wrap text-[12px] leading-5 text-content/60">
+                        {task.prompt}
+                      </p>
+                    )}
+                    {!!task.dependsOn.length && (
+                      <p>
+                        After ·{" "}
+                        {task.dependsOn
+                          .map(
+                            (id) =>
+                              proposal.tasks.find((entry) => entry.id === id)
+                                ?.title ?? id,
+                          )
+                          .join(", ")}
+                      </p>
+                    )}
+                  </div>
+                )}
+              </li>
+            );
+          })}
+        </ul>
+      )}
+      {proposal.tasks.length > 3 && (
+        <button
+          type="button"
+          aria-expanded={showAll}
+          onClick={() => setShowAll(!showAll)}
+          className="flex h-8 w-full items-center gap-1.5 border-t border-content/10 px-3 text-left text-[11px] text-content/45 hover:bg-content/5 hover:text-content/70"
+        >
+          {showAll ? (
+            <ChevronDown className="size-3.5" />
+          ) : (
+            <ChevronRight className="size-3.5" />
+          )}
+          {showAll
+            ? "Show fewer tasks"
+            : `Show ${proposal.tasks.length - 3} more ${proposal.tasks.length === 4 ? "task" : "tasks"}`}
+        </button>
+      )}
+      {(error || proposal.error) && (
+        <p role="alert" className="px-3 py-2 text-[12px] text-red-400">
+          {error ?? proposal.error}
+        </p>
+      )}
+      {!planning && (
+        <div className="flex flex-wrap items-center justify-between gap-2 border-t border-content/10 px-3 py-2 text-[11px] text-content/45">
+          <div className="flex items-center gap-1.5">
+            {editable ? (
+              <>
+                <span>Parallel workers</span>
+                <div
+                  role="radiogroup"
+                  aria-label="Parallel workers"
+                  className="flex items-center gap-0.5 rounded-md bg-content/5 p-0.5"
+                >
+                  {[1, 2, 3, 4].map((number) => (
+                    <button
+                      key={number}
+                      type="button"
+                      role="radio"
+                      aria-checked={proposal.settings.maxWorkers === number}
+                      onClick={() =>
+                        actions?.update(proposal.leadId, block.id, {
+                          ...proposal,
+                          settings: {
+                            ...proposal.settings,
+                            maxWorkers: number,
+                          },
+                        })
+                      }
+                      className={`grid size-5 place-items-center rounded-[5px] text-[11px] leading-none tabular-nums ${
+                        proposal.settings.maxWorkers === number
+                          ? "bg-content/15 font-medium text-content"
+                          : "text-content/45 hover:bg-content/8 hover:text-content"
+                      }`}
+                    >
+                      {number}
+                    </button>
+                  ))}
+                </div>
+              </>
+            ) : (
+              <span>{proposal.settings.maxWorkers} parallel</span>
+            )}
+            <WorkerHelp />
+          </div>
+          <span>
+            {run?.status ??
+              (proposal.status === "approved"
+                ? "Approved"
+                : proposal.status === "ready"
+                  ? "Awaiting confirmation"
+                  : "")}{" "}
+            · Shared project folder
+          </span>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/chrome/OrchestrationSidebarAgents.tsx b/src/chrome/OrchestrationSidebarAgents.tsx
new file mode 100644
index 00000000..79a3b715
--- /dev/null
+++ b/src/chrome/OrchestrationSidebarAgents.tsx
@@ -0,0 +1,253 @@
+import { useContext, useEffect, useState, useSyncExternalStore } from "react";
+import { findModel } from "../lib/models";
+import { orchestrator } from "../lib/orchestration";
+import {
+  orchestrationTaskLabel,
+  type OrchestrationSummary,
+} from "../lib/orchestrationSummary";
+import { HARNESS_TITLE } from "../lib/session";
+import { HarnessIcon } from "./HarnessIcon";
+import { OrchestrationWorkers } from "./OrchestrationActions";
+import { Check, ChevronDown, ChevronRight, CircleAlert } from "./icons";
+import { TerminalSpinner } from "./TerminalSpinner";
+
+export function OrchestrationSidebarAgents({
+  leadId,
+  summary,
+}: {
+  leadId: string;
+  summary: OrchestrationSummary;
+}) {
+  const workers = useContext(OrchestrationWorkers);
+  const runs = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const [error, setError] = useState<string>();
+  const [pending, setPending] = useState(false);
+  // Rows expand independently, so several agents can be watched side by side.
+  const [expanded, setExpanded] = useState<ReadonlySet<string>>(
+    () => new Set(),
+  );
+  // Revealing a worker from its toast opens that row without closing others.
+  const revealed = workers.selectedId;
+  useEffect(() => {
+    if (revealed)
+      setExpanded((current) =>
+        current.has(revealed) ? current : new Set(current).add(revealed),
+      );
+  }, [revealed]);
+  const toggle = (sessionId: string, isOpen: boolean) => {
+    setExpanded((current) => {
+      const next = new Set(current);
+      if (isOpen) next.delete(sessionId);
+      else next.add(sessionId);
+      return next;
+    });
+    if (isOpen && revealed === sessionId) workers.inspect(null);
+  };
+  // A saved run has no live entry, so the card stays read-only after a reload.
+  const run = runs.find((entry) => entry.leadId === leadId);
+  const perform = async (operation: () => Promise<void>) => {
+    setPending(true);
+    setError(undefined);
+    try {
+      await operation();
+    } catch (reason) {
+      setError(reason instanceof Error ? reason.message : String(reason));
+    } finally {
+      setPending(false);
+    }
+  };
+  const done = summary.tasks.filter(
+    (task) => task.status === "completed",
+  ).length;
+  const action =
+    "rounded px-1.5 py-0.5 text-[11px] text-content/55 hover:bg-content/10 hover:text-content disabled:opacity-35";
+  // Sits inside an already-lit row, so it needs its own surface to read as a
+  // button rather than as another line of text.
+  const solidAction =
+    "rounded bg-content/15 px-1.5 py-0.5 text-[11px] text-content/75 hover:bg-content/25 hover:text-content disabled:opacity-35";
+  return (
+    <div className="relative mt-1.5">
+      <div className="mb-0.5 px-0.5 flex items-center justify-between text-[11px] text-content/45">
+        <span>
+          {summary.tasks.length}{" "}
+          {summary.tasks.length === 1 ? "agent" : "agents"}
+        </span>
+        <span className="tabular-nums">
+          {done}/{summary.tasks.length} done
+        </span>
+      </div>
+      {/*
+        Offset by the rows' own padding so a chevron lands on the card's
+        content edge, under the harness icon of the header above.
+
+        No height cap and no scroller: the card grows with whatever the user
+        expanded, and the sidebar it sits in does the only scrolling. Nesting
+        a second scroll region here made rows clip mid-line.
+      */}
+      <div
+        aria-label="Orchestrated agents"
+        className="-mx-2 flex touch-pan-y flex-col gap-px"
+        onPointerDown={(event) => event.stopPropagation()}
+        onClick={(event) => event.stopPropagation()}
+      >
+        {summary.tasks.map((task) => {
+          // Something waiting on an answer opens itself; it cannot be missed.
+          const open = expanded.has(task.sessionId) || !!task.needsInput;
+          const live = run?.tasks.find(
+            (entry) => entry.sessionId === task.sessionId,
+          );
+          const label = orchestrationTaskLabel(task, summary);
+          const working =
+            summary.live && task.status === "running" && !task.needsInput;
+          // A saved provider model may not be in this window's catalog yet.
+          // Keep its identity instead of substituting the harness default.
+          const model = findModel(task.model)?.name ?? task.model;
+          return (
+            <div
+              key={task.sessionId}
+              data-orchestration-agent={task.sessionId}
+              // Expanding lights the whole row, header and detail together.
+              className={`rounded-md ${open ? "bg-content/10" : ""}`}
+            >
+              <button
+                type="button"
+                title={`${task.title} · ${HARNESS_TITLE[task.harness]} · ${model} · ${label}`}
+                aria-label={`Agent details: ${task.title}`}
+                aria-expanded={open}
+                onClick={() => toggle(task.sessionId, open)}
+                // Named, because the whole session card is already a `group`.
+                className={`group/agent flex w-full min-w-0 items-center gap-1.5 rounded-md px-2 py-1.5 text-left ${
+                  open ? "" : "hover:bg-content/10"
+                }`}
+              >
+                {/* One slot: the chevron stands in for the harness mark
+                    whenever this row is open or under the pointer. */}
+                <span className="grid size-3.5 shrink-0 place-items-center text-content/45">
+                  {open ? (
+                    <ChevronDown className="size-3" strokeWidth={1.75} />
+                  ) : (
+                    <>
+                      <HarnessIcon
+                        harness={task.harness}
+                        className="size-3.5 opacity-75 group-focus-visible/agent:hidden group-hover/agent:hidden"
+                      />
+                      <ChevronRight
+                        className="hidden size-3 group-focus-visible/agent:block group-hover/agent:block"
+                        strokeWidth={1.75}
+                      />
+                    </>
+                  )}
+                </span>
+                <span className="min-w-0 flex-1 truncate text-[12px] leading-snug text-content/80">
+                  {task.title}
+                </span>
+                <span
+                  className={`flex shrink-0 items-center gap-1 text-[11px] ${
+                    task.needsInput || task.status === "failed"
+                      ? "text-amber-400"
+                      : working
+                        ? "text-accent"
+                        : task.status === "completed"
+                          ? "text-emerald-400"
+                          : "text-content/45"
+                  }`}
+                >
+                  {task.needsInput || task.status === "failed" ? (
+                    <CircleAlert className="size-3" strokeWidth={1.75} />
+                  ) : working ? (
+                    <TerminalSpinner className="inline-block w-3 select-none text-center text-[11px] leading-none text-accent" />
+                  ) : task.status === "completed" ? (
+                    <Check className="size-3" strokeWidth={2.25} />
+                  ) : null}
+                  <span>{label}</span>
+                </span>
+              </button>
+              {/* Indented to the title's column: the icon slot and its gap. */}
+              {open && (
+                <div className="space-y-2 pb-3 pl-6.5 pr-2">
+                  <p
+                    className="flex min-w-0 items-center gap-1.5 text-[11px] text-content/45"
+                    title={`${model} · ${HARNESS_TITLE[task.harness]}`}
+                  >
+                    <HarnessIcon
+                      harness={task.harness}
+                      className="size-3.5 shrink-0"
+                    />
+                    <span className="min-w-0 truncate">{model}</span>
+                  </p>
+                  {live?.error && (
+                    <p className="text-[11px] text-red-400">{live.error}</p>
+                  )}
+                  <div className="flex flex-wrap items-center gap-1">
+                    {workers.openDetails && (
+                      <button
+                        type="button"
+                        title="Open this agent beside the orchestrator"
+                        className={solidAction}
+                        onClick={() =>
+                          workers.openDetails?.({
+                            sessionId: task.sessionId,
+                            leadId,
+                            title: task.title,
+                            harness: task.harness,
+                          })
+                        }
+                      >
+                        See details
+                      </button>
+                    )}
+                    {live && ["queued", "running"].includes(live.status) && (
+                      <button
+                        type="button"
+                        className={solidAction}
+                        disabled={pending}
+                        onClick={() =>
+                          void perform(() =>
+                            orchestrator.cancelTask(leadId, live.id),
+                          )
+                        }
+                      >
+                        Cancel task
+                      </button>
+                    )}
+                  </div>
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+      {(error || run?.error) && (
+        <p role="alert" className="py-1 text-[11px] text-red-400">
+          {error ?? run?.error}
+        </p>
+      )}
+      {/* Stopping a run belongs to the composer, which stops the lead and its
+          agents together. Resume has no other home, so it stays. */}
+      {run?.status === "paused" && (
+        <div className="-mr-1.5 mt-0.5 flex items-center justify-end">
+          <button
+            type="button"
+            className={action}
+            disabled={pending}
+            onClick={() =>
+              void perform(() =>
+                orchestrator.start(
+                  leadId,
+                  run.allowedHarnesses,
+                  run.maxWorkers,
+                ),
+              )
+            }
+          >
+            Resume
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index 38cc0f48..8a210c09 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -1,3 +1,4 @@
+import { OrchestrationSidebarAgents } from "./OrchestrationSidebarAgents";
 import { openUrl } from "@tauri-apps/plugin-opener";
 import {
   Archive,
@@ -426,7 +427,7 @@ function SidebarComponent({
     sessions,
     openSessions,
     sessionFolders,
-  );
+  ).filter((session) => !session.orchestrationLeadId);
   const visibleSessions = [
     ...filterSessionsByQuery(
       filterSessionsByStatus(
@@ -2348,12 +2349,16 @@ function SessionCard({
   const skipClickUntil = useRef(0);
   const prefetchTimer = useRef<number | null>(null);
   const [dragging, setDragging] = useState(false);
+  const orchestration = session.orchestration;
   const title = sessionDisplayTitle(session.title, session.harness);
   const gitLabel = formatGitLabel(session.repo, session.branch);
   const time = formatRelative(session.updatedAt, now);
-  const model = compact
-    ? null
-    : resolveModel(session.harness, session.model).name;
+  // A lead card always shows its model, even compact: it heads a group of
+  // agents that each name theirs, so the row naming none reads as a gap.
+  const model =
+    compact && !orchestration
+      ? null
+      : resolveModel(session.harness, session.model).name;
   const statusClass = needsApproval
     ? "text-amber-400"
     : busy
@@ -2368,7 +2373,7 @@ function SessionCard({
       {needsApproval ? (
         <>
           <CircleAlert className="size-3" strokeWidth={1.75} />
-          <span>Need approval</span>
+          <span>{orchestration ? "Needs input" : "Need approval"}</span>
         </>
       ) : busy ? (
         <>
@@ -2579,16 +2584,18 @@ function SessionCard({
   };
 
   const archiveLabel = session.archived ? "Unarchive" : "Archive";
+  const cardPaddingY = orchestration
+    ? "py-2.5"
+    : compact
+      ? "py-1.5"
+      : "py-2";
 
   return (
     <div className="group relative">
       <div
-        role="button"
-        tabIndex={0}
         title={title}
-        aria-current={isActive ? "true" : undefined}
-        aria-pressed={isSelected}
         data-session-card={session.id}
+        data-orchestration-card={orchestration ? "true" : undefined}
         data-session-selected={isSelected ? "true" : undefined}
         data-tauri-drag-region="false"
         onPointerDown={onPointerDown}
@@ -2599,10 +2606,9 @@ function SessionCard({
           onSelect(session.id, event);
         }}
         onContextMenu={onContextMenu}
-        onKeyDown={onKeyDown}
-        className={`relative border flex w-full cursor-default select-none touch-none flex-col rounded-md px-2.5 text-left ${
-          compact ? "py-1.5" : "py-2"
-        } ${dragging ? "opacity-40" : ""} ${
+        className={`relative border flex w-full cursor-default select-none touch-none flex-col rounded-md px-2.5 text-left ${cardPaddingY} ${
+          dragging ? "opacity-40" : ""
+        } ${
           dropTarget
             ? "text-content border-transparent"
             : isSelected
@@ -2611,50 +2617,71 @@ function SessionCard({
                 ? "bg-content/20 text-content border-content/30 border-dashed"
                 : isActive
                   ? "bg-content/10 text-content border-transparent"
-                  : "text-content/80 hover:bg-content/5 hover:text-content border-transparent"
+                  : // A lead rests at the tone others only reach on hover, so
+                    // its card reads as a group even when nothing is selected.
+                    `text-content/80 hover:text-content border-transparent ${
+                      orchestration
+                        ? "bg-content/5 hover:bg-content/10"
+                        : "hover:bg-content/5"
+                    }`
         }`}
       >
         {dropTarget ? (
           <div className="pointer-events-none absolute inset-0 rounded-md bg-accent/20" />
         ) : null}
-        {compact ? null : (
-          <span className="relative flex items-center gap-2">
-            <span className="flex min-w-0 flex-1 items-center gap-1.5">
-              <HarnessIcon
-                harness={session.harness}
-                className="size-3.5 shrink-0"
-              />
-              <span className="min-w-0 truncate text-[11px] text-content/50">
-                {model}
+        <div
+          role="button"
+          tabIndex={0}
+          aria-current={isActive ? "true" : undefined}
+          aria-pressed={isSelected}
+          data-session-select={session.id}
+          onKeyDown={onKeyDown}
+        >
+          {compact && !orchestration ? null : (
+            <span className="relative flex items-center gap-2">
+              <span className="flex min-w-0 flex-1 items-center gap-1.5">
+                <HarnessIcon
+                  harness={session.harness}
+                  className="size-3.5 shrink-0"
+                />
+                <span className="min-w-0 truncate text-[11px] text-content/50">
+                  {model}
+                </span>
+              </span>
+              <span className="flex shrink-0 items-center gap-1.5">
+                {linkedUpdateDot}
+                {status}
               </span>
             </span>
-            <span className="flex shrink-0 items-center gap-1.5">
-              {linkedUpdateDot}
-              {status}
+          )}
+          <span
+            className={`relative flex min-w-0 items-center gap-1.5 ${
+              compact && !orchestration ? "" : "mt-1"
+            }`}
+          >
+            {session.pinned ? (
+              <Pin
+                className="size-3 shrink-0 text-content/45"
+                strokeWidth={1.75}
+              />
+            ) : null}
+            <span className="min-w-0 flex-1 line-clamp-1 text-[13px] font-semibold leading-snug text-content">
+              {title}
             </span>
+            {compact && !orchestration ? (
+              <span className="flex shrink-0 items-center gap-1.5">
+                {linkedUpdateDot}
+                {status}
+              </span>
+            ) : null}
           </span>
-        )}
-        <span
-          className={`relative flex min-w-0 items-center gap-1.5 ${
-            compact ? "" : "mt-1"
-          }`}
-        >
-          {session.pinned ? (
-            <Pin
-              className="size-3 shrink-0 text-content/45"
-              strokeWidth={1.75}
-            />
-          ) : null}
-          <span className="min-w-0 flex-1 line-clamp-1 text-[13px] font-semibold leading-snug text-content">
-            {title}
-          </span>
-          {compact ? (
-            <span className="flex shrink-0 items-center gap-1.5">
-              {linkedUpdateDot}
-              {status}
-            </span>
-          ) : null}
-        </span>
+        </div>
+        {orchestration ? (
+          <OrchestrationSidebarAgents
+            leadId={session.id}
+            summary={orchestration}
+          />
+        ) : null}
         <span className="relative mt-1 flex items-center gap-2">
           {gitLabel ? (
             <span className="flex min-w-0 flex-1 items-center gap-1 text-[11px] text-content/45">
diff --git a/src/chrome/SidebarRename.test.ts b/src/chrome/SidebarRename.test.ts
index 599b269e..bd07b003 100644
--- a/src/chrome/SidebarRename.test.ts
+++ b/src/chrome/SidebarRename.test.ts
@@ -163,7 +163,7 @@ describe("sidebar session rename", () => {
 
   it("allows F2 to rename a working conversation", () => {
     act(() => render());
-    pressKey(card(), "F2");
+    pressKey(card().querySelector('[data-session-select]')!, "F2");
     const input = renameInput();
     expect(input.disabled).toBe(false);
     expect(document.activeElement === input).toBe(true);
@@ -374,6 +374,167 @@ describe("sidebar pinned sessions", () => {
   });
 });
 
+describe("sidebar orchestration card", () => {
+  it.each([false, true])(
+    "keeps agents inside a distinct lead card (pinned=%s)",
+    (pinned) => {
+      props.onArchiveSession = vi.fn();
+      props.linkedSessionUpdateIds = new Set(["session-1"]);
+      const lead = {
+        ...props.sessions[0],
+        pinned,
+        linkedWorkItem: {
+          kind: "pr" as const,
+          repo: "acme/app",
+          number: 42,
+          url: "https://github.com/acme/app/pull/42",
+        },
+        orchestration: {
+          status: "active" as const,
+          live: true,
+          tasks: [
+            {
+              sessionId: "worker-a",
+              title: "Build settings",
+              harness: "codex" as const,
+              model: "codex:worker-a",
+              status: "running" as const,
+            },
+            {
+              sessionId: "worker-b",
+              title: "Review changes",
+              harness: "claude" as const,
+              model: "claude:worker-b",
+              status: "running" as const,
+              needsInput: true,
+            },
+            {
+              sessionId: "worker-c",
+              title: "Check types",
+              harness: "codex" as const,
+              model: "codex:worker-c",
+              status: "completed" as const,
+            },
+          ],
+        },
+      };
+      props.sessions = [
+        lead,
+        { ...props.sessions[0], id: "unrelated" },
+        {
+          ...props.sessions[0],
+          id: "worker-a",
+          orchestrationLeadId: lead.id,
+        },
+      ];
+      act(() => render());
+      expect(container.querySelectorAll("[data-session-card]")).toHaveLength(2);
+      expect(card().dataset.orchestrationCard).toBe("true");
+      // The lead card carries the sidebar's ordinary active treatment.
+      expect(card().className).toContain("bg-content/10");
+      // The lead names its own model, like every agent row beneath it.
+      expect(card().textContent).toContain("Claude Sonnet 5");
+      expect(card().textContent).not.toContain("Orchestrator");
+      expect(card().textContent).toContain("3 agents");
+      expect(card().textContent).toContain("1/3 done");
+      expect(card().textContent).toContain("Build settings");
+      expect(card().textContent).toContain("Needs input");
+      expect(
+        card().querySelector('[aria-label="Linked work item updated"]'),
+      ).not.toBeNull();
+      const archive = card().querySelector<HTMLButtonElement>(
+        '[aria-label^="Archive "]',
+      )!;
+      const pullRequest = card().querySelector('[aria-label="Open PR #42"]');
+      expect(card().querySelectorAll('[aria-label^="Archive "]')).toHaveLength(
+        1,
+      );
+      expect(card().lastElementChild?.contains(pullRequest)).toBe(true);
+      expect(archive.nextElementSibling).toBe(pullRequest);
+      act(() => archive.click());
+      expect(props.onArchiveSession).toHaveBeenCalledExactlyOnceWith(
+        lead.id,
+        true,
+      );
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      // A collapsed row stays one line; the model rides along in the tooltip.
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-a"] button')
+          ?.getAttribute("title"),
+      ).toContain("codex:worker-a");
+      expect(
+        card().querySelectorAll("[data-orchestration-agent]"),
+      ).toHaveLength(3);
+      const normal = container.querySelector<HTMLElement>(
+        '[data-session-card="unrelated"]',
+      )!;
+      expect(normal.hasAttribute("data-orchestration-card")).toBe(false);
+      expect(normal.querySelector("[data-orchestration-agent]")).toBeNull();
+      // Working the agents list is not a request to open the lead's tab: the
+      // row expands in place and the card stays where it is.
+      const agentRow = card().querySelector<HTMLButtonElement>(
+        '[data-orchestration-agent="worker-a"] button',
+      )!;
+      expect(card().hasAttribute("role")).toBe(false);
+      for (const action of card().querySelectorAll('button, [role="button"]')) {
+        expect(
+          action.parentElement?.closest('button, [role="button"]'),
+        ).toBeNull();
+      }
+      const selection = card().querySelector<HTMLElement>(
+        '[data-session-select]',
+      )!;
+      act(() => selection.focus());
+      expect(document.activeElement).toBe(selection);
+      expect(pressKey(selection, "Enter").defaultPrevented).toBe(true);
+      expect(props.onSelectSession).toHaveBeenCalledWith(lead.id);
+      vi.mocked(props.onSelectSession).mockClear();
+      expect(pressKey(agentRow, "Enter").defaultPrevented).toBe(false);
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      const wasOpen = agentRow.getAttribute("aria-expanded");
+      act(() => agentRow.click());
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-a"] button')
+          ?.getAttribute("aria-expanded"),
+      ).not.toBe(wasOpen);
+      // A blocked agent stays expanded while it needs the lead's attention.
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-b"] button')
+          ?.getAttribute("aria-expanded"),
+      ).toBe("true");
+      props.approvalSessionIds = new Set([lead.id]);
+      act(() => render());
+      expect(card().className).toContain("border-dashed");
+      expect(card().textContent).toContain("Needs input");
+    },
+  );
+
+  it("renders saved worker details without claiming the workers are running", () => {
+    props.busySessionIds = new Set();
+    props.sessions[0].orchestration = {
+      status: "active",
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "Saved task",
+          harness: "codex",
+          model: "codex:test",
+          status: "running",
+        },
+      ],
+    };
+    act(() => render());
+    expect(card().textContent).toContain("Saved task");
+    expect(card().textContent).toContain("Saved");
+    expect(card().textContent).not.toContain("Working");
+    expect(card().querySelector(".motion-safe\\:animate-pulse")).toBeNull();
+  });
+});
+
 describe("sidebar linked work item updates", () => {
   it("uses the footer for the linked issue or PR instead of a second harness icon", () => {
     props.busySessionIds = new Set();
diff --git a/src/chrome/SurfaceTabs.tsx b/src/chrome/SurfaceTabs.tsx
index eb42884b..f23c9e9b 100644
--- a/src/chrome/SurfaceTabs.tsx
+++ b/src/chrome/SurfaceTabs.tsx
@@ -5,6 +5,7 @@ import { useLayoutEffect, useRef, useState } from "react";
 import { copyText } from "../lib/clipboard";
 import { basename, revealPath } from "../lib/fs";
 import {
+  isAgentTab,
   isChangesTab,
   isCommitTab,
   isFilesystemTab,
@@ -23,6 +24,7 @@ import { useLockOverscroll } from "../hooks/useLockOverscroll";
 import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { ExplorerMenu, type ExplorerMenuItem } from "./ExplorerMenu";
 import { FileTypeIcon } from "./FileTypeIcon";
+import { HarnessIcon } from "./HarnessIcon";
 
 type Props = {
   files: FilePaneTab[];
@@ -124,6 +126,16 @@ export function surfaceTabPresentation(
     };
   }
 
+  if (isAgentTab(file)) {
+    const name = file.path.trim() || "Agent";
+    return {
+      name,
+      label: name,
+      iconName: "AGENT",
+      tooltip: `${name} — orchestration agent`,
+    };
+  }
+
   if (isCommitTab(file)) {
     const name = file.commit.subject.trim() || file.commit.shortSha;
     return {
@@ -263,6 +275,7 @@ export function SurfaceTabs({
         const commit = isCommitTab(file);
         const review = isReviewTab(file) && !changes;
         const terminal = isTerminalTab(file);
+        const agent = isAgentTab(file) ? file.agent : null;
         const { label, iconName, tooltip } = surfaceTabPresentation(file);
         return (
           <div
@@ -323,6 +336,11 @@ export function SurfaceTabs({
             >
               {terminal ? (
                 <Terminal className="size-3.5 shrink-0" strokeWidth={1.75} />
+              ) : agent ? (
+                <HarnessIcon
+                  harness={agent.harness}
+                  className="size-3.5 shrink-0"
+                />
               ) : changes || commit ? (
                 <GitCompare className="size-3.5 shrink-0" strokeWidth={1.75} />
               ) : (
diff --git a/src/chrome/icons.tsx b/src/chrome/icons.tsx
index 13c2c4bd..4819c148 100644
--- a/src/chrome/icons.tsx
+++ b/src/chrome/icons.tsx
@@ -50,6 +50,7 @@ import GitMergeIcon from "@hugeicons/core-free-icons/GitMergeIcon";
 import GitPullRequestClosedIcon from "@hugeicons/core-free-icons/GitPullRequestClosedIcon";
 import GitPullRequestDraftIcon from "@hugeicons/core-free-icons/GitPullRequestDraftIcon";
 import GitPullRequestIcon from "@hugeicons/core-free-icons/GitPullRequestIcon";
+import HelpCircleIcon from "@hugeicons/core-free-icons/HelpCircleIcon";
 import ImageAdd01Icon from "@hugeicons/core-free-icons/ImageAdd01Icon";
 import InboxIcon from "@hugeicons/core-free-icons/InboxIcon";
 import KeyboardIcon from "@hugeicons/core-free-icons/KeyboardIcon";
@@ -79,6 +80,7 @@ import ReplaceIcon from "@hugeicons/core-free-icons/ReplaceIcon";
 import RotateCcwIcon from "@hugeicons/core-free-icons/RotateCcwIcon";
 import Search01Icon from "@hugeicons/core-free-icons/Search01Icon";
 import Settings01Icon from "@hugeicons/core-free-icons/Settings01Icon";
+import Share02Icon from "@hugeicons/core-free-icons/Share02Icon";
 import SidebarRight01Icon from "@hugeicons/core-free-icons/SidebarRight01Icon";
 import SparklesIcon from "@hugeicons/core-free-icons/SparklesIcon";
 import SquareIcon from "@hugeicons/core-free-icons/SquareIcon";
@@ -163,6 +165,7 @@ export const ChevronUp = wrap(ArrowUp01Icon, "ChevronUp");
 export const CircleAlert = wrap(AlertCircleIcon, "CircleAlert");
 export const CircleDashed = wrap(CircleDashedIcon, "CircleDashed");
 export const CircleDot = wrap(CircleDotIcon, "CircleDot");
+export const CircleHelp = wrap(HelpCircleIcon, "CircleHelp");
 export const CircleX = wrap(CancelCircleIcon, "CircleX");
 export const CloudUpload = wrap(CloudUploadIcon, "CloudUpload");
 export const Clock = wrap(Clock01Icon, "Clock");
@@ -231,6 +234,7 @@ export const Replace = wrap(ReplaceIcon, "Replace");
 export const RotateCcw = wrap(RotateCcwIcon, "RotateCcw");
 export const Search = wrap(Search01Icon, "Search");
 export const Settings = wrap(Settings01Icon, "Settings");
+export const Share = wrap(Share02Icon, "Share");
 export const SlidersHorizontal = wrap(
   PreferenceHorizontalIcon,
   "SlidersHorizontal",
diff --git a/src/hooks/useLockOverscroll.test.ts b/src/hooks/useLockOverscroll.test.ts
index e7eeb351..bee16481 100644
--- a/src/hooks/useLockOverscroll.test.ts
+++ b/src/hooks/useLockOverscroll.test.ts
@@ -1,55 +1,200 @@
+// @vitest-environment happy-dom
 import { describe, expect, it } from "vitest";
+import {
+  atScrollEdge,
+  hasScrollRoom,
+  lockOverscroll,
+} from "./useLockOverscroll";
 
-function shouldPreventWheel(
-  el: Pick<HTMLElement, "scrollTop" | "scrollLeft" | "clientHeight" | "clientWidth" | "scrollHeight" | "scrollWidth">,
-  e: Pick<WheelEvent, "deltaX" | "deltaY">,
-) {
-  const canScrollX = el.scrollWidth > el.clientWidth + 1;
-  const canScrollY = el.scrollHeight > el.clientHeight + 1;
-  const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
-  const atBottom =
-    canScrollY &&
-    el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
-    e.deltaY > 0;
-  const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
-  const atRight =
-    canScrollX &&
-    el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
-    e.deltaX > 0;
-  return atTop || atBottom || atLeft || atRight;
+const box = (over: Partial<Record<string, number>> = {}) => ({
+  scrollTop: 0,
+  scrollLeft: 0,
+  clientHeight: 400,
+  clientWidth: 400,
+  scrollHeight: 800,
+  scrollWidth: 400,
+  ...over,
+});
+
+/** happy-dom reports 0 for every layout box, so the sizes are declared. */
+function sized(el: HTMLElement, sizes: Record<string, number>) {
+  for (const [name, value] of Object.entries(sizes)) {
+    Object.defineProperty(el, name, { value, configurable: true });
+  }
+  return el;
 }
 
 describe("useLockOverscroll wheel guard", () => {
-  it("does not block horizontal wheel on vertically scrolling containers", () => {
-    const el = {
-      scrollTop: 0,
-      scrollLeft: 0,
-      clientHeight: 400,
-      clientWidth: 400,
-      scrollHeight: 800,
-      scrollWidth: 400,
-    };
+  it.each(["svg", "path"])(
+    "allows scrolling a nested container through an SVG %s target",
+    (tag) => {
+      const outer = sized(
+        document.createElement("div"),
+        box({ scrollTop: 400 }),
+      );
+      const inner = sized(document.createElement("div"), box());
+      inner.style.overflowY = "auto";
+      const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+      const path = document.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "path",
+      );
+      svg.append(path);
+      inner.append(svg);
+      outer.append(inner);
+      document.body.append(outer);
+      const detach = lockOverscroll(outer);
+      const wheel = new WheelEvent("wheel", {
+        deltaY: 40,
+        bubbles: true,
+        cancelable: true,
+      });
+      (tag === "svg" ? svg : path).dispatchEvent(wheel);
+      expect(wheel.defaultPrevented).toBe(false);
+      detach();
+      outer.remove();
+    },
+  );
+
+  it.each([
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 0,
+      deltaY: 40,
+      blocked: true,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: 40,
+      deltaY: 0,
+      blocked: true,
+    },
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 0,
+      deltaY: -40,
+      blocked: true,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: -40,
+      deltaY: 0,
+      blocked: true,
+    },
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 40,
+      deltaY: 40,
+      blocked: false,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: 40,
+      deltaY: 40,
+      blocked: false,
+    },
+  ])(
+    "matches nested overflow to the gesture's axis ($overflowX, $overflowY, $deltaX, $deltaY)",
+    ({ overflowX, overflowY, deltaX, deltaY, blocked }) => {
+      const outer = sized(
+        document.createElement("div"),
+        box({
+          scrollTop: deltaY < 0 ? 0 : 400,
+          scrollLeft: deltaX < 0 ? 0 : 400,
+          scrollWidth: 800,
+        }),
+      );
+      const inner = sized(
+        document.createElement("div"),
+        box({ scrollTop: 100, scrollLeft: 100, scrollWidth: 800 }),
+      );
+      Object.assign(inner.style, { overflowX, overflowY });
+      outer.append(inner);
+      document.body.append(outer);
+      const detach = lockOverscroll(outer);
+      const wheel = new WheelEvent("wheel", {
+        deltaX,
+        deltaY,
+        bubbles: true,
+        cancelable: true,
+      });
+      inner.dispatchEvent(wheel);
+      expect(wheel.defaultPrevented).toBe(blocked);
+      detach();
+      outer.remove();
+    },
+  );
 
-    expect(shouldPreventWheel(el, { deltaX: 40, deltaY: 0 })).toBe(false);
-    expect(shouldPreventWheel(el, { deltaX: -40, deltaY: 0 })).toBe(false);
+  it("does not block horizontal wheel on vertically scrolling containers", () => {
+    expect(atScrollEdge(box(), { deltaX: 40, deltaY: 0 })).toBe(false);
+    expect(atScrollEdge(box(), { deltaX: -40, deltaY: 0 })).toBe(false);
   });
 
   it("still blocks vertical rubber-band at the top and bottom", () => {
-    const el = {
-      scrollTop: 0,
-      scrollLeft: 0,
+    expect(atScrollEdge(box(), { deltaX: 0, deltaY: -40 })).toBe(true);
+    expect(
+      atScrollEdge(box({ scrollTop: 400 }), { deltaX: 0, deltaY: 40 }),
+    ).toBe(true);
+  });
+
+  it("reads room in the direction the wheel is pushing", () => {
+    expect(hasScrollRoom(box(), { deltaX: 0, deltaY: 40 })).toBe(true);
+    expect(hasScrollRoom(box(), { deltaX: 0, deltaY: -40 })).toBe(false);
+    expect(
+      hasScrollRoom(box({ scrollTop: 400 }), { deltaX: 0, deltaY: 40 }),
+    ).toBe(false);
+  });
+
+  it("leaves the gesture alone when a scroller inside still has room", () => {
+    // A pinned transcript with a part-scrolled field in it: cancelling the
+    // wheel here would cancel the field's own scrolling too.
+    const scroller = sized(document.createElement("div"), {
+      scrollTop: 400,
       clientHeight: 400,
-      clientWidth: 400,
       scrollHeight: 800,
+      clientWidth: 400,
       scrollWidth: 400,
-    };
+    });
+    const field = sized(document.createElement("textarea"), {
+      scrollTop: 0,
+      clientHeight: 160,
+      scrollHeight: 600,
+      clientWidth: 400,
+      scrollWidth: 400,
+    });
+    field.style.overflowY = "auto";
+    scroller.append(field);
+    document.body.append(scroller);
+    const detach = lockOverscroll(scroller);
 
-    expect(shouldPreventWheel(el, { deltaX: 0, deltaY: -40 })).toBe(true);
+    const down = new WheelEvent("wheel", {
+      deltaY: 40,
+      bubbles: true,
+      cancelable: true,
+    });
+    field.dispatchEvent(down);
+    expect(down.defaultPrevented).toBe(false);
 
-    const atBottom = {
-      ...el,
-      scrollTop: 400,
-    };
-    expect(shouldPreventWheel(atBottom, { deltaX: 0, deltaY: 40 })).toBe(true);
+    // Once the field bottoms out the lock takes over again.
+    Object.defineProperty(field, "scrollTop", {
+      value: 440,
+      configurable: true,
+    });
+    const spent = new WheelEvent("wheel", {
+      deltaY: 40,
+      bubbles: true,
+      cancelable: true,
+    });
+    field.dispatchEvent(spent);
+    expect(spent.defaultPrevented).toBe(true);
+
+    detach();
+    scroller.remove();
   });
 });
diff --git a/src/hooks/useLockOverscroll.ts b/src/hooks/useLockOverscroll.ts
index 5257ac95..c2a05fc8 100644
--- a/src/hooks/useLockOverscroll.ts
+++ b/src/hooks/useLockOverscroll.ts
@@ -1,31 +1,91 @@
 import { useCallback, useRef } from "react";
 
-/** Stop macOS rubber-band bounce when a scroller reaches any edge. */
+type Edges = Pick<
+  HTMLElement,
+  | "scrollTop"
+  | "scrollLeft"
+  | "clientHeight"
+  | "clientWidth"
+  | "scrollHeight"
+  | "scrollWidth"
+>;
+type Delta = Pick<WheelEvent, "deltaX" | "deltaY">;
+
+/** The scroller has run out of room in the direction the wheel is pushing. */
+export function atScrollEdge(el: Edges, e: Delta): boolean {
+  const canScrollX = el.scrollWidth > el.clientWidth + 1;
+  const canScrollY = el.scrollHeight > el.clientHeight + 1;
+  const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
+  const atBottom =
+    canScrollY &&
+    el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
+    e.deltaY > 0;
+  const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
+  const atRight =
+    canScrollX &&
+    el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
+    e.deltaX > 0;
+  return atTop || atBottom || atLeft || atRight;
+}
+
+/** The scroller still has somewhere to go in the direction of the wheel. */
+export function hasScrollRoom(el: Edges, e: Delta): boolean {
+  if (e.deltaY < 0 && el.scrollTop > 0) return true;
+  if (e.deltaY > 0 && el.scrollTop + el.clientHeight < el.scrollHeight - 1) {
+    return true;
+  }
+  if (e.deltaX < 0 && el.scrollLeft > 0) return true;
+  return e.deltaX > 0 && el.scrollLeft + el.clientWidth < el.scrollWidth - 1;
+}
+
+function scrollable(node: HTMLElement, e: Delta): boolean {
+  const style = getComputedStyle(node);
+  return hasScrollRoom(node, {
+    deltaX: /auto|scroll|overlay/.test(style.overflowX) ? e.deltaX : 0,
+    deltaY: /auto|scroll|overlay/.test(style.overflowY) ? e.deltaY : 0,
+  });
+}
+
+/**
+ * A scroller between the wheel's target and `el` that can still take the
+ * gesture. Cancelling here would cancel it for that scroller too, since the
+ * browser picks what to scroll only after the event has finished dispatching.
+ */
+function innerScrollerTakes(el: HTMLElement, e: WheelEvent): boolean {
+  let node = e.target instanceof Element ? e.target : null;
+  while (node && node !== el) {
+    // Geometry first: it is free, and it rules out most of the ancestry
+    // before anything has to resolve style.
+    if (
+      node instanceof HTMLElement &&
+      hasScrollRoom(node, e) &&
+      scrollable(node, e)
+    )
+      return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+
+/**
+ * Stop macOS rubber-band bounce when a scroller reaches any edge. Returns the
+ * detach, and stands alone from the hook so it can be exercised directly.
+ */
+export function lockOverscroll(el: HTMLElement): () => void {
+  const onWheel = (e: WheelEvent) => {
+    if (!atScrollEdge(el, e)) return;
+    if (innerScrollerTakes(el, e)) return;
+    e.preventDefault();
+  };
+  el.addEventListener("wheel", onWheel, { passive: false });
+  return () => el.removeEventListener("wheel", onWheel);
+}
+
 export function useLockOverscroll<T extends HTMLElement>() {
   const cleanup = useRef<(() => void) | null>(null);
 
   return useCallback((el: T | null) => {
     cleanup.current?.();
-    cleanup.current = null;
-    if (!el) return;
-
-    const onWheel = (e: WheelEvent) => {
-      const canScrollX = el.scrollWidth > el.clientWidth + 1;
-      const canScrollY = el.scrollHeight > el.clientHeight + 1;
-      const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
-      const atBottom =
-        canScrollY &&
-        el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
-        e.deltaY > 0;
-      const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
-      const atRight =
-        canScrollX &&
-        el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
-        e.deltaX > 0;
-      if (atTop || atBottom || atLeft || atRight) e.preventDefault();
-    };
-
-    el.addEventListener("wheel", onWheel, { passive: false });
-    cleanup.current = () => el.removeEventListener("wheel", onWheel);
+    cleanup.current = el ? lockOverscroll(el) : null;
   }, []);
 }
diff --git a/src/lib/agentTabs.test.ts b/src/lib/agentTabs.test.ts
new file mode 100644
index 00000000..3b3d3872
--- /dev/null
+++ b/src/lib/agentTabs.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import {
+  editorTabKey,
+  isAgentTab,
+  isFilesystemTab,
+  leafIds,
+  newAgentTab,
+  newFileTab,
+  newTab,
+  openEditorTab,
+} from "./layout";
+import { groupTurns } from "../surfaces/transcriptActivity";
+import type { Block } from "./session";
+
+const agent = (sessionId: string, title: string) =>
+  newAgentTab(title, "/repo", {
+    sessionId,
+    leadId: "lead",
+    harness: "codex",
+  });
+
+describe("agent tabs", () => {
+  it("gathers every agent of a run into one pane beside the lead", () => {
+    let tab = newTab("lead");
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+    const paneId = tab.editorPanes[0].id;
+    tab = openEditorTab(tab, agent("worker-b", "Audit the UI"));
+
+    expect(tab.editorPanes).toHaveLength(1);
+    expect(tab.editorPanes[0].id).toBe(paneId);
+    expect(tab.editorPanes[0].files.map((file) => file.path)).toEqual([
+      "Audit the engine",
+      "Audit the UI",
+    ]);
+    // The pane sits beside the lead, which keeps its own leaf.
+    expect(leafIds(tab.layout)).toEqual(["lead", paneId]);
+    expect(tab.focusedId).toBe(paneId);
+  });
+
+  it("focuses the tab an agent already has instead of opening a second", () => {
+    let tab = newTab("lead");
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+    tab = openEditorTab(tab, agent("worker-b", "Audit the UI"));
+    const first = tab.editorPanes[0].files[0];
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+
+    expect(tab.editorPanes[0].files).toHaveLength(2);
+    expect(tab.editorPanes[0].activeFileId).toBe(first.id);
+  });
+
+  it("is keyed by its worker, and is not a file on disk", () => {
+    const file = agent("worker-a", "Audit the engine");
+    expect(editorTabKey(file)).toBe("agent:worker-a");
+    expect(isAgentTab(file)).toBe(true);
+    expect(file.agent.harness).toBe("codex");
+    expect(isFilesystemTab(file)).toBe(false);
+    expect(isFilesystemTab(newFileTab("/repo/a.ts", "/repo"))).toBe(true);
+  });
+});
+
+describe("a worker's own transcript", () => {
+  const blocks: Block[] = [
+    { id: "u1", role: "user", text: "Audit the engine", internal: true },
+    { id: "a1", role: "assistant", text: "Looking now" },
+    { id: "u2", role: "user", text: "Also check retries", internal: true },
+    { id: "a2", role: "assistant", text: "Done" },
+  ];
+
+  it("shows the orchestrator's turns, which the lead's own transcript hides", () => {
+    expect(
+      groupTurns(blocks, true).map((turn) => turn.map((b) => b.id)),
+    ).toEqual([
+      ["u1", "a1"],
+      ["u2", "a2"],
+    ]);
+    // Without it the prompts vanish and the replies fold into one turn, which
+    // is what left the worker's answers with nothing above them.
+    expect(groupTurns(blocks).map((turn) => turn.map((b) => b.id))).toEqual([
+      ["a1", "a2"],
+    ]);
+  });
+});
diff --git a/src/lib/approvalToast.test.ts b/src/lib/approvalToast.test.ts
index 5a1ea98f..691a2de6 100644
--- a/src/lib/approvalToast.test.ts
+++ b/src/lib/approvalToast.test.ts
@@ -7,10 +7,7 @@ import {
 } from "./approvalToast";
 import { newSession, type Block } from "./session";
 
-function block(
-  role: Block["role"],
-  approval?: Block["approval"],
-): Block {
+function block(role: Block["role"], approval?: Block["approval"]): Block {
   return {
     id: crypto.randomUUID(),
     role,
@@ -23,6 +20,24 @@ function block(
 }
 
 describe("pendingApprovalForSession", () => {
+  it("never toasts a worker approval, which its lead answers instead", () => {
+    const worker = {
+      ...newSession(),
+      id: "worker",
+      orchestrationLeadId: "lead",
+      blocks: [block("tool", { requestId: 42 })],
+    };
+    const leadTab = newTab("lead");
+    const otherTab = newTab("unrelated");
+    const tabs = [leadTab, otherTab];
+    for (const active of [leadTab, otherTab])
+      expect(hiddenApprovalNotices([worker], active.id, tabs, true)).toEqual([]);
+    // The same approval on an ordinary session still reaches the user.
+    const solo = { ...worker, orchestrationLeadId: undefined };
+    expect(
+      hiddenApprovalNotices([solo], otherTab.id, tabs, true)[0].sessionId,
+    ).toBe("worker");
+  });
   it("returns the latest undecided approval", () => {
     const session = newSession();
     session.blocks = [
@@ -62,15 +77,15 @@ describe("isSessionConversationFocused", () => {
   it("is true only when the session pane is focused on the active tab", () => {
     const session = newSession();
     const tab = newTab(session.id);
-    expect(
-      isSessionConversationFocused(session.id, tab.id, [tab], true),
-    ).toBe(true);
-    expect(
-      isSessionConversationFocused(session.id, tab.id, [tab], false),
-    ).toBe(false);
-    expect(
-      isSessionConversationFocused("other", tab.id, [tab], true),
-    ).toBe(false);
+    expect(isSessionConversationFocused(session.id, tab.id, [tab], true)).toBe(
+      true,
+    );
+    expect(isSessionConversationFocused(session.id, tab.id, [tab], false)).toBe(
+      false,
+    );
+    expect(isSessionConversationFocused("other", tab.id, [tab], true)).toBe(
+      false,
+    );
   });
 });
 
diff --git a/src/lib/approvalToast.ts b/src/lib/approvalToast.ts
index d217f484..1ee1f5ab 100644
--- a/src/lib/approvalToast.ts
+++ b/src/lib/approvalToast.ts
@@ -62,6 +62,8 @@ export function hiddenApprovalNotices(
   const notices: Array<PendingApprovalNotice & { session: Session }> = [];
   for (const session of sessions) {
     if (session.inboxAsk) continue;
+    // An orchestrated worker answers to its lead, never to the user directly.
+    if (session.orchestrationLeadId) continue;
     const pending = pendingApprovalForSession(session);
     if (!pending) continue;
     if (
diff --git a/src/lib/harness/apply.ts b/src/lib/harness/apply.ts
index 2108d053..160dd082 100644
--- a/src/lib/harness/apply.ts
+++ b/src/lib/harness/apply.ts
@@ -354,12 +354,14 @@ function lastMatchingBlock(
 type UserTurnExtra = {
   secondOpinion?: Block["secondOpinion"];
   noteCard?: Block["noteCard"];
+  internal?: boolean;
 };
 
 function userTurnFields(extra?: UserTurnExtra) {
   return {
     ...(extra?.secondOpinion ? { secondOpinion: extra.secondOpinion } : {}),
     ...(extra?.noteCard ? { noteCard: extra.noteCard } : {}),
+    ...(extra?.internal ? { internal: true } : {}),
   };
 }
 
@@ -521,6 +523,16 @@ export function promoteLastAssistantToPlan(
 
 function stopBlockProgress(block: Block): Block {
   let stopped = block.streaming ? { ...block, streaming: false } : block;
+  if (stopped.orchestration?.status === "planning") {
+    stopped = {
+      ...stopped,
+      orchestration: {
+        ...stopped.orchestration,
+        status: "invalid",
+        error: "Planning was interrupted. Generate the assignments again.",
+      },
+    };
+  }
   if (stopped.role === "plan" && stopped.plan?.status === "streaming") {
     stopped = {
       ...stopped,
diff --git a/src/lib/harness/codex.ts b/src/lib/harness/codex.ts
index 5fb130c4..bf36b46d 100644
--- a/src/lib/harness/codex.ts
+++ b/src/lib/harness/codex.ts
@@ -415,6 +415,7 @@ async function ensureLive(input: HarnessSessionInput): Promise<Live> {
             ...buildThreadStartParams({
               cwd: input.cwd,
               runtimeMode: input.runtimeMode,
+              controlsAgents: input.controlsAgents,
               model,
               serviceTier,
             }),
@@ -434,6 +435,7 @@ async function ensureLive(input: HarnessSessionInput): Promise<Live> {
         buildThreadStartParams({
           cwd: input.cwd,
           runtimeMode: input.runtimeMode,
+          controlsAgents: input.controlsAgents,
           model,
           serviceTier,
         }),
@@ -497,6 +499,7 @@ async function runTurn(live: Live, input: SendTurnInput): Promise<void> {
   const params = buildTurnStartParams({
     threadId: live.threadId,
     runtimeMode: input.runtimeMode,
+    controlsAgents: input.controlsAgents,
     prompt: input.text.trim() || undefined,
     attachments: input.attachments,
     model,
diff --git a/src/lib/harness/codexProtocol.test.ts b/src/lib/harness/codexProtocol.test.ts
index fb8ba9aa..7c35f2f9 100644
--- a/src/lib/harness/codexProtocol.test.ts
+++ b/src/lib/harness/codexProtocol.test.ts
@@ -21,6 +21,21 @@ describe("runtimeModeToCodexConfig", () => {
     });
   });
 
+  it("opens loopback for a lead, since every sandbox denies network by default", () => {
+    // Without this an orchestration lead cannot reach its own control CLI.
+    for (const mode of ["supervised", "auto-accept-edits", "auto"] as const)
+      expect(
+        runtimeModeToCodexConfig(mode, true).sandboxPolicy,
+      ).toMatchObject({ networkAccess: true });
+    // Ordinary sessions keep the default, and full access needs no flag.
+    expect(runtimeModeToCodexConfig("auto").sandboxPolicy).not.toHaveProperty(
+      "networkAccess",
+    );
+    expect(runtimeModeToCodexConfig("full-access", true).sandboxPolicy).toEqual({
+      type: "dangerFullAccess",
+    });
+  });
+
   it("maps auto-accept-edits to workspace-write with user reviewer", () => {
     expect(runtimeModeToCodexConfig("auto-accept-edits")).toMatchObject({
       approvalPolicy: "on-request",
@@ -38,6 +53,45 @@ describe("runtimeModeToCodexConfig", () => {
     });
   });
 
+  it("opens the sandbox network only for a lead, which needs the control socket", () => {
+    // Both sandboxed policies default networkAccess to false, which denies
+    // loopback too, so the control CLI cannot reach MonoCode without this.
+    for (const mode of ["supervised", "auto-accept-edits", "auto"] as const) {
+      expect(runtimeModeToCodexConfig(mode).sandboxPolicy).not.toHaveProperty(
+        "networkAccess",
+      );
+      expect(runtimeModeToCodexConfig(mode, true).sandboxPolicy).toMatchObject({
+        networkAccess: true,
+      });
+    }
+    // full-access already permits it, and its policy takes no such field.
+    expect(runtimeModeToCodexConfig("full-access", true).sandboxPolicy).toEqual({
+      type: "dangerFullAccess",
+    });
+  });
+
+  it("carries the lead's network grant onto the turn, including a plan turn", () => {
+    expect(
+      buildTurnStartParams({
+        threadId: "t",
+        runtimeMode: "auto",
+        controlsAgents: true,
+      }).sandboxPolicy,
+    ).toMatchObject({ type: "workspaceWrite", networkAccess: true });
+    expect(
+      buildTurnStartParams({
+        threadId: "t",
+        runtimeMode: "auto",
+        controlsAgents: true,
+        intent: "plan",
+      }).sandboxPolicy,
+    ).toMatchObject({ type: "readOnly", networkAccess: true });
+    expect(
+      buildTurnStartParams({ threadId: "t", runtimeMode: "auto" })
+        .sandboxPolicy,
+    ).not.toHaveProperty("networkAccess");
+  });
+
   it("allows explicit escalation requests in full-access", () => {
     expect(runtimeModeToCodexConfig("full-access")).toMatchObject({
       approvalPolicy: "on-request",
diff --git a/src/lib/harness/codexProtocol.ts b/src/lib/harness/codexProtocol.ts
index d7faae95..cdf46e6f 100644
--- a/src/lib/harness/codexProtocol.ts
+++ b/src/lib/harness/codexProtocol.ts
@@ -27,12 +27,36 @@ export type CodexThreadConfig = {
   sandbox: "read-only" | "workspace-write" | "danger-full-access";
   approvalsReviewer: "user" | "auto_review";
   sandboxPolicy:
-    | { type: "readOnly" }
-    | { type: "workspaceWrite" }
+    | { type: "readOnly"; networkAccess?: boolean }
+    | { type: "workspaceWrite"; networkAccess?: boolean }
     | { type: "dangerFullAccess" };
 };
 
-export function runtimeModeToCodexConfig(mode: RuntimeMode): CodexThreadConfig {
+/**
+ * `readOnly` and `workspaceWrite` both default to networkAccess: false, which
+ * blocks loopback too. An orchestration lead has to reach the control CLI's
+ * socket, so it opts in; every other session keeps the default.
+ */
+function withNetwork(
+  config: CodexThreadConfig,
+  controlsAgents?: boolean,
+): CodexThreadConfig {
+  if (!controlsAgents || config.sandboxPolicy.type === "dangerFullAccess")
+    return config;
+  return {
+    ...config,
+    sandboxPolicy: { ...config.sandboxPolicy, networkAccess: true },
+  };
+}
+
+export function runtimeModeToCodexConfig(
+  mode: RuntimeMode,
+  controlsAgents?: boolean,
+): CodexThreadConfig {
+  return withNetwork(baseCodexConfig(mode), controlsAgents);
+}
+
+function baseCodexConfig(mode: RuntimeMode): CodexThreadConfig {
   switch (mode) {
     case "supervised":
       return {
@@ -70,14 +94,19 @@ export function runtimeModeToCodexConfig(mode: RuntimeMode): CodexThreadConfig {
 export function buildThreadStartParams(input: {
   cwd: string;
   runtimeMode: RuntimeMode;
+  controlsAgents?: boolean;
   model?: string;
   serviceTier?: string;
 }): Record<string, unknown> {
-  const config = runtimeModeToCodexConfig(input.runtimeMode);
+  const config = runtimeModeToCodexConfig(
+    input.runtimeMode,
+    input.controlsAgents,
+  );
   return {
     cwd: input.cwd,
     approvalPolicy: config.approvalPolicy,
     sandbox: config.sandbox,
+    sandboxPolicy: config.sandboxPolicy,
     approvalsReviewer: config.approvalsReviewer,
     ...(input.model ? { model: input.model } : {}),
     ...(input.serviceTier && input.serviceTier !== "default"
@@ -102,6 +131,7 @@ export function buildTurnSteerParams(input: {
 export function buildTurnStartParams(input: {
   threadId: string;
   runtimeMode: RuntimeMode;
+  controlsAgents?: boolean;
   prompt?: string;
   attachments?: Attachment[];
   model?: string;
@@ -109,15 +139,21 @@ export function buildTurnStartParams(input: {
   serviceTier?: string;
   intent?: TurnIntent;
 }): Record<string, unknown> {
-  const runtimeConfig = runtimeModeToCodexConfig(input.runtimeMode);
+  const runtimeConfig = runtimeModeToCodexConfig(
+    input.runtimeMode,
+    input.controlsAgents,
+  );
   const config: CodexThreadConfig =
     input.intent === "plan"
-      ? {
-          approvalPolicy: "never",
-          sandbox: "read-only",
-          approvalsReviewer: runtimeConfig.approvalsReviewer,
-          sandboxPolicy: { type: "readOnly" },
-        }
+      ? withNetwork(
+          {
+            approvalPolicy: "never",
+            sandbox: "read-only",
+            approvalsReviewer: runtimeConfig.approvalsReviewer,
+            sandboxPolicy: { type: "readOnly" },
+          },
+          input.controlsAgents,
+        )
       : runtimeConfig;
   return {
     threadId: input.threadId,
diff --git a/src/lib/harness/registry.ts b/src/lib/harness/registry.ts
index 648165b2..5b07953d 100644
--- a/src/lib/harness/registry.ts
+++ b/src/lib/harness/registry.ts
@@ -1,4 +1,5 @@
 import type { HarnessId } from "../session";
+import { invoke, isTauri } from "@tauri-apps/api/core";
 import type { GeneratedSessionTitle } from "../sessionTitle";
 import type { PrContent } from "../gitText";
 import { hasLiveCatalog } from "../models";
@@ -131,9 +132,17 @@ export async function sendHarnessTurn(
     throw new Error(`${input.harness} is not connected yet`);
   }
   cancelIdlePark(input.sessionId);
+  const controlled = typeof isTauri === "function" && isTauri();
+  if (controlled)
+    await invoke("control_authorize_turn", {
+      sessionId: input.sessionId,
+      cwd: input.cwd,
+    });
   try {
     await adapter.sendTurn(input);
   } finally {
+    if (controlled)
+      await invoke("control_turn_finished", { sessionId: input.sessionId });
     scheduleIdlePark(input.harness, input.sessionId);
   }
 }
diff --git a/src/lib/harness/types.ts b/src/lib/harness/types.ts
index acf05c26..562372e3 100644
--- a/src/lib/harness/types.ts
+++ b/src/lib/harness/types.ts
@@ -130,6 +130,12 @@ export type HarnessSessionInput = {
   modelSettings?: Record<string, string>;
   runtimeMode: RuntimeMode;
   intent?: TurnIntent;
+  /**
+   * This session drives MonoCode's control CLI, which reaches the app over
+   * loopback. Sandboxes deny network by default, so a lead that cannot open
+   * that socket cannot supervise its agents at all.
+   */
+  controlsAgents?: boolean;
   onEvent: (event: HarnessEvent) => void;
 };
 
diff --git a/src/lib/layout.ts b/src/lib/layout.ts
index 8d56f256..ee909241 100644
--- a/src/lib/layout.ts
+++ b/src/lib/layout.ts
@@ -5,6 +5,7 @@ import {
   defaultTerminalTitle,
   type TerminalMetaPatch,
 } from "./terminalTab";
+import type { HarnessId } from "./session";
 
 /**
  * Split tree for a tab. Same-direction splits share a group so
@@ -42,6 +43,13 @@ export type CommitTabSource = {
   subject: string;
 };
 
+/** One orchestration worker, opened for inspection beside its lead. */
+export type AgentTabSource = {
+  sessionId: string;
+  leadId: string;
+  harness: HarnessId;
+};
+
 export type SessionChangesSource = {
   sessionId: string;
 };
@@ -61,6 +69,8 @@ export type FilePaneTab = {
   sessionChanges?: SessionChangesSource;
   /** Historical commit review (unified diff, read-only). */
   commit?: CommitTabSource;
+  /** Read-only transcript of an orchestration worker. Live only — not persisted. */
+  agent?: AgentTabSource;
   terminal?: boolean;
   /** Foreground command when it isn't the shell. Live only — not persisted. */
   foreground?: string;
@@ -207,6 +217,15 @@ export function newReleaseNotesWorkspaceTab(
   };
 }
 
+/** `path` carries the label: an agent tab has no file behind it. */
+export function newAgentTab(
+  title: string,
+  cwd: string,
+  agent: AgentTabSource,
+): FilePaneTab {
+  return { id: crypto.randomUUID(), path: title, cwd, agent };
+}
+
 export function newTerminalFile(cwd: string, title?: string): FilePaneTab {
   return {
     id: crypto.randomUUID(),
@@ -319,8 +338,19 @@ export function isTerminalTab(file: FilePaneTab): boolean {
   return !!file.terminal;
 }
 
+export function isAgentTab(
+  file: FilePaneTab,
+): file is FilePaneTab & { agent: AgentTabSource } {
+  return !!file.agent;
+}
+
 export function isVirtualDocumentTab(file: FilePaneTab): boolean {
-  return isPlanTab(file) || isReleaseNotesTab(file) || isCommitTab(file);
+  return (
+    isPlanTab(file) ||
+    isReleaseNotesTab(file) ||
+    isCommitTab(file) ||
+    isAgentTab(file)
+  );
 }
 
 export function isFilesystemTab(file: FilePaneTab): boolean {
@@ -399,6 +429,7 @@ export function isSessionChangesTab(
 
 export function editorTabKey(file: FilePaneTab): string {
   if (file.terminal) return `terminal:${file.id}`;
+  if (file.agent) return `agent:${file.agent.sessionId}`;
   if (file.plan) return `plan:${file.plan.blockId}`;
   if (file.releaseNotes) return `release-notes:${file.releaseNotes.version}`;
   if (file.commit) return `commit:${file.cwd}:${file.commit.sha}`;
diff --git a/src/lib/liveAgents.test.ts b/src/lib/liveAgents.test.ts
index cd7beffe..ce3f1790 100644
--- a/src/lib/liveAgents.test.ts
+++ b/src/lib/liveAgents.test.ts
@@ -28,6 +28,11 @@ function edit(id: string, path = "src/App.tsx", status = "in_progress"): Block {
 }
 
 describe("liveAgentsFromSessions", () => {
+  it("keeps internal workers in their lead's agent panel", () => {
+    const lead = chat("/repo", { id: "lead", busy: true });
+    const worker = chat("/repo", { id: "worker", busy: true, orchestrationLeadId: "lead" });
+    expect(liveAgentsFromSessions([lead, worker]).map((agent) => agent.id)).toEqual(["lead"]);
+  });
   it("skips idle sessions", () => {
     expect(liveAgentsFromSessions([chat("/tmp/a")])).toEqual([]);
   });
diff --git a/src/lib/liveAgents.ts b/src/lib/liveAgents.ts
index 8e6350e2..93d77914 100644
--- a/src/lib/liveAgents.ts
+++ b/src/lib/liveAgents.ts
@@ -27,7 +27,7 @@ export function liveAgentsFromSessions(
   return sessions
     .filter(
       (session) =>
-        !session.inboxAsk && (isInFlightSession(session) || unseenFinishedIds.has(session.id)),
+        !session.inboxAsk && !session.orchestrationLeadId && (isInFlightSession(session) || unseenFinishedIds.has(session.id)),
     )
     .map((session) =>
       toLiveAgent(session, unseenFinishedIds.has(session.id)),
diff --git a/src/lib/orchestration.test.ts b/src/lib/orchestration.test.ts
new file mode 100644
index 00000000..2fcd9eb6
--- /dev/null
+++ b/src/lib/orchestration.test.ts
@@ -0,0 +1,792 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  Orchestrator,
+  scopesOverlap,
+  visibleUserPrompt,
+  workerTurnPrompt,
+  type ControlOutcome,
+  type OrchestrationHost,
+  type OrchestrationRun,
+  shellPath,
+} from "./orchestration";
+import { newSession } from "./session";
+import type { OrchestrationProposal } from "./orchestrationPlan";
+
+function setup() {
+  const saved = new Map<string, OrchestrationRun>();
+  const store = {
+    save: vi.fn(async (run: OrchestrationRun) => {
+      saved.set(run.leadId, structuredClone(run));
+    }),
+    load: vi.fn(async (id: string) => saved.get(id) ?? null),
+    enable: vi.fn(
+      async () => "/Applications/MonoCode.app/Contents/MacOS/monocode",
+    ),
+    disable: vi.fn(async () => {}),
+    scopes: vi.fn(async (_cwd: string, files: string[]) =>
+      files.map((file) => (file === "." ? "/repo" : `/repo/${file}`)),
+    ),
+  };
+  const manager = new Orchestrator(store);
+  const lead = { ...newSession("claude", "/repo"), id: "lead", busy: true };
+  const sessions = [lead];
+  const completions = new Map<string, (outcome: ControlOutcome) => void>();
+  const host: OrchestrationHost = {
+    session: (id) => sessions.find((session) => session.id === id),
+    sessions: () => sessions,
+    choices: () => [
+      { harness: "codex", models: [{ id: "codex:test", name: "Test" }] },
+    ],
+    createWorker: vi.fn(async (run, task) => {
+      sessions.push({
+        ...newSession(task.harness, run.cwd),
+        id: task.sessionId,
+        busy: false,
+      });
+    }),
+    submit: vi.fn((id, _text, done) => {
+      const session = sessions.find((session) => session.id === id)!;
+      session.busy = true;
+      completions.set(id, (outcome) => {
+        session.busy = false;
+        done(outcome);
+      });
+    }),
+    stop: vi.fn(async (id) => {
+      const session = sessions.find((entry) => entry.id === id);
+      if (session) session.busy = false;
+    }),
+    steer: vi.fn(async () => {}),
+    respondApproval: vi.fn(),
+    answerQuestion: vi.fn(),
+  };
+  manager.bind(host);
+  let request = 0;
+  const call = (
+    action: string,
+    input: Record<string, unknown> = {},
+    id = `request-${++request}`,
+  ) => manager.handle("lead", id, action, input);
+  const start = async () => {
+    lead.busy = false;
+    await manager.start("lead", ["codex"], 2);
+    lead.busy = true;
+  };
+  const delegate = (files: string[], extra = {}) =>
+    call("delegate", {
+      title: "Task",
+      prompt: "Implement the bounded change",
+      harness: "codex",
+      files,
+      ...extra,
+    });
+  const tasks = () => manager.run("lead")!.tasks;
+  return {
+    manager,
+    store,
+    host,
+    lead,
+    saved,
+    sessions,
+    start,
+    call,
+    delegate,
+    tasks,
+    completions,
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("worker assignment prompts", () => {
+  it("keeps the task text and wraps it in the assignment envelope", () => {
+    const sent = workerTurnPrompt("Review the branch.", ["src/App.tsx"]);
+    expect(sent.startsWith("Review the branch.")).toBe(true);
+    expect(sent).toContain("<monocode_assignment>");
+    expect(sent).toContain("src/App.tsx");
+    expect(visibleUserPrompt(sent)).toBe("Review the branch.");
+  });
+});
+
+describe("local orchestration", () => {
+  it("stops and forgets a deleted lead without persisting it again", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    const remove = vi.fn(async () => {
+      expect(f.lead.busy).toBe(false);
+      expect(f.manager.run("lead")?.status).toBe("stopped");
+      f.saved.delete("lead");
+    });
+    await f.manager.deleteSession("lead", remove);
+    expect(remove).toHaveBeenCalledOnce();
+    expect(f.host.stop).toHaveBeenCalledWith(task.sessionId);
+    expect(f.manager.snapshot()).toEqual([]);
+    f.store.save.mockClear();
+    f.completions.get(task.sessionId)?.({
+      status: "completed",
+      text: "Late result",
+    });
+    await f.manager.hydrate("lead");
+    f.manager.sync();
+    await Promise.resolve();
+    expect(f.manager.snapshot()).toEqual([]);
+    expect(f.store.save).not.toHaveBeenCalled();
+  });
+
+  it("reloads a deleted worker's pruned run and preserves state if deletion fails", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    await expect(
+      f.manager.deleteSession(task.sessionId, async () => {
+        throw new Error("Delete failed");
+      }),
+    ).rejects.toThrow("Delete failed");
+    expect(f.tasks()).toHaveLength(1);
+    expect(f.manager.run("lead")?.status).toBe("stopped");
+    await f.manager.deleteSession(task.sessionId, async () => {
+      f.saved.set("lead", { ...f.saved.get("lead")!, tasks: [], requests: {} });
+      f.store.save.mockClear();
+    });
+    expect(f.tasks()).toEqual([]);
+    expect(f.manager.forSession(task.sessionId)).toBeUndefined();
+    expect(f.store.save).not.toHaveBeenCalled();
+  });
+
+  const proposal = (): OrchestrationProposal => ({
+    version: 1,
+    leadId: "lead",
+    cwd: "/repo",
+    request: "Build settings",
+    author: { harness: "claude", model: "claude:test", name: "Lead" },
+    settings: {
+      choices: [{ harness: "codex", model: "codex:test", name: "Test" }],
+      maxWorkers: 2,
+    },
+    status: "ready",
+    title: "Settings",
+    summary: "Split the work",
+    tasks: [
+      {
+        id: "ui",
+        title: "UI",
+        prompt: "User edited instructions",
+        harness: "codex",
+        model: "codex:test",
+        files: ["src/ui"],
+        dependsOn: ["types"],
+      },
+      {
+        id: "types",
+        title: "Types",
+        prompt: "Define the types",
+        harness: "codex",
+        model: "codex:test",
+        files: ["src/types"],
+        dependsOn: [],
+      },
+    ],
+  });
+  it("starts exactly the approved assignments and preserves forward dependencies", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    expect(f.host.submit).not.toHaveBeenCalled();
+    await f.manager.startApproved("lead", "card", proposal());
+    await vi.waitFor(() =>
+      expect(f.host.createWorker).toHaveBeenCalledTimes(1),
+    );
+    expect(f.tasks().map((task) => task.status)).toEqual(["queued", "running"]);
+    expect(f.tasks()[0].prompt).toBe("User edited instructions");
+    expect(f.tasks()[0].dependsOn).toEqual([f.tasks()[1].id]);
+    expect(f.manager.run("lead")?.proposalId).toBe("card");
+    expect(f.saved.get("lead")?.tasks).toHaveLength(2);
+    const workerPrompt = vi
+      .mocked(f.host.submit)
+      .mock.calls.find(
+        ([id, prompt]) =>
+          id !== "lead" && String(prompt).includes("<monocode_assignment>"),
+      )?.[1];
+    expect(workerPrompt).toContain("Define the types");
+    expect(workerPrompt).toContain("<monocode_assignment>");
+    expect(
+      vi.mocked(f.host.submit).mock.calls.find(([id]) => id === "lead")?.[1],
+    ).toContain("do not delegate duplicates");
+  });
+  it("never launches a partial plan when one assignment has invalid scopes", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    f.store.scopes.mockRejectedValueOnce(new Error("Scope escapes project"));
+    await expect(
+      f.manager.startApproved("lead", "card", proposal()),
+    ).rejects.toThrow("Scope escapes");
+    expect(f.store.enable).not.toHaveBeenCalled();
+    expect(f.host.submit).not.toHaveBeenCalled();
+  });
+  it("requires a ready proposal and enforces the exact model pool for later CLI calls", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    await expect(
+      f.manager.startApproved("lead", "card", {
+        ...proposal(),
+        status: "planning",
+      }),
+    ).rejects.toThrow("completed proposal");
+    f.host.choices = () => [
+      {
+        harness: "codex",
+        models: [
+          { id: "codex:test", name: "Test" },
+          { id: "codex:extra", name: "Unselected" },
+        ],
+      },
+    ];
+    await f.manager.startApproved("lead", "card", proposal());
+    const result = (await f.call("list")) as {
+      harnesses: { models: { id: string }[] }[];
+    };
+    expect(result.harnesses[0].models.map((model) => model.id)).toEqual([
+      "codex:test",
+    ]);
+    await expect(
+      f.delegate(["extra"], { model: "codex:extra" }),
+    ).rejects.toThrow("model ID returned by list");
+  });
+  it("does not duplicate work when confirmation is repeated", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    const results = await Promise.allSettled([
+      f.manager.startApproved("lead", "card", proposal()),
+      f.manager.startApproved("lead", "card", proposal()),
+    ]);
+    expect(
+      results.filter((result) => result.status === "fulfilled"),
+    ).toHaveLength(1);
+    expect(f.store.enable).toHaveBeenCalledTimes(1);
+    expect(f.tasks()).toHaveLength(2);
+  });
+  it("ignores unavailable unused catalog models but blocks an unavailable assignment", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    const card = proposal();
+    card.settings.choices.push({
+      harness: "claude",
+      model: "claude:removed",
+      name: "Removed",
+    });
+    await f.manager.startApproved("lead", "card", card);
+    expect(f.manager.run("lead")?.allowedHarnesses).toEqual(["codex"]);
+    expect(f.manager.run("lead")?.allowedModels).toEqual(
+      proposal().settings.choices,
+    );
+
+    const unavailable = setup();
+    unavailable.lead.busy = false;
+    card.tasks[0] = {
+      ...card.tasks[0],
+      harness: "claude",
+      model: "claude:removed",
+    };
+    await expect(
+      unavailable.manager.startApproved("lead", "card", card),
+    ).rejects.toThrow("An assigned model is no longer available");
+    expect(unavailable.store.enable).not.toHaveBeenCalled();
+    expect(unavailable.host.submit).not.toHaveBeenCalled();
+  });
+  it("treats directory scopes as overlapping only at path boundaries", () => {
+    expect(scopesOverlap(["/repo/src"], ["/repo/src/file.ts"])).toBe(true);
+    expect(scopesOverlap(["/repo/src"], ["/repo/src2/file.ts"])).toBe(false);
+    expect(scopesOverlap(["/repo"], ["/repo/anything"])).toBe(true);
+  });
+  it("runs disjoint workers concurrently and queues overlap", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/a"]);
+    await f.delegate(["src/b"]);
+    await f.delegate(["src/a/file.ts"]);
+    await vi.waitFor(() =>
+      expect(f.tasks().map((task) => task.status)).toEqual([
+        "running",
+        "running",
+        "queued",
+      ]),
+    );
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Implemented A",
+    });
+    await vi.waitFor(() => expect(f.tasks()[2].status).toBe("running"));
+    expect(f.tasks()[0].accepted).toBe(false);
+  });
+  it("keeps a dependency queued until the lead accepts the upstream result", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/types.ts"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const upstream = f.tasks()[0];
+    await f.delegate(["src/ui"], { dependsOn: [upstream.id] });
+    f.completions.get(upstream.sessionId)!({
+      status: "completed",
+      text: "Types ready",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("completed"));
+    expect(f.tasks()[1].status).toBe("queued");
+    await f.call("review", { taskId: upstream.id });
+    await vi.waitFor(() => expect(f.tasks()[1].status).toBe("running"));
+  });
+  it("deduplicates command retries and rejects foreign tasks or unapproved harnesses", async () => {
+    const f = setup();
+    await f.start();
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    const first = await f.call("delegate", input, "same");
+    expect(await f.call("delegate", input, "same")).toEqual(first);
+    expect(f.tasks()).toHaveLength(1);
+    await expect(
+      f.call("delegate", { ...input, title: "B" }, "same"),
+    ).rejects.toThrow("different input");
+    await expect(f.call("get", { taskId: "foreign" })).rejects.toThrow(
+      "does not belong",
+    );
+    await expect(f.delegate(["a"], { harness: "pi" })).rejects.toThrow(
+      "not allowed",
+    );
+  });
+  it("does not dispatch a worker if its task cannot be persisted", async () => {
+    const f = setup();
+    await f.start();
+    f.store.save.mockRejectedValueOnce(new Error("Disk full"));
+    await expect(f.delegate(["a"])).rejects.toThrow("Disk full");
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.host.submit).not.toHaveBeenCalled();
+  });
+  it("persists a delegation and its retry receipt in the same snapshot", async () => {
+    const f = setup();
+    await f.start();
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    await f.call("delegate", input, "durable");
+    const firstTaskSave = f.store.save.mock.calls.find(
+      ([run]) => run.tasks.length === 1,
+    )![0];
+    expect(firstTaskSave.requests.durable.result).toMatchObject({
+      taskId: firstTaskSave.tasks[0].id,
+    });
+    const restored = new Orchestrator(f.store);
+    restored.bind(f.host);
+    await restored.hydrate("lead");
+    expect(await restored.handle("lead", "durable", "delegate", input)).toEqual(
+      firstTaskSave.requests.durable.result,
+    );
+    expect(restored.run("lead")!.tasks).toHaveLength(1);
+  });
+  it("rejects conflicting reuse of an in-flight request ID", async () => {
+    const f = setup();
+    await f.start();
+    let release!: (paths: string[]) => void;
+    f.store.scopes.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          release = resolve;
+        }),
+    );
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    const pending = f.call("delegate", input, "pending");
+    await vi.waitFor(() => expect(f.store.scopes).toHaveBeenCalled());
+    await expect(
+      f.call("delegate", { ...input, files: ["b"] }, "pending"),
+    ).rejects.toThrow("different input");
+    release(["/repo/a"]);
+    await pending;
+    expect(f.tasks()).toHaveLength(1);
+  });
+  it("stops an active worker if saving another assignment fails", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.store.save.mockRejectedValueOnce(new Error("Disk full"));
+    await expect(f.delegate(["b"])).rejects.toThrow("Disk full");
+    expect(f.host.stop).toHaveBeenCalledWith(f.tasks()[0].sessionId);
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("pauses and stops workers when a reported write escapes its scope", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.manager.observe(f.tasks()[0].sessionId, {
+      type: "tool.started",
+      callId: "edit",
+      title: "Edit",
+      preview: { kind: "write", path: "src/a/../b/file.ts" },
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("cancelled"));
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.manager.run("lead")!.error).toContain("outside its assignment");
+  });
+  it("holds ownership until a cancelled process has stopped", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    let stopped!: () => void;
+    vi.mocked(f.host.stop).mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          stopped = resolve;
+        }),
+    );
+    const cancel = f.call("cancel", { taskId: f.tasks()[0].id });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("cancelling"));
+    expect(f.tasks()[1].status).toBe("queued");
+    stopped();
+    await cancel;
+    await vi.waitFor(() => expect(f.tasks()[1].status).toBe("running"));
+  });
+  it("stops queued work and suppresses lead continuation on stop", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const done = f.completions.get(f.tasks()[0].sessionId)!;
+    await f.manager.stopRun("lead");
+    done({ status: "completed", text: "late output" });
+    f.lead.busy = false;
+    f.manager.sync();
+    expect(f.tasks().map((task) => task.status)).toEqual([
+      "cancelled",
+      "cancelled",
+    ]);
+    expect(f.manager.run("lead")!.status).toBe("stopped");
+    expect(f.store.disable).toHaveBeenCalledWith("lead");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("returns worker output to an idle lead once", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.lead.busy = false;
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Tests pass",
+    });
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(2));
+    expect(vi.mocked(f.host.submit).mock.calls[1][0]).toBe("lead");
+    expect(vi.mocked(f.host.submit).mock.calls[1][1]).toContain("Tests pass");
+    f.manager.sync();
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+  });
+  it("keeps results available and pauses when the lead cannot continue", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.lead.busy = false;
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Result",
+    });
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(2));
+    f.completions.get("lead")!({
+      status: "failed",
+      text: "",
+      error: "Provider unavailable",
+    });
+    await vi.waitFor(() =>
+      expect(f.manager.run("lead")!.status).toBe("paused"),
+    );
+    expect(f.tasks()[0].delivered).toBe(false);
+    f.manager.sync();
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+  });
+  it("recovers interrupted tasks as failed instead of re-executing edits", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    await vi.waitFor(() =>
+      expect(f.saved.get("lead")?.tasks[0].status).toBe("running"),
+    );
+    const restored = new Orchestrator(f.store);
+    restored.bind(f.host);
+    await restored.hydrate("lead");
+    expect(restored.run("lead")?.status).toBe("paused");
+    expect(restored.run("lead")?.tasks[0].status).toBe("failed");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("does not claim a turn or run is successful before review", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await expect(f.call("finish")).rejects.toThrow("Review all");
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "failed",
+      text: "Partial edits",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("failed"));
+    await expect(f.call("review", { taskId: f.tasks()[0].id })).rejects.toThrow(
+      "Only a completed",
+    );
+  });
+  it("names the way out of a run that cannot finish yet", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "failed",
+      text: "",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("failed"));
+    // A failed task can never be reviewed, so both exits must be spelled out.
+    await expect(f.call("review", { taskId: f.tasks()[0].id })).rejects.toThrow(
+      /message.*cancel/,
+    );
+    await expect(f.call("finish")).rejects.toThrow(/Task \(failed\)/);
+    await expect(f.call("finish")).rejects.toThrow(/message.*cancel/);
+    await f.call("cancel", { taskId: f.tasks()[0].id });
+    expect(await f.call("finish")).toEqual({ finished: true });
+  });
+  it("rejects mistyped fields instead of silently dropping them", async () => {
+    const f = setup();
+    await f.start();
+    // Silently ignoring depends_on would race two workers over one file.
+    await expect(
+      f.delegate(["a"], { depends_on: [], modelId: "codex:test" }),
+    ).rejects.toThrow("Unknown delegate fields: depends_on, modelId");
+    await expect(f.call("finish", { taskId: "x" })).rejects.toThrow(
+      "finish takes no input",
+    );
+    await expect(f.call("wait", { timeout: 5 })).rejects.toThrow(
+      "wait accepts: timeoutSeconds",
+    );
+    expect(f.tasks()).toHaveLength(0);
+  });
+  it("points a bad delegate at the values list would have returned", async () => {
+    const f = setup();
+    await f.start();
+    await expect(f.delegate(["a"], { harness: "claude" })).rejects.toThrow(
+      'Harness "claude" is not allowed in this run. Allowed: codex.',
+    );
+    await expect(f.delegate(["a"], { model: "codex:ghost" })).rejects.toThrow(
+      "Choose a model ID returned by list for codex: codex:test.",
+    );
+    await expect(f.delegate([], {})).rejects.toThrow("at least one file");
+    await expect(
+      f.call("delegate", {
+        title: "T",
+        prompt: "P",
+        harness: "codex",
+        files: ["a"],
+        dependsOn: ["nope"],
+      }),
+    ).rejects.toThrow("unknown or cancelled: nope");
+  });
+  it("keeps the retry ledger free of inherited object keys", async () => {
+    const f = setup();
+    await f.start();
+    const first = await f.call(
+      "delegate",
+      {
+        title: "A",
+        prompt: "Implement",
+        harness: "codex",
+        files: ["a"],
+      },
+      "constructor",
+    );
+    expect(first).toHaveProperty("taskId");
+  });
+  it("quotes the control path only when the shell needs it", () => {
+    expect(
+      shellPath("/Applications/MonoCode.app/Contents/MacOS/monocode"),
+    ).toBe("/Applications/MonoCode.app/Contents/MacOS/monocode");
+    expect(shellPath("/Users/a b/MonoCode")).toBe("'/Users/a b/MonoCode'");
+    expect(shellPath("C:/Program Files/MonoCode/monocode.exe")).toBe(
+      '"C:/Program Files/MonoCode/monocode.exe"',
+    );
+    expect(shellPath("C:\\Tools\\monocode.exe")).toBe("C:\\Tools\\monocode.exe");
+    // A backslash escapes in a POSIX shell, so bare would rewrite the path.
+    expect(shellPath("/Users/a\\b/MonoCode")).toBe("'/Users/a\\b/MonoCode'");
+    expect(shellPath("/Users/it's/MonoCode")).toBe("'/Users/it'\\''s/MonoCode'");
+  });
+  it("treats an action named after an Object member as unknown", async () => {
+    const f = setup();
+    await f.start();
+    for (const action of ["constructor", "toString", "__proto__"])
+      await expect(f.call(action)).rejects.toThrow(
+        `Unknown action "${action}"`,
+      );
+  });
+  it("routes a blocked agent to the lead instead of the user", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const worker = f.sessions.find(
+      (session) => session.id === f.tasks()[0].sessionId,
+    )!;
+    worker.blocks = [
+      {
+        id: "ask",
+        role: "approval",
+        text: "rm -rf build",
+        approval: { requestId: 7 },
+      },
+    ];
+    const view = (await f.call("get", { taskId: f.tasks()[0].id })) as {
+      needsInput?: { kind: string; requestId: number };
+    };
+    expect(view.needsInput).toMatchObject({ kind: "approval", requestId: 7 });
+    // A stale or invented requestId must never decide a live prompt.
+    await expect(
+      f.call("respond", {
+        taskId: f.tasks()[0].id,
+        requestId: 6,
+        decision: "allow",
+      }),
+    ).rejects.toThrow("Stale requestId");
+    await expect(
+      f.call("respond", {
+        taskId: f.tasks()[0].id,
+        requestId: 7,
+        decision: "maybe",
+      }),
+    ).rejects.toThrow('decision must be "allow" or "deny"');
+    await f.call("respond", {
+      taskId: f.tasks()[0].id,
+      requestId: 7,
+      decision: "deny",
+    });
+    expect(f.host.respondApproval).toHaveBeenCalledWith(
+      worker.id,
+      7,
+      "deny",
+    );
+  });
+  it("validates the lead's answer against the agent's own question", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const worker = f.sessions.find(
+      (session) => session.id === f.tasks()[0].sessionId,
+    )!;
+    worker.pendingQuestion = {
+      requestId: 9,
+      title: "Pick a check",
+      questions: [
+        {
+          id: "check",
+          prompt: "Which check?",
+          multiSelect: false,
+          allowCustom: false,
+          options: [{ id: "unit", label: "Unit" }],
+        },
+      ],
+    };
+    const taskId = f.tasks()[0].id;
+    await expect(
+      f.call("answer", { taskId, requestId: 9, answers: { check: ["e2e"] } }),
+    ).rejects.toThrow("Unknown option");
+    await expect(
+      f.call("answer", { taskId, requestId: 9, answers: { nope: ["unit"] } }),
+    ).rejects.toThrow("Unknown question");
+    await f.call("answer", { taskId, requestId: 9, answers: { check: ["unit"] } });
+    expect(f.host.answerQuestion).toHaveBeenCalledWith(worker.id, 9, {
+      kind: "answered",
+      answers: { check: ["unit"] },
+    });
+  });
+  it("stops the agents whenever the lead stops supervising", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    await f.manager.startApproved("lead", "card", proposal());
+    await vi.waitFor(() =>
+      expect(f.host.createWorker).toHaveBeenCalledTimes(1),
+    );
+    const running = f.tasks().find((task) => task.title === "Types")!;
+    expect(running.status).toBe("running");
+    // The lead's turn dies. Its agents must not carry on editing the shared
+    // checkout with nobody left to review them.
+    f.completions.get("lead")!({
+      status: "failed",
+      text: "",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.manager.run("lead")!.status).toBe("paused"));
+    await vi.waitFor(() =>
+      expect(
+        f.tasks().find((task) => task.title === "Types")!.status,
+      ).toBe("cancelled"),
+    );
+    expect(f.host.stop).toHaveBeenCalledWith(running.sessionId);
+    // Queued work is untouched, so resuming picks it up intact.
+    expect(f.tasks().find((task) => task.title === "UI")!.status).toBe(
+      "queued",
+    );
+  });
+  it("steers a running agent and refuses one that is not", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    await f.call("steer", { taskId: task.id, text: "Use the existing helper" });
+    expect(f.host.steer).toHaveBeenCalledWith(
+      task.sessionId,
+      "Use the existing helper",
+    );
+    // Steering must not end the turn, so the agent keeps its work.
+    expect(f.tasks()[0].status).toBe("running");
+    expect(f.host.stop).not.toHaveBeenCalledWith(task.sessionId);
+    // A stopped agent takes a fresh turn instead, and the error says so.
+    f.completions.get(task.sessionId)!({
+      status: "completed",
+      text: "Done",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("completed"));
+    await expect(
+      f.call("steer", { taskId: task.id, text: "Too late" }),
+    ).rejects.toThrow(/Only a running agent can be steered.*message/s);
+  });
+  it("blocks ordinary sessions while a run owns their checkout", async () => {
+    const f = setup();
+    await f.start();
+    f.sessions.push({
+      ...newSession("claude", "/repo"),
+      id: "other",
+      busy: false,
+    });
+    expect(f.manager.submissionError("other")).toContain("active orchestrator");
+    expect(f.manager.submissionError("lead")).toBeNull();
+  });
+});
diff --git a/src/lib/orchestration.ts b/src/lib/orchestration.ts
new file mode 100644
index 00000000..5d10dc07
--- /dev/null
+++ b/src/lib/orchestration.ts
@@ -0,0 +1,1391 @@
+import { invoke } from "@tauri-apps/api/core";
+import { HARNESSES, type HarnessId, type Session } from "./session";
+import type { ApprovalDecision, HarnessEvent } from "./harness/types";
+import { pendingApprovalForSession } from "./approvalToast";
+import type { UserQuestionReply } from "./userQuestion";
+import {
+  validateOrchestrationSettings,
+  validateProposedTasks,
+  type OrchestrationChoice,
+  type OrchestrationProposal,
+} from "./orchestrationPlan";
+
+export type TaskStatus =
+  "queued" | "running" | "cancelling" | "completed" | "failed" | "cancelled";
+export type OrchestrationTask = {
+  id: string;
+  assignmentId?: string;
+  sessionId: string;
+  title: string;
+  harness: HarnessId;
+  model: string;
+  prompt: string;
+  files: string[];
+  scopes: string[];
+  dependsOn: string[];
+  status: TaskStatus;
+  accepted: boolean;
+  result: string;
+  error?: string;
+  delivered: boolean;
+};
+export type OrchestrationRun = {
+  version: 1;
+  leadId: string;
+  cwd: string;
+  canonicalRoot?: string;
+  status: "active" | "paused" | "stopped" | "finished";
+  allowedHarnesses: HarnessId[];
+  allowedModels?: OrchestrationChoice[];
+  proposalId?: string;
+  maxWorkers: number;
+  cli: string;
+  tasks: OrchestrationTask[];
+  error?: string;
+  continuations: number;
+  requests: Record<string, { signature: string; result: unknown }>;
+};
+export type ControlOutcome = {
+  status: "completed" | "failed" | "cancelled";
+  text: string;
+  error?: string;
+};
+export type OrchestrationHost = {
+  session(id: string): Session | undefined;
+  sessions(): Session[];
+  choices(): { harness: HarnessId; models: { id: string; name: string }[] }[];
+  createWorker(run: OrchestrationRun, task: OrchestrationTask): Promise<void>;
+  submit(
+    id: string,
+    text: string,
+    done: (outcome: ControlOutcome) => void,
+  ): void;
+  stop(id: string): Promise<void>;
+  /** Redirect a worker mid-turn, without discarding what it has already done. */
+  steer(id: string, text: string): Promise<void>;
+  /** Answer on a worker's behalf; the lead, not the user, decides. */
+  respondApproval(
+    id: string,
+    requestId: number,
+    decision: ApprovalDecision,
+  ): void;
+  answerQuestion(id: string, requestId: number, reply: UserQuestionReply): void;
+};
+type Storage = {
+  save(run: OrchestrationRun): Promise<void>;
+  load(id: string): Promise<OrchestrationRun | null>;
+  enable(id: string, cwd: string): Promise<string>;
+  disable(id: string): Promise<void>;
+  scopes(cwd: string, files: string[]): Promise<string[]>;
+};
+const storage: Storage = {
+  save: (run) =>
+    invoke("control_save", { leadId: run.leadId, state: JSON.stringify(run) }),
+  load: async (id) => {
+    const raw = await invoke<string | null>("control_load", { leadId: id });
+    if (!raw) return null;
+    const run = JSON.parse(raw) as OrchestrationRun;
+    if (run.version !== 1 || run.leadId !== id || !Array.isArray(run.tasks))
+      throw new Error("Unsupported orchestration history");
+    return run;
+  },
+  enable: (sessionId, cwd) => invoke("control_enable", { sessionId, cwd }),
+  disable: (sessionId) => invoke("control_disable", { sessionId }),
+  scopes: (cwd, files) => invoke("control_scopes", { cwd, files }),
+};
+
+export function scopesOverlap(a: string[], b: string[]): boolean {
+  return a.some((left) =>
+    b.some(
+      (right) =>
+        left === right ||
+        left.startsWith(`${right}/`) ||
+        right.startsWith(`${left}/`),
+    ),
+  );
+}
+const activeTask = (task: OrchestrationTask) =>
+  task.status === "running" || task.status === "cancelling";
+export const sameCheckout = (a: string, b: string) =>
+  a.replace(/\\/g, "/").replace(/\/$/, "").toLowerCase() ===
+  b.replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+const messageOf = (error: unknown) =>
+  error instanceof Error ? error.message : String(error);
+
+const ASSIGNMENT_BLOCK =
+  /(?:\r?\n[ \t]*)*<monocode_assignment\b[^>]*>[\s\S]*?<\/monocode_assignment>/gi;
+
+/** Prompt the worker receives, including the envelope the transcript hides. */
+export function workerTurnPrompt(prompt: string, files: string[]): string {
+  return `${prompt}\n\n<monocode_assignment>\nYou are a worker managed by a MonoCode lead. Work in this shared checkout. Your assigned write scope is: ${files.join(", ")}. Read other files as needed, but do not edit outside your scope. If another file or shared operation is needed, report the blocker and stop so the lead can assign a new task. Do not spawn agents, create worktrees, switch branches, stage/commit changes, install dependencies or run broad formatters/generators unless this task owns '.' and explicitly requires that operation. Do not undo another agent's changes. Other workers may be editing concurrently; report focused checks, changed files, remaining issues and a concise final result.\n</monocode_assignment>`;
+}
+
+/** Task text a person should see: the assignment envelope stays in the send. */
+export function visibleUserPrompt(text: string): string {
+  return text.replace(ASSIGNMENT_BLOCK, "").trimEnd();
+}
+
+function text(value: unknown, label: string, max = 30_000): string {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`Invalid ${label}: provide a non-empty string`);
+  if (value.length > max)
+    throw new Error(`Invalid ${label}: keep it under ${max} characters`);
+  return value.trim();
+}
+function strings(value: unknown, label: string, max = 64): string[] {
+  if (!Array.isArray(value))
+    throw new Error(`Invalid ${label}: provide an array of strings`);
+  if (value.length > max)
+    throw new Error(`Invalid ${label}: at most ${max} entries`);
+  return [...new Set(value.map((item) => text(item, label, 512)))];
+}
+/**
+ * A mistyped field must fail loudly rather than silently change the task. A
+ * Map, so an action named after an Object member is still just unknown.
+ */
+const FIELDS = new Map<string, string[]>([
+  ["list", []],
+  ["delegate", ["title", "harness", "model", "prompt", "files", "dependsOn"]],
+  ["get", ["taskId"]],
+  ["message", ["taskId", "text"]],
+  ["cancel", ["taskId"]],
+  ["wait", ["timeoutSeconds"]],
+  ["review", ["taskId"]],
+  ["finish", []],
+  ["steer", ["taskId", "text"]],
+  ["respond", ["taskId", "requestId", "decision"]],
+  ["answer", ["taskId", "requestId", "answers", "skip"]],
+]);
+function checkFields(action: string, input: Record<string, unknown>) {
+  const allowed = FIELDS.get(action);
+  if (!allowed)
+    throw new Error(
+      `Unknown action "${action}". Use one of: ${[...FIELDS.keys()].join(", ")}. Run the control CLI with --help.`,
+    );
+  const unknown = Object.keys(input).filter((key) => !allowed.includes(key));
+  if (unknown.length)
+    throw new Error(
+      `Unknown ${action} field${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}. ${allowed.length ? `${action} accepts: ${allowed.join(", ")}.` : `${action} takes no input.`}`,
+    );
+}
+/**
+ * Quote the executable for the shell the lead runs in, and only when needed.
+ * The path is absolute, so a leading slash means a POSIX shell — where a
+ * backslash escapes rather than separates, and so is never safe bare.
+ */
+export function shellPath(path: string): string {
+  if (path.startsWith("/"))
+    return /^[A-Za-z0-9._/:-]+$/.test(path)
+      ? path
+      : `'${path.replace(/'/g, `'\\''`)}'`;
+  return /[\s"]/.test(path) ? `"${path.replace(/"/g, "")}"` : path;
+}
+/** Map the lead's chosen option IDs onto the worker's own question shape. */
+function questionAnswers(
+  value: unknown,
+  questions: { id: string; options: { id: string }[] }[] = [],
+): Record<string, string[]> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(
+      'answers must be an object of questionId -> [optionId], or pass {"skip":true}',
+    );
+  const answers: Record<string, string[]> = {};
+  for (const [id, chosen] of Object.entries(value)) {
+    const question = questions.find((entry) => entry.id === id);
+    if (!question)
+      throw new Error(
+        `Unknown question "${id}". Ask for: ${listed(questions.map((entry) => entry.id)) || "none"}.`,
+      );
+    const ids = strings(chosen, `answers.${id}`, 16);
+    const unknown = ids.filter(
+      (option) => !question.options.some((entry) => entry.id === option),
+    );
+    if (unknown.length)
+      throw new Error(
+        `Unknown option${unknown.length > 1 ? "s" : ""} for "${id}": ${listed(unknown)}. Choose from: ${listed(question.options.map((entry) => entry.id))}.`,
+      );
+    answers[id] = ids;
+  }
+  if (!Object.keys(answers).length)
+    throw new Error('Answer at least one question, or pass {"skip":true}');
+  return answers;
+}
+const listed = (values: string[], max = 12) =>
+  values.length > max
+    ? `${values.slice(0, max).join(", ")} (+${values.length - max} more)`
+    : values.join(", ");
+
+export class Orchestrator {
+  private runs: OrchestrationRun[] = [];
+  private listeners = new Set<() => void>();
+  private loaded = new Set<string>();
+  private deleted = new Set<string>();
+  private persisted = new Map<string, OrchestrationRun>();
+  private saves = Promise.resolve();
+  private actions = Promise.resolve();
+  private pumping = false;
+  private starting = new Set<string>();
+  private pumpAgain = false;
+  private waking = new Set<string>();
+  private blocked = new Map<string, string>();
+  private announced = new Map<string, Set<string>>();
+  private inflight = new Map<
+    string,
+    { signature: string; promise: Promise<unknown> }
+  >();
+  private host: OrchestrationHost | null = null;
+  constructor(private readonly store: Storage = storage) {}
+  bind(host: OrchestrationHost) {
+    this.host = host;
+  }
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  snapshot = () => this.runs;
+  run(id: string) {
+    return this.runs.find((run) => run.leadId === id);
+  }
+  forSession(id: string) {
+    return this.runs.find(
+      (run) =>
+        run.leadId === id || run.tasks.some((task) => task.sessionId === id),
+    );
+  }
+  private emit() {
+    for (const listener of this.listeners) listener();
+  }
+  private async commit(run: OrchestrationRun) {
+    this.runs = [
+      ...this.runs.filter((entry) => entry.leadId !== run.leadId),
+      run,
+    ];
+    this.emit();
+    const saved = this.saves
+      .catch(() => undefined)
+      .then(async () => {
+        await this.store.save(run);
+        this.persisted.set(run.leadId, run);
+      });
+    this.saves = saved;
+    try {
+      await saved;
+    } catch (error) {
+      const current = this.run(run.leadId)!;
+      const running = current.tasks.filter(activeTask);
+      this.runs = this.runs.map((entry) =>
+        entry.leadId === run.leadId
+          ? {
+              ...entry,
+              status: "paused",
+              error: `Could not save run: ${messageOf(error)}`,
+              tasks: entry.tasks.map((task) =>
+                activeTask(task) ? { ...task, status: "cancelling" } : task,
+              ),
+            }
+          : entry,
+      );
+      this.emit();
+      // Keep the checkout reserved until processes have stopped, even if the
+      // database is unavailable. Recovery never repeats an interrupted turn.
+      await Promise.allSettled(
+        [run.leadId, ...running.map((task) => task.sessionId)].map(
+          async (id) => {
+            await this.host?.stop(id);
+            const latest = this.run(run.leadId)!;
+            this.runs = this.runs.map((entry) =>
+              entry.leadId === run.leadId
+                ? {
+                    ...latest,
+                    tasks: latest.tasks.map((task) =>
+                      task.sessionId === id && activeTask(task)
+                        ? {
+                            ...task,
+                            status: "failed",
+                            accepted: false,
+                            delivered: true,
+                            error:
+                              "Stopped because run history could not be saved. Review files before retrying.",
+                          }
+                        : task,
+                    ),
+                  }
+                : entry,
+            );
+            this.emit();
+          },
+        ),
+      );
+      throw error;
+    }
+  }
+  private async patchTask(
+    leadId: string,
+    id: string,
+    patch: Partial<OrchestrationTask>,
+  ) {
+    const run = this.run(leadId);
+    if (run)
+      await this.commit({
+        ...run,
+        tasks: run.tasks.map((task) =>
+          task.id === id ? { ...task, ...patch } : task,
+        ),
+      });
+  }
+  async hydrate(id: string) {
+    if (this.loaded.has(id) || this.run(id)) return;
+    this.loaded.add(id);
+    try {
+      const run = await this.store.load(id);
+      if (!run || this.run(id) || this.deleted.has(id)) return;
+      if (run.status === "active" || run.tasks.some(activeTask)) {
+        await Promise.all(
+          [
+            id,
+            ...run.tasks.filter(activeTask).map((task) => task.sessionId),
+          ].map((sessionId) => this.host?.stop(sessionId)),
+        );
+        await this.store.disable(id);
+      }
+      await this.commit({
+        ...run,
+        status: run.status === "active" ? "paused" : run.status,
+        tasks: run.tasks.map((task) =>
+          activeTask(task)
+            ? {
+                ...task,
+                status: "failed",
+                accepted: false,
+                error: "Interrupted. Review the shared files before retrying.",
+                delivered: false,
+              }
+            : { ...task, delivered: task.accepted || task.status === "queued" },
+        ),
+        error:
+          run.status === "active"
+            ? "Run interrupted. Review the files, then resume."
+            : run.error,
+      });
+    } catch (error) {
+      this.loaded.delete(id);
+      throw error;
+    }
+  }
+  async start(
+    leadId: string,
+    allowedHarnesses: HarnessId[],
+    maxWorkers: number,
+    approved?: {
+      proposalId: string;
+      allowedModels: OrchestrationChoice[];
+      tasks: OrchestrationTask[];
+    },
+  ) {
+    if (this.starting.has(leadId))
+      throw new Error("The run is already starting");
+    this.starting.add(leadId);
+    try {
+      await this.startRun(leadId, allowedHarnesses, maxWorkers, approved);
+    } finally {
+      this.starting.delete(leadId);
+    }
+  }
+  async startApproved(
+    leadId: string,
+    proposalId: string,
+    proposal: OrchestrationProposal,
+  ) {
+    if (proposal.status !== "ready")
+      throw new Error("Review a completed proposal before starting");
+    const settings = validateOrchestrationSettings(proposal.settings);
+    const planned = validateProposedTasks(proposal.tasks, settings);
+    const lead = this.host?.session(leadId);
+    if (!lead || !sameCheckout(lead.cwd, proposal.cwd))
+      throw new Error("Return to the proposal's project before starting");
+    const available = this.host!.choices();
+    const allowedModels = settings.choices.filter((choice) =>
+      available.some(
+        (entry) =>
+          entry.harness === choice.harness &&
+          entry.models.some((model) => model.id === choice.model),
+      ),
+    );
+    if (
+      planned.some(
+        (task) =>
+          !allowedModels.some(
+            (choice) =>
+              choice.harness === task.harness && choice.model === task.model,
+          ),
+      )
+    )
+      throw new Error(
+        "An assigned model is no longer available. Change that assignment before starting.",
+      );
+    const ids = new Map(planned.map((task) => [task.id, crypto.randomUUID()]));
+    const tasks: OrchestrationTask[] = await Promise.all(
+      planned.map(async (task) => ({
+        ...task,
+        id: ids.get(task.id)!,
+        assignmentId: task.id,
+        sessionId: crypto.randomUUID(),
+        scopes: await this.store.scopes(lead.cwd, task.files),
+        dependsOn: task.dependsOn.map((id) => ids.get(id)!),
+        status: "queued",
+        accepted: false,
+        delivered: true,
+        result: "",
+      })),
+    );
+    await this.start(
+      leadId,
+      [...new Set(allowedModels.map((choice) => choice.harness))],
+      settings.maxWorkers,
+      { proposalId, allowedModels, tasks },
+    );
+    this.host!.submit(
+      leadId,
+      `The user confirmed the orchestration card, including any edits. The app has already queued the exact assignments below; do not delegate duplicates. Supervise them through the control CLI, review their changes, request corrections when needed, and finish the original request.\n\nOriginal request:\n${proposal.request}\n\nApproved assignments:\n${JSON.stringify(tasks.map(({ id, title, prompt, harness, model, files, dependsOn }) => ({ taskId: id, title, prompt, harness, model, files, dependsOn })))}`,
+      (outcome) => {
+        if (outcome.status !== "completed")
+          void this.pause(
+            leadId,
+            outcome.error ??
+              "The lead was interrupted. Its agents were stopped; review and resume the run.",
+          ).catch(console.error);
+      },
+    );
+  }
+  private async startRun(
+    leadId: string,
+    allowedHarnesses: HarnessId[],
+    maxWorkers: number,
+    approved?: {
+      proposalId: string;
+      allowedModels: OrchestrationChoice[];
+      tasks: OrchestrationTask[];
+    },
+  ) {
+    const lead = this.host?.session(leadId);
+    if (!lead || lead.busy)
+      throw new Error("Wait for the lead's current turn to finish");
+    if (lead.worktreeCwd)
+      throw new Error(
+        "Start orchestration in a regular project session; this session uses a worktree",
+      );
+    if (!Number.isInteger(maxWorkers) || maxWorkers < 1 || maxWorkers > 4)
+      throw new Error("Choose 1 to 4 workers");
+    const available = this.host!.choices().map((choice) => choice.harness);
+    if (
+      !allowedHarnesses.length ||
+      allowedHarnesses.some((id) => !available.includes(id))
+    )
+      throw new Error("Choose installed worker harnesses");
+    if (
+      this.host!.sessions().some(
+        (session) =>
+          session.id !== leadId &&
+          session.busy &&
+          sameCheckout(session.worktreeCwd ?? session.cwd, lead.cwd),
+      )
+    )
+      throw new Error("Stop other running sessions in this checkout first");
+    const previous = this.run(leadId);
+    if (
+      previous?.status === "active" ||
+      (approved && previous?.status === "paused")
+    )
+      throw new Error("Stop the current run before starting another proposal");
+    if (previous?.tasks.some(activeTask))
+      throw new Error("Stop active workers before changing the run");
+    const [canonicalRoot] = await this.store.scopes(lead.cwd, ["."]);
+    const cli = await this.store.enable(leadId, lead.cwd);
+    try {
+      await this.host!.stop(leadId); // Refresh the child environment before its next turn.
+      await this.commit({
+        version: 1,
+        leadId,
+        cwd: lead.cwd,
+        canonicalRoot,
+        cli,
+        status: "active",
+        allowedHarnesses: [...new Set(allowedHarnesses)],
+        allowedModels:
+          approved?.allowedModels ??
+          (previous?.status === "paused" ? previous.allowedModels : undefined),
+        proposalId:
+          approved?.proposalId ??
+          (previous?.status === "paused" ? previous.proposalId : undefined),
+        maxWorkers,
+        tasks:
+          approved?.tasks ??
+          (previous?.status === "paused" ? previous.tasks : []),
+        continuations: 0,
+        requests: previous?.status === "paused" ? previous.requests : {},
+      });
+    } catch (error) {
+      await this.store.disable(leadId);
+      throw error;
+    }
+    void this.pump();
+    this.sync();
+  }
+  submissionError(id: string, managed = false): string | null {
+    if (managed) return null;
+    const session = this.host?.session(id);
+    if (!session) return null;
+    const own = this.forSession(id);
+    if (
+      own &&
+      own.leadId !== id &&
+      (own.status === "active" || own.tasks.some(activeTask))
+    )
+      return "This worker is managed by the orchestrator. Send instructions through its lead or stop the run first.";
+    const other = this.runs.find(
+      (run) =>
+        (run.status === "active" || run.tasks.some(activeTask)) &&
+        run.leadId !== id &&
+        sameCheckout(run.cwd, session.worktreeCwd ?? session.cwd),
+    );
+    if (other)
+      return "This checkout has an active orchestrator. Stop that run before starting independent work.";
+    if (own?.status === "paused")
+      return "Resume or stop orchestration before sending the lead another turn.";
+    if (
+      own?.status === "active" &&
+      !sameCheckout(own.cwd, session.worktreeCwd ?? session.cwd)
+    )
+      return "Return the lead to its original project or stop orchestration first.";
+    return null;
+  }
+  prompt(id: string, prompt: string): string {
+    const run = this.run(id);
+    if (!run || run.status !== "active") return prompt;
+    const cli = `${shellPath(run.cli)} control`;
+    return `${prompt}\n\n<monocode_orchestration>\nYou are the lead of a local MonoCode run. Coordinate the user's task using ${cli}. Run \`${cli} --help\` before your first command; it documents every action, its exact JSON fields and the retry rule. Credentials are already in your environment; never print them.\nEach call prints one JSON line and exits non-zero unless "ok" is true; read the "error" text, it says what to do next. Unknown JSON fields are rejected rather than ignored, so fix the field name instead of guessing. If a call fails before reaching MonoCode, retry it with the "requestId" from that response so the work is never queued twice.\nUse list to discover allowed harness/model IDs. Delegate bounded tasks with project-relative files (directories reserve their descendants), self-contained prompts and dependsOn task IDs. Use the same checkout. You may read and plan; leave file edits to workers. Never start workers outside this CLI. Workers with overlapping files are queued. For installs, Git mutations, generators or broad formatting, assign a separate task with files ["."] and wait for other workers to finish.\nAgents never prompt the user. When one needs an approval or answers a question, list, get and wait report it as needsInput on that task, and you decide with respond or answer; it stays stopped until you do. Judge the request against the task you assigned, and put it to the user in this conversation only when the call is genuinely theirs.\nSteer a running agent with steer to correct its course without losing its work; use message only once it has stopped. Read results with get or wait; completed means a turn finished, not that the work passed review. Review the actual changes, message a worker for fixes, and use review to accept each completed task. Cancel discarded tasks. A failed task blocks finish until you retry it with message or drop it with cancel. Call finish only when required work and combined validation are complete. You receive worker results automatically when idle; use bounded wait calls while supervising. Do not expose credentials, use worktrees, switch branches or silently escalate worker permissions.\n</monocode_orchestration>`;
+  }
+  async handle(
+    leadId: string,
+    requestId: string,
+    action: string,
+    input: Record<string, unknown>,
+  ): Promise<unknown> {
+    checkFields(action, input);
+    const signature = JSON.stringify({ action, input });
+    const key = `${leadId}:${requestId}`;
+    const receipts = this.persisted.get(leadId)?.requests;
+    const previous =
+      receipts &&
+      Object.prototype.hasOwnProperty.call(receipts, requestId) &&
+      typeof receipts[requestId]?.signature === "string"
+        ? receipts[requestId]
+        : undefined;
+    if (previous) {
+      if (previous.signature !== signature)
+        throw new Error("Request ID was already used with different input");
+      return previous.result;
+    }
+    const pending = this.inflight.get(key);
+    if (pending) {
+      if (pending.signature !== signature)
+        throw new Error("Request ID was already used with different input");
+      return pending.promise;
+    }
+    if (action === "wait") return this.wait(leadId, input);
+    const result = this.actions
+      .catch(() => undefined)
+      .then(async () => {
+        const run = this.run(leadId);
+        if (!run || run.status !== "active")
+          throw new Error("This run is not active");
+        if (
+          !["list", "get"].includes(action) &&
+          Object.keys(run.requests).length >= 512
+        )
+          throw new Error(
+            "Run command limit reached. Stop the run and start another after reviewing the files.",
+          );
+        return this.execute(run, action, input, requestId, signature);
+      });
+    this.actions = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.inflight.set(key, { signature, promise: result });
+    try {
+      return await result;
+    } finally {
+      this.inflight.delete(key);
+      void this.pump();
+    }
+  }
+  private view(run: OrchestrationRun) {
+    return {
+      ...run,
+      cli: undefined,
+      requests: undefined,
+      tasks: run.tasks.map((task) => ({
+        ...task,
+        prompt: undefined,
+        scopes: undefined,
+        waitingFor: this.waitingFor(run, task),
+        needsInput: this.pendingInput(task),
+      })),
+    };
+  }
+  /**
+   * What a worker is blocked on. Workers have no user-facing prompt: the lead
+   * answers for them, and escalates to the user in its own conversation when
+   * it does not want to decide alone.
+   */
+  pendingInput(task: OrchestrationTask) {
+    const worker = this.host?.session(task.sessionId);
+    const pending = worker && pendingApprovalForSession(worker);
+    if (!pending) return undefined;
+    return {
+      kind: pending.kind,
+      requestId: pending.requestId,
+      label: pending.label,
+      detail:
+        pending.kind === "approval"
+          ? (pending.block?.tool?.detail?.trim() ?? pending.block?.text)
+          : undefined,
+      questions: worker?.pendingQuestion?.questions,
+    };
+  }
+  waitingFor(
+    run: OrchestrationRun,
+    task: OrchestrationTask,
+  ): string | undefined {
+    if (task.status !== "queued") return undefined;
+    const dependency = run.tasks.find(
+      (entry) => task.dependsOn.includes(entry.id) && !entry.accepted,
+    );
+    if (dependency) return `Waiting for review: ${dependency.title}`;
+    const owner = run.tasks.find(
+      (entry) => activeTask(entry) && scopesOverlap(entry.scopes, task.scopes),
+    );
+    if (owner) return `Waiting for files: ${owner.title}`;
+    return "Waiting for a worker slot";
+  }
+  private async execute(
+    run: OrchestrationRun,
+    action: string,
+    input: Record<string, unknown>,
+    requestId: string,
+    signature: string,
+  ): Promise<unknown> {
+    // Persist the mutation and its retry receipt together, before dispatch.
+    const record = async (next: OrchestrationRun, result: unknown) => {
+      await this.commit({
+        ...next,
+        requests: { ...next.requests, [requestId]: { signature, result } },
+      });
+      return result;
+    };
+    const changeTask = (
+      id: string,
+      patch: Partial<OrchestrationTask>,
+      result: unknown,
+    ) => {
+      const current = this.run(run.leadId)!;
+      return record(
+        {
+          ...current,
+          tasks: current.tasks.map((entry) =>
+            entry.id === id ? { ...entry, ...patch } : entry,
+          ),
+        },
+        result,
+      );
+    };
+    const task = () => {
+      const id = text(input.taskId, "taskId", 128);
+      const found = this.run(run.leadId)!.tasks.find(
+        (entry) => entry.id === id,
+      );
+      if (!found)
+        throw new Error(
+          "Task does not belong to this run. Use a taskId returned by delegate or list.",
+        );
+      return found;
+    };
+    switch (action) {
+      case "list":
+        return {
+          run: this.view(run),
+          harnesses: this.host!.choices()
+            .filter((choice) => run.allowedHarnesses.includes(choice.harness))
+            .map((choice) => ({
+              ...choice,
+              models: choice.models.filter(
+                (model) =>
+                  !run.allowedModels ||
+                  run.allowedModels.some(
+                    (allowed) =>
+                      allowed.harness === choice.harness &&
+                      allowed.model === model.id,
+                  ),
+              ),
+            })),
+        };
+      case "get": {
+        // The fields list reports, plus this task's own prompt.
+        const target = task();
+        return {
+          ...target,
+          scopes: undefined,
+          waitingFor: this.waitingFor(this.run(run.leadId)!, target),
+          needsInput: this.pendingInput(target),
+        };
+      }
+      case "delegate": {
+        if (run.tasks.length >= 40)
+          throw new Error("This run has reached its 40-task limit");
+        const harness = text(input.harness, "harness") as HarnessId;
+        if (
+          !HARNESSES.includes(harness) ||
+          !run.allowedHarnesses.includes(harness)
+        )
+          throw new Error(
+            `Harness "${harness}" is not allowed in this run. Allowed: ${listed(run.allowedHarnesses)}.`,
+          );
+        const choice = this.host!.choices().find(
+          (entry) => entry.harness === harness,
+        );
+        if (!choice) throw new Error("Worker harness is unavailable");
+        const permittedModels = choice.models.filter(
+          (model) =>
+            !run.allowedModels ||
+            run.allowedModels.some(
+              (allowed) =>
+                allowed.harness === harness && allowed.model === model.id,
+            ),
+        );
+        const model =
+          input.model == null
+            ? permittedModels[0]?.id
+            : text(input.model, "model", 256);
+        if (!model || !permittedModels.some((item) => item.id === model))
+          throw new Error(
+            `Choose a model ID returned by list for ${harness}: ${listed(permittedModels.map((item) => item.id)) || "none available"}.`,
+          );
+        const title = text(input.title, "title", 160);
+        const prompt = text(input.prompt, "prompt");
+        const files = strings(input.files, "files");
+        if (!files.length)
+          throw new Error(
+            "Declare at least one file/directory scope in files, or '.' for exclusive checkout access",
+          );
+        const dependsOn = strings(input.dependsOn ?? [], "dependsOn", 40);
+        const missing = dependsOn.filter(
+          (id) =>
+            !run.tasks.some(
+              (item) => item.id === id && item.status !== "cancelled",
+            ),
+        );
+        if (missing.length)
+          throw new Error(
+            `dependsOn must hold taskIds from this run; unknown or cancelled: ${listed(missing)}.`,
+          );
+        const scopes = await this.store.scopes(run.cwd, files);
+        const created: OrchestrationTask = {
+          id: crypto.randomUUID(),
+          sessionId: crypto.randomUUID(),
+          title,
+          prompt,
+          files,
+          scopes,
+          dependsOn,
+          harness,
+          model,
+          status: "queued",
+          accepted: false,
+          result: "",
+          delivered: true,
+        };
+        return record(
+          {
+            ...this.run(run.leadId)!,
+            tasks: [...this.run(run.leadId)!.tasks, created],
+          },
+          {
+            taskId: created.id,
+            sessionId: created.sessionId,
+            status: "queued",
+          },
+        );
+      }
+      case "message": {
+        const target = task();
+        if (activeTask(target) || target.status === "queued")
+          throw new Error(
+            `Wait for this worker or cancel it before sending a new turn; ${target.title} is ${target.status}.`,
+          );
+        if (
+          run.tasks.some(
+            (entry) =>
+              entry.dependsOn.includes(target.id) &&
+              entry.status !== "queued" &&
+              entry.status !== "cancelled",
+          )
+        )
+          throw new Error(
+            "A dependent task has already started; create a separate correction task after it finishes",
+          );
+        return changeTask(
+          target.id,
+          {
+            prompt: text(input.text, "text"),
+            status: "queued",
+            accepted: false,
+            result: "",
+            error: undefined,
+            delivered: true,
+          },
+          { taskId: target.id, status: "queued" },
+        );
+      }
+      case "steer": {
+        const target = task();
+        if (target.status !== "running")
+          throw new Error(
+            `Only a running agent can be steered; ${target.title} is ${target.status}. ${
+              target.status === "queued"
+                ? "It has not started yet, so edit it with message instead."
+                : "Send it a fresh turn with message."
+            }`,
+          );
+        const guidance = text(input.text, "text");
+        await this.host!.steer(target.sessionId, guidance);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          steered: true,
+        });
+      }
+      case "cancel":
+        await this.cancelTask(run.leadId, task().id);
+        return record(this.run(run.leadId)!, { cancelled: true });
+      case "respond": {
+        const target = task();
+        const pending = this.pendingInput(target);
+        if (pending?.kind !== "approval")
+          throw new Error(
+            `${target.title} is not waiting on an approval. Read needsInput from list or wait before responding.`,
+          );
+        if (input.requestId !== pending.requestId)
+          throw new Error(
+            `Stale requestId. ${target.title} is waiting on ${pending.requestId}.`,
+          );
+        const decision = text(input.decision, "decision", 16);
+        if (decision !== "allow" && decision !== "deny")
+          throw new Error('decision must be "allow" or "deny"');
+        this.host!.respondApproval(target.sessionId, pending.requestId, decision);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          decision,
+        });
+      }
+      case "answer": {
+        const target = task();
+        const pending = this.pendingInput(target);
+        if (pending?.kind !== "question")
+          throw new Error(
+            `${target.title} is not waiting on a question. Read needsInput from list or wait before answering.`,
+          );
+        if (input.requestId !== pending.requestId)
+          throw new Error(
+            `Stale requestId. ${target.title} is waiting on ${pending.requestId}.`,
+          );
+        const reply: UserQuestionReply =
+          input.skip === true
+            ? { kind: "skipped" }
+            : {
+                kind: "answered",
+                answers: questionAnswers(input.answers, pending.questions),
+              };
+        this.host!.answerQuestion(target.sessionId, pending.requestId, reply);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          answered: reply.kind === "answered",
+        });
+      }
+      case "review": {
+        const target = task();
+        if (target.status !== "completed")
+          throw new Error(
+            `Only a completed result can be accepted; ${target.title} is ${target.status}. ${
+              target.status === "failed"
+                ? "Send it another turn with message, or drop it with cancel."
+                : "Wait for it to finish, or cancel it."
+            }`,
+          );
+        return changeTask(target.id, { accepted: true }, { accepted: true });
+      }
+      case "finish": {
+        const outstanding = this.run(run.leadId)!.tasks.filter(
+          (entry) => entry.status !== "cancelled" && !entry.accepted,
+        );
+        if (outstanding.length)
+          throw new Error(
+            `Review all remaining tasks before finishing. Outstanding: ${listed(
+              outstanding.map((entry) => `${entry.title} (${entry.status})`),
+            )}. Accept a completed task with review, send a failed one another turn with message, or drop it with cancel.`,
+          );
+        const result = await record(
+          { ...this.run(run.leadId)!, status: "finished" },
+          { finished: true },
+        );
+        await this.store.disable(run.leadId);
+        return result;
+      }
+      default:
+        throw new Error("Unknown action. Run control --help.");
+    }
+  }
+  private async wait(leadId: string, input: Record<string, unknown>) {
+    const run = this.run(leadId);
+    if (!run || run.status !== "active")
+      throw new Error("This run is not active");
+    const seconds = input.timeoutSeconds ?? 20;
+    if (
+      typeof seconds !== "number" ||
+      !Number.isFinite(seconds) ||
+      seconds < 0 ||
+      seconds > 25
+    )
+      throw new Error("timeoutSeconds must be 0 to 25");
+    // A worker blocking on the lead changes no run state, so watch for that
+    // separately; otherwise the lead sleeps while an agent waits on it.
+    const blocked = this.blocked.get(leadId);
+    if (
+      run.tasks.some(activeTask) ||
+      run.tasks.some((task) => task.status === "queued")
+    ) {
+      await new Promise<void>((resolve) => {
+        const finish = () => {
+          clearTimeout(timer);
+          unsubscribe();
+          resolve();
+        };
+        const unsubscribe = this.subscribe(() => {
+          if (this.run(leadId) !== run || this.blocked.get(leadId) !== blocked)
+            finish();
+        });
+        const timer = setTimeout(finish, seconds * 1000);
+      });
+    }
+    return this.view(this.run(leadId)!);
+  }
+  private async pump() {
+    if (this.pumping) {
+      this.pumpAgain = true;
+      return;
+    }
+    if (!this.host) return;
+    this.pumping = true;
+    try {
+      for (const initial of this.runs) {
+        const initialRun = this.run(initial.leadId);
+        if (!initialRun || initialRun.status !== "active") continue;
+        for (const initialTask of initialRun.tasks) {
+          const run = this.run(initial.leadId);
+          if (
+            !run ||
+            run.status !== "active" ||
+            run.tasks.filter(activeTask).length >= run.maxWorkers
+          )
+            break;
+          const task = run.tasks.find((entry) => entry.id === initialTask.id);
+          if (
+            !task ||
+            task.status !== "queued" ||
+            task.dependsOn.some(
+              (id) => !run.tasks.find((entry) => entry.id === id)?.accepted,
+            )
+          )
+            continue;
+          if (
+            run.tasks.some(
+              (entry) =>
+                activeTask(entry) && scopesOverlap(entry.scopes, task.scopes),
+            )
+          )
+            continue;
+          if (!this.host.session(run.leadId)) {
+            await this.stopRun(run.leadId);
+            break;
+          }
+          await this.patchTask(run.leadId, task.id, { status: "running" });
+          try {
+            if (
+              !this.host
+                .choices()
+                .some(
+                  (choice) =>
+                    choice.harness === task.harness &&
+                    choice.models.some((model) => model.id === task.model),
+                )
+            )
+              throw new Error(
+                "The assigned harness/model is no longer available. Review this task before retrying.",
+              );
+            await this.host.createWorker(run, task);
+            if (
+              this.run(run.leadId)?.status !== "active" ||
+              this.run(run.leadId)?.tasks.find((entry) => entry.id === task.id)
+                ?.status !== "running"
+            )
+              continue;
+            const prompt = workerTurnPrompt(task.prompt, task.files);
+            this.host.submit(task.sessionId, prompt, (outcome) => {
+              void this.settle(run.leadId, task.id, outcome).catch(
+                console.error,
+              );
+            });
+          } catch (error) {
+            await this.settle(run.leadId, task.id, {
+              status: "failed",
+              text: "",
+              error: messageOf(error),
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Orchestration dispatch failed", error);
+    } finally {
+      this.pumping = false;
+      if (this.pumpAgain) {
+        this.pumpAgain = false;
+        void this.pump();
+      }
+    }
+  }
+  private async settle(
+    leadId: string,
+    taskId: string,
+    outcome: ControlOutcome,
+  ) {
+    const task = this.run(leadId)?.tasks.find((entry) => entry.id === taskId);
+    if (!task || task.status !== "running") return;
+    await this.patchTask(leadId, taskId, {
+      status: outcome.status,
+      result: outcome.text.slice(-20_000),
+      error: outcome.error,
+      delivered: false,
+      accepted: false,
+    });
+    void this.pump();
+    this.sync();
+  }
+  async cancelTask(leadId: string, taskId: string) {
+    const task = this.run(leadId)?.tasks.find((entry) => entry.id === taskId);
+    if (!task || task.status === "cancelled") return;
+    if (activeTask(task)) {
+      await this.patchTask(leadId, taskId, { status: "cancelling" });
+      await this.host!.stop(task.sessionId);
+    }
+    await this.patchTask(leadId, taskId, {
+      status: "cancelled",
+      accepted: false,
+      delivered: false,
+    });
+    void this.pump();
+  }
+  /**
+   * A paused run has no supervisor, so its agents stop with it. Leaving them
+   * editing the shared checkout with nobody reviewing is how a run quietly
+   * diverges from what the user approved. Queued work is left alone: `pump`
+   * will not dispatch while paused, so it resumes intact.
+   */
+  private async pause(
+    leadId: string,
+    error: string,
+    patch?: (run: OrchestrationRun) => OrchestrationRun,
+  ) {
+    const run = this.run(leadId);
+    if (!run || run.status !== "active") return;
+    await this.commit({ ...(patch ? patch(run) : run), status: "paused", error });
+    await Promise.all(
+      this.run(leadId)!
+        .tasks.filter(activeTask)
+        .map((task) => this.cancelTask(leadId, task.id)),
+    );
+  }
+  async stopRun(leadId: string) {
+    const run = this.run(leadId);
+    if (!run) return;
+    let saveError: unknown;
+    await this.commit({ ...run, status: "stopped" }).catch((error: unknown) => {
+      saveError = error;
+    });
+    await Promise.all(
+      [
+        leadId,
+        ...run.tasks.filter(activeTask).map((task) => task.sessionId),
+      ].map((id) => this.host?.stop(id)),
+    );
+    const latest = this.run(leadId)!;
+    const stopped: OrchestrationRun = {
+      ...latest,
+      status: "stopped",
+      tasks: latest.tasks.map((task) =>
+        activeTask(task) || task.status === "queued"
+          ? { ...task, status: "cancelled", accepted: false, delivered: true }
+          : task,
+      ),
+    };
+    await this.commit(stopped).catch((error: unknown) => {
+      saveError = error;
+    });
+    this.runs = this.runs.map((entry) =>
+      entry.leadId === leadId
+        ? {
+            ...stopped,
+            error: saveError
+              ? `Run stopped; could not save history: ${messageOf(saveError)}`
+              : undefined,
+          }
+        : entry,
+    );
+    this.emit();
+    await this.store.disable(leadId);
+  }
+  stopForSession(id: string): Promise<void> | null {
+    const run = this.forSession(id);
+    if (
+      !run ||
+      (run.status !== "active" &&
+        run.status !== "paused" &&
+        !run.tasks.some(activeTask))
+    )
+      return null;
+    if (run.leadId === id) return this.stopRun(id);
+    const task = run.tasks.find((entry) => entry.sessionId === id)!;
+    return this.cancelTask(run.leadId, task.id);
+  }
+  /** Drain control writes before the database removes a lead or one of its workers. */
+  deleteSession(id: string, remove: () => Promise<void>): Promise<void> {
+    const result = this.actions.catch(() => undefined).then(async () => {
+      const run = this.forSession(id);
+      if (
+        run &&
+        (run.status === "active" ||
+          run.status === "paused" ||
+          run.tasks.some(activeTask))
+      ) {
+        await this.stopRun(run.leadId);
+      }
+      await this.saves.catch(() => undefined);
+      await remove();
+      this.deleted.add(id);
+      if (!run) return;
+      this.runs = this.runs.filter((entry) => entry.leadId !== run.leadId);
+      this.persisted.delete(run.leadId);
+      this.blocked.delete(run.leadId);
+      this.announced.delete(run.leadId);
+      this.emit();
+      if (run.leadId !== id) {
+        // Read the transaction's pruned graph; never save the pre-delete snapshot.
+        const updated = await this.store.load(run.leadId).catch((error) => {
+          console.error("Could not reload orchestration after deletion", error);
+          this.loaded.delete(run.leadId);
+          return null;
+        });
+        if (updated) {
+          this.runs = [...this.runs, updated];
+          this.persisted.set(run.leadId, updated);
+          this.emit();
+        }
+      }
+    });
+    this.actions = result.catch(() => undefined);
+    return result;
+  }
+  /** `${taskId}:${requestId}` for every worker currently blocked on the lead. */
+  private blockedKeys(run: OrchestrationRun): string[] {
+    return run.tasks.flatMap((task) => {
+      const pending = this.pendingInput(task);
+      return pending ? [`${task.id}:${pending.requestId}`] : [];
+    });
+  }
+  sync() {
+    for (const run of this.runs) {
+      if (run.status !== "active") continue;
+      // A blocked worker changes no run state, so `wait` needs telling.
+      const keys = this.blockedKeys(run).join(",");
+      if (this.blocked.get(run.leadId) !== keys) {
+        this.blocked.set(run.leadId, keys);
+        this.emit();
+      }
+    }
+    for (const run of this.runs) {
+      if (run.status !== "active" || this.waking.has(run.leadId)) continue;
+      const lead = this.host?.session(run.leadId);
+      if (!lead || lead.busy || lead.queuedMessages?.length) continue;
+      const announced = this.announced.get(run.leadId) ?? new Set<string>();
+      const results = run.tasks.filter((task) => !task.delivered);
+      const blocked = this.blockedKeys(run).filter(
+        (key) => !announced.has(key),
+      );
+      if (!results.length && !blocked.length) continue;
+      this.waking.add(run.leadId);
+      // Let session state settle before checking idle; never interrupt user input.
+      setTimeout(() => {
+        void (async () => {
+          try {
+            const current = this.run(run.leadId);
+            const session = this.host?.session(run.leadId);
+            if (
+              !current ||
+              current.status !== "active" ||
+              !session ||
+              session.busy ||
+              session.queuedMessages?.length
+            )
+              return;
+            const results = current.tasks.filter(
+              (task) =>
+                !task.delivered &&
+                !activeTask(task) &&
+                task.status !== "queued",
+            );
+            const seen = this.announced.get(run.leadId) ?? new Set<string>();
+            const waiting = current.tasks.flatMap((task) => {
+              const pending = this.pendingInput(task);
+              const key = pending && `${task.id}:${pending.requestId}`;
+              return key && !seen.has(key) ? [{ task, pending, key }] : [];
+            });
+            if (!results.length && !waiting.length) return;
+            if (current.continuations >= 20) {
+              await this.pause(
+                run.leadId,
+                "Automatic continuation limit reached. Its agents were stopped; review and resume the run.",
+              );
+              return;
+            }
+            await this.commit({
+              ...current,
+              continuations: current.continuations + 1,
+              tasks: current.tasks.map((task) =>
+                results.some((item) => item.id === task.id)
+                  ? { ...task, delivered: true }
+                  : task,
+              ),
+            });
+            this.announced.set(
+              run.leadId,
+              new Set([...seen, ...waiting.map((entry) => entry.key)]),
+            );
+            const summary = results
+              .map(
+                (task) =>
+                  `${task.id} — ${task.title}: ${task.status}\n${task.error ?? ""}\n${task.result.slice(-4000)}`,
+              )
+              .join("\n\n");
+            const asks = waiting
+              .map(
+                ({ task, pending }) =>
+                  `${task.id} — ${task.title} needs ${pending.kind === "approval" ? "an approval" : "an answer"} (requestId ${pending.requestId}): ${pending.label}\n${pending.detail?.slice(0, 2000) ?? ""}${
+                    pending.questions
+                      ? `\n${JSON.stringify(pending.questions)}`
+                      : ""
+                  }`,
+              )
+              .join("\n\n");
+            const body = [
+              results.length
+                ? `Worker results are ready. Review the work, request corrections through the CLI when needed, and finish the original task.\n\n${summary}`
+                : "",
+              waiting.length
+                ? `These agents are blocked waiting on you. Decide each one with respond or answer; they stay stopped until you do. Judge it against the task you assigned, and ask the user in this conversation only when the call is genuinely theirs to make.\n\n${asks}`
+                : "",
+            ]
+              .filter(Boolean)
+              .join("\n\n");
+            this.host!.submit(
+              run.leadId,
+              body,
+              (outcome) => {
+                if (outcome.status !== "completed") {
+                  void this.pause(
+                    run.leadId,
+                    outcome.error ??
+                      "Lead continuation was interrupted. Its agents were stopped; review and resume.",
+                    (current) => ({
+                      ...current,
+                      tasks: current.tasks.map((task) =>
+                        results.some((item) => item.id === task.id)
+                          ? { ...task, delivered: false }
+                          : task,
+                      ),
+                    }),
+                  ).catch(console.error);
+                } else this.sync();
+              },
+            );
+          } catch (error) {
+            console.error("Orchestration continuation failed", error);
+          } finally {
+            this.waking.delete(run.leadId);
+          }
+        })();
+      }, 0);
+    }
+  }
+  observe(id: string, event: HarnessEvent) {
+    if (event.type !== "tool.started" && event.type !== "tool.updated") return;
+    const run = this.forSession(id);
+    const task = run?.tasks.find(
+      (entry) => entry.sessionId === id && entry.status === "running",
+    );
+    if (
+      !run ||
+      run.status !== "active" ||
+      !task ||
+      event.preview?.kind !== "write"
+    )
+      return;
+    const paths =
+      event.paths ?? (event.preview.path ? [event.preview.path] : []);
+    for (const path of paths) {
+      const absolute = /^(\/|[a-z]:[\\/])/i.test(path)
+        ? path
+        : `${run.canonicalRoot ?? run.cwd}/${path}`;
+      const parts: string[] = [];
+      for (const part of absolute
+        .replace(/\\/g, "/")
+        .toLowerCase()
+        .split("/")) {
+        if (part === "..") parts.pop();
+        else if (part !== ".") parts.push(part);
+      }
+      const normalized = parts.join("/");
+      if (
+        task.scopes.some(
+          (scope) => normalized === scope || normalized.startsWith(`${scope}/`),
+        )
+      )
+        continue;
+      void (async () => {
+        await this.commit({
+          ...this.run(run.leadId)!,
+          status: "paused",
+          error: `${task.title} reported a write outside its assignment: ${path}. Review the shared files before resuming.`,
+        });
+        await Promise.all(
+          this.run(run.leadId)!
+            .tasks.filter(activeTask)
+            .map((entry) => this.cancelTask(run.leadId, entry.id)),
+        );
+      })().catch(console.error);
+      break;
+    }
+  }
+}
+
+export const orchestrator = new Orchestrator();
diff --git a/src/lib/orchestrationCatalog.test.ts b/src/lib/orchestrationCatalog.test.ts
new file mode 100644
index 00000000..06cde591
--- /dev/null
+++ b/src/lib/orchestrationCatalog.test.ts
@@ -0,0 +1,68 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("./harness/availability", () => ({
+  isHarnessAvailable: vi.fn((id: string) => id === "codex" || id === "claude"),
+  probeHarnessAvailability: vi.fn(async () => {}),
+}));
+vi.mock("./harness/registry", () => ({
+  refreshHarnessCatalogs: vi.fn(async () => {}),
+}));
+import { discoverOrchestrationSettings } from "./orchestrationCatalog";
+import {
+  isHarnessAvailable,
+  probeHarnessAvailability,
+} from "./harness/availability";
+import { refreshHarnessCatalogs } from "./harness/registry";
+import { resetHarnessModelOverlays, setHarnessModels } from "./models";
+
+afterEach(() => {
+  resetHarnessModelOverlays();
+  vi.clearAllMocks();
+  vi.mocked(isHarnessAvailable).mockImplementation(
+    (id) => id === "codex" || id === "claude",
+  );
+});
+
+describe("automatic orchestration catalog", () => {
+  it("discovers every installed harness and reads its refreshed models without a user-selected pool", async () => {
+    vi.mocked(refreshHarnessCatalogs).mockImplementationOnce(async () => {
+      setHarnessModels("codex", [
+        { id: "codex:live", harness: "codex", name: "Live Codex" },
+      ]);
+    });
+    const settings = await discoverOrchestrationSettings();
+    expect(probeHarnessAvailability).toHaveBeenCalledOnce();
+    expect(refreshHarnessCatalogs).toHaveBeenCalledWith(["claude", "codex"]);
+    expect(settings.choices).toContainEqual({
+      harness: "codex",
+      model: "codex:live",
+      name: "Live Codex",
+    });
+    expect(settings.choices.some((choice) => choice.harness === "claude")).toBe(
+      true,
+    );
+    expect(settings.choices.some((choice) => choice.harness === "cursor")).toBe(
+      false,
+    );
+    expect(settings.maxWorkers).toBe(2);
+  });
+  it("does not truncate catalogs at the former manual-selection limit", async () => {
+    setHarnessModels(
+      "codex",
+      Array.from({ length: 80 }, (_, i) => ({
+        id: `codex:${i}`,
+        harness: "codex",
+        name: `Model ${i}`,
+      })),
+    );
+    const settings = await discoverOrchestrationSettings();
+    expect(
+      settings.choices.filter((choice) => choice.harness === "codex"),
+    ).toHaveLength(80);
+  });
+  it("fails planning clearly when no harness is available", async () => {
+    vi.mocked(isHarnessAvailable).mockReturnValue(false);
+    await expect(discoverOrchestrationSettings()).rejects.toThrow(
+      "No worker models are available",
+    );
+  });
+});
diff --git a/src/lib/orchestrationCatalog.ts b/src/lib/orchestrationCatalog.ts
new file mode 100644
index 00000000..c9a92969
--- /dev/null
+++ b/src/lib/orchestrationCatalog.ts
@@ -0,0 +1,27 @@
+import { HARNESSES } from "./session";
+import { modelsFor } from "./models";
+import {
+  isHarnessAvailable,
+  probeHarnessAvailability,
+} from "./harness/availability";
+import { refreshHarnessCatalogs } from "./harness/registry";
+import { validateOrchestrationSettings } from "./orchestrationPlan";
+
+/** Discover worker choices only when the user sends an orchestration request. */
+export async function discoverOrchestrationSettings() {
+  await probeHarnessAvailability();
+  const installed = HARNESSES.filter(isHarnessAvailable);
+  await refreshHarnessCatalogs(installed);
+  return validateOrchestrationSettings({
+    maxWorkers: 2,
+    choices: installed
+      .filter(isHarnessAvailable)
+      .flatMap((harness) =>
+        modelsFor(harness).map(({ id, name }) => ({
+          harness,
+          model: id,
+          name,
+        })),
+      ),
+  });
+}
diff --git a/src/lib/orchestrationPlan.test.ts b/src/lib/orchestrationPlan.test.ts
new file mode 100644
index 00000000..4b3af7f7
--- /dev/null
+++ b/src/lib/orchestrationPlan.test.ts
@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import {
+  completeOrchestrationProposal,
+  orchestrationPlanningPrompt,
+  proposalBlock,
+  validateProposedTasks,
+  type OrchestrationProposal,
+} from "./orchestrationPlan";
+import { newSession } from "./session";
+import { sanitizeSessionForPersist } from "./sessionStore";
+import { stopStreaming } from "./harness/apply";
+
+const draft: OrchestrationProposal = {
+  version: 1,
+  leadId: "lead",
+  cwd: "/repo",
+  request: "Build settings",
+  author: { harness: "claude", model: "claude:test", name: "Lead" },
+  settings: {
+    choices: [{ harness: "codex", model: "codex:test", name: "Worker" }],
+    maxWorkers: 2,
+  },
+  status: "planning",
+  title: "Planning",
+  summary: "",
+  tasks: [],
+};
+const task = {
+  id: "ui",
+  title: "Settings UI",
+  prompt: "Build the view",
+  harness: "codex",
+  model: "codex:test",
+  files: ["src/settings"],
+  dependsOn: [],
+};
+const payload = {
+  title: "Settings",
+  summary: "Build the view, then validate",
+  tasks: [task],
+};
+
+describe("orchestration proposals", () => {
+  it("prompts the current lead with the available model catalog and no execution authority", () => {
+    const prompt = orchestrationPlanningPrompt(draft.request, draft.settings);
+    expect(prompt).toContain("do not edit files, start workers");
+    expect(prompt).toContain('"model":"codex:test"');
+    expect(prompt).toContain("until the user confirms");
+    expect(prompt).toContain("<monocode_proposal>");
+    expect(prompt).toContain("fewest useful tasks");
+    expect(prompt).toContain("Do not ask the user to assemble a team");
+    expect(prompt).toContain("disjoint files");
+    expect(prompt).toContain("acceptance checks");
+  });
+  it("turns the lead's structured response into a ready card without changing the discovered catalog", () => {
+    const result = completeOrchestrationProposal(
+      draft,
+      `Commentary\n<monocode_proposal>${JSON.stringify({ ...payload, settings: { choices: [] } })}</monocode_proposal>`,
+    );
+    expect(result.status).toBe("ready");
+    expect(result.tasks).toEqual(payload.tasks);
+    expect(result.settings).toEqual(draft.settings);
+    expect(result.author).toEqual(draft.author);
+  });
+  it("accepts fenced JSON and rejects prose or a model outside the available catalog", () => {
+    expect(
+      completeOrchestrationProposal(
+        draft,
+        "```json\n" + JSON.stringify(payload) + "\n```",
+      ).status,
+    ).toBe("ready");
+    expect(
+      completeOrchestrationProposal(draft, "I will implement it now").status,
+    ).toBe("invalid");
+    const invalid = completeOrchestrationProposal(
+      draft,
+      JSON.stringify({
+        ...payload,
+        tasks: [{ ...task, model: "codex:unselected" }],
+      }),
+    );
+    expect(invalid.status).toBe("invalid");
+    expect(invalid.error).toContain("available catalog");
+    expect(invalid.tasks).toEqual([]);
+  });
+  it("validates cycles, unknown dependencies and path escapes before execution", () => {
+    const settings = draft.settings;
+    expect(() =>
+      validateProposedTasks([{ ...task, dependsOn: ["ui"] }], settings),
+    ).toThrow("cycle");
+    expect(() =>
+      validateProposedTasks([{ ...task, dependsOn: ["missing"] }], settings),
+    ).toThrow("unknown assignment");
+    expect(() =>
+      validateProposedTasks([{ ...task, files: ["../outside"] }], settings),
+    ).toThrow("project-relative");
+    expect(() => validateProposedTasks([task, task], settings)).toThrow(
+      "unique",
+    );
+    expect(
+      validateProposedTasks(
+        [
+          { ...task, dependsOn: ["data"] },
+          { ...task, id: "data" },
+        ],
+        settings,
+      ),
+    ).toHaveLength(2);
+  });
+  it("keeps model edits and assignments through persistence", () => {
+    const proposal = completeOrchestrationProposal(
+      draft,
+      JSON.stringify(payload),
+    );
+    proposal.tasks[0].prompt = "User edited the instructions";
+    const session = {
+      ...newSession("claude", "/repo"),
+      blocks: [proposalBlock("proposal", proposal)],
+    };
+    expect(sanitizeSessionForPersist(session).blocks[0].orchestration).toEqual(
+      proposal,
+    );
+  });
+  it("makes interrupted planning non-executable on stop and reload", () => {
+    const session = {
+      ...newSession("claude", "/repo"),
+      busy: true,
+      blocks: [proposalBlock("proposal", draft)],
+    };
+    expect(stopStreaming(session).blocks[0].orchestration?.status).toBe(
+      "invalid",
+    );
+    expect(
+      sanitizeSessionForPersist(session).blocks[0].orchestration?.status,
+    ).toBe("invalid");
+  });
+});
diff --git a/src/lib/orchestrationPlan.ts b/src/lib/orchestrationPlan.ts
new file mode 100644
index 00000000..6c4d0704
--- /dev/null
+++ b/src/lib/orchestrationPlan.ts
@@ -0,0 +1,267 @@
+import { HARNESSES, type Block, type HarnessId, type Session } from "./session";
+
+export type OrchestrationChoice = {
+  harness: HarnessId;
+  model: string;
+  name: string;
+};
+export type OrchestrationSettings = {
+  choices: OrchestrationChoice[];
+  maxWorkers: number;
+};
+export type ProposedTask = {
+  id: string;
+  title: string;
+  prompt: string;
+  harness: HarnessId;
+  model: string;
+  files: string[];
+  dependsOn: string[];
+};
+export type OrchestrationProposal = {
+  version: 1;
+  leadId: string;
+  cwd: string;
+  request: string;
+  author: OrchestrationChoice;
+  settings: OrchestrationSettings;
+  status: "planning" | "ready" | "invalid" | "starting" | "approved";
+  title: string;
+  summary: string;
+  tasks: ProposedTask[];
+  error?: string;
+};
+
+function required(value: unknown, label: string, max = 30_000): string {
+  if (typeof value !== "string" || !value.trim() || value.length > max)
+    throw new Error(`Provide ${label}`);
+  return value.trim();
+}
+function record(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an assignment object");
+  return value as Record<string, unknown>;
+}
+function stringList(value: unknown, label: string, max: number): string[] {
+  if (!Array.isArray(value) || value.length > max)
+    throw new Error(`Invalid ${label}`);
+  return [
+    ...new Set(
+      value
+        .filter((item) => item !== "")
+        .map((item) => required(item, label, 512)),
+    ),
+  ];
+}
+
+export function validateOrchestrationSettings(
+  value: unknown,
+): OrchestrationSettings {
+  const input = record(value);
+  if (
+    !Number.isInteger(input.maxWorkers) ||
+    Number(input.maxWorkers) < 1 ||
+    Number(input.maxWorkers) > 4
+  )
+    throw new Error("Choose 1 to 4 parallel workers");
+  if (
+    !Array.isArray(input.choices) ||
+    !input.choices.length ||
+    input.choices.length > 4096
+  )
+    throw new Error(
+      "No worker models are available, or the model catalog is too large. Check your connected harnesses.",
+    );
+  const choices = input.choices.map((value) => {
+    const item = record(value);
+    const harness = required(item.harness, "a harness", 32) as HarnessId;
+    if (!HARNESSES.includes(harness)) throw new Error("Unknown worker harness");
+    return {
+      harness,
+      model: required(item.model, "a model", 256),
+      name: required(item.name, "a model name", 256),
+    };
+  });
+  return {
+    maxWorkers: Number(input.maxWorkers),
+    choices: choices.filter(
+      (choice, index) =>
+        choices.findIndex(
+          (entry) =>
+            entry.harness === choice.harness && entry.model === choice.model,
+        ) === index,
+    ),
+  };
+}
+
+/** Validate the entire graph before enabling any process or acquiring scopes. */
+export function validateProposedTasks(
+  value: unknown,
+  settings: OrchestrationSettings,
+): ProposedTask[] {
+  if (!Array.isArray(value) || !value.length || value.length > 40)
+    throw new Error("Provide 1 to 40 assignments");
+  const tasks = value.map((value) => {
+    const task = record(value);
+    const harness = required(task.harness, "a harness", 32) as HarnessId;
+    const model = required(task.model, "a model", 256);
+    if (
+      !settings.choices.some(
+        (choice) => choice.harness === harness && choice.model === model,
+      )
+    )
+      throw new Error(
+        "An assignment uses a model outside the available catalog",
+      );
+    const id = required(task.id, "an assignment ID", 64);
+    if (!/^[A-Za-z0-9_-]+$/.test(id))
+      throw new Error(
+        "Assignment IDs must contain letters, numbers, underscores or hyphens",
+      );
+    const files = stringList(task.files, "file scopes", 64);
+    if (
+      !files.length ||
+      files.some(
+        (path) =>
+          /^(\/|\\|[a-z]:)/i.test(path) || path.split(/[\\/]/).includes(".."),
+      )
+    )
+      throw new Error(
+        "Use project-relative file scopes, or '.' for the whole project",
+      );
+    return {
+      id,
+      title: required(task.title, "a task title", 160),
+      prompt: required(task.prompt, "task instructions"),
+      harness,
+      model,
+      files,
+      dependsOn: stringList(task.dependsOn ?? [], "dependencies", 40),
+    };
+  });
+  const ids = new Set(tasks.map((task) => task.id));
+  if (ids.size !== tasks.length)
+    throw new Error("Assignment IDs must be unique");
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const visit = (id: string) => {
+    if (!ids.has(id))
+      throw new Error("A dependency references an unknown assignment");
+    if (visiting.has(id))
+      throw new Error("Assignments have a dependency cycle");
+    if (visited.has(id)) return;
+    visiting.add(id);
+    tasks.find((task) => task.id === id)!.dependsOn.forEach(visit);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  tasks.forEach((task) => visit(task.id));
+  return tasks;
+}
+
+export function orchestrationPlanningPrompt(
+  request: string,
+  settings: OrchestrationSettings,
+): string {
+  return [
+    "Prepare an orchestration proposal for the user to review in MonoCode. Investigate and plan only: do not edit files, start workers, or invoke the MonoCode control CLI. No execution is authorized until the user confirms the assignment card.",
+    "You are the orchestrator: the user selected you in the composer model picker. Decide the task breakdown and choose each worker's harness and model from the available catalog below. Do not ask the user to assemble a team. They can change your choices in the card before confirming.",
+    "Keep planning efficient: inspect only what is needed to understand the request and relevant project conventions. Use the fewest useful tasks, with clear deliverables and acceptance checks. Do not create agents for trivial steps or duplicate investigation. Prefer a fast, economical model for straightforward work and a more capable model when complexity warrants it; do not invent model capabilities or prices. Reuse a suitable harness/model across tasks when that is sufficient. Explain your overall division of work briefly in the summary.",
+    'Use only exact harness/model pairs from the catalog. Give each task self-contained instructions and project-relative write scopes; directories own their descendants. Parallelize independent work with disjoint files. Serialize shared-file edits with dependencies and avoid concurrent repository-wide commands. Assign shared operations and final combined validation to a task with files ["."]. All workers use one shared checkout without worktrees.',
+    "Return your final proposal as one JSON object inside <monocode_proposal>...</monocode_proposal>. The app renders it as an editable card, so do not ask for approval in prose. No Markdown inside the JSON fields. Tasks may reference any task ID; the graph must be acyclic.",
+    'Schema: {"title":"Short project title","summary":"What you will do and how the work fits together","tasks":[{"id":"task-1","title":"Short task title","prompt":"Self-contained instructions, constraints and checks","harness":"exact harness ID","model":"exact model ID","files":["src/feature"],"dependsOn":[]}]}',
+    `Parallel worker limit: ${settings.maxWorkers}`,
+    `<available_models>\n${JSON.stringify(settings.choices)}\n</available_models>`,
+    `<user_request>\n${request}\n</user_request>`,
+  ].join("\n\n");
+}
+
+export function completeOrchestrationProposal(
+  draft: OrchestrationProposal,
+  response: string,
+  error?: string,
+): OrchestrationProposal {
+  try {
+    if (error) throw new Error(error);
+    const tagged = response.match(
+      /<monocode_proposal>\s*([\s\S]*?)\s*<\/monocode_proposal>/,
+    );
+    const fenced = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const raw = (tagged?.[1] ?? fenced?.[1] ?? response).trim();
+    const input = record(JSON.parse(raw));
+    return {
+      ...draft,
+      title: required(input.title, "a proposal title", 160),
+      summary: required(input.summary, "a proposal summary", 2000),
+      tasks: validateProposedTasks(input.tasks, draft.settings),
+      status: "ready",
+      error: undefined,
+    };
+  } catch (reason) {
+    return {
+      ...draft,
+      status: "invalid",
+      error:
+        error ??
+        `Could not prepare the assignment card: ${reason instanceof Error ? reason.message : String(reason)}`,
+    };
+  }
+}
+
+export function proposalMarkdown(proposal: OrchestrationProposal): string {
+  return [
+    `# ${proposal.title}`,
+    proposal.summary,
+    ...proposal.tasks.map(
+      (task) =>
+        `## ${task.title}\n${task.harness} · ${proposal.settings.choices.find((choice) => choice.harness === task.harness && choice.model === task.model)?.name ?? task.model}\n${task.prompt}\nFiles: ${task.files.join(", ")}\nDepends on: ${task.dependsOn.join(", ") || "None"}`,
+    ),
+  ].join("\n\n");
+}
+
+export function withOrchestrationProposal(
+  session: Session,
+  blockId: string,
+  proposal: OrchestrationProposal,
+): Session {
+  return {
+    ...session,
+    blocks: session.blocks.map((block) =>
+      block.id === blockId
+        ? {
+            ...block,
+            text: proposalMarkdown(proposal),
+            orchestration: proposal,
+            streaming: proposal.status === "planning",
+          }
+        : block,
+    ),
+  };
+}
+
+export function proposalBlock(
+  id: string,
+  proposal: OrchestrationProposal,
+): Block {
+  return {
+    id,
+    role: "plan",
+    text: proposalMarkdown(proposal),
+    orchestration: proposal,
+    streaming: true,
+  };
+}
+
+/** A reload must never turn a half-generated card into an executable plan. */
+export function restoreOrchestrationProposal(
+  value: OrchestrationProposal,
+): OrchestrationProposal {
+  if (value.status === "planning")
+    return {
+      ...value,
+      status: "invalid",
+      error: "Planning was interrupted. Generate the assignments again.",
+    };
+  if (value.status === "starting") return { ...value, status: "ready" };
+  return value;
+}
diff --git a/src/lib/orchestrationSummary.ts b/src/lib/orchestrationSummary.ts
new file mode 100644
index 00000000..849f5d95
--- /dev/null
+++ b/src/lib/orchestrationSummary.ts
@@ -0,0 +1,57 @@
+import type { OrchestrationRun, TaskStatus } from "./orchestration";
+import { sessionNeedsInput, type HarnessId, type Session } from "./session";
+
+/** Small history projection; never includes prompts, results or credentials. */
+export type OrchestrationSummary = {
+  status: OrchestrationRun["status"];
+  live?: boolean;
+  tasks: {
+    sessionId: string;
+    title: string;
+    harness: HarnessId;
+    model: string;
+    status: TaskStatus;
+    needsInput?: boolean;
+  }[];
+};
+
+export function summarizeOrchestration(
+  run: OrchestrationRun,
+  sessions: readonly Session[],
+): OrchestrationSummary {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+  return {
+    status: run.status,
+    live: true,
+    tasks: run.tasks.map(({ sessionId, title, harness, model, status }) => ({
+      sessionId,
+      title,
+      harness,
+      model,
+      status,
+      needsInput:
+        !!byId.get(sessionId) && sessionNeedsInput(byId.get(sessionId)!),
+    })),
+  };
+}
+
+export function orchestrationTaskLabel(
+  task: OrchestrationSummary["tasks"][number],
+  summary: OrchestrationSummary,
+): string {
+  if (task.needsInput) return "Needs input";
+  if (
+    !summary.live &&
+    ["running", "cancelling", "queued"].includes(task.status)
+  )
+    return "Saved";
+  if (summary.status === "paused" && task.status === "queued") return "Paused";
+  return {
+    queued: "Queued",
+    running: "Working",
+    cancelling: "Stopping",
+    completed: "Done",
+    failed: "Failed",
+    cancelled: "Cancelled",
+  }[task.status];
+}
diff --git a/src/lib/orchestrationWorkspace.test.ts b/src/lib/orchestrationWorkspace.test.ts
new file mode 100644
index 00000000..0c5840da
--- /dev/null
+++ b/src/lib/orchestrationWorkspace.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  attachOrchestrationWorkers,
+  consolidateOrchestrationTabs,
+  prepareOrchestrationWorkerDetails,
+  releaseOrchestrationWorker,
+} from "./orchestrationWorkspace";
+import { leafIds, newTab, splitPane } from "./layout";
+import { newSession } from "./session";
+import type { OrchestrationRun, OrchestrationTask } from "./orchestration";
+
+const tasks: OrchestrationTask[] = ["worker-a", "worker-b"].map(
+  (sessionId) => ({
+    id: sessionId,
+    sessionId,
+    title: sessionId,
+    harness: "claude",
+    model: "claude:test",
+    prompt: "Work",
+    files: [sessionId],
+    scopes: [`/repo/${sessionId}`],
+    dependsOn: [],
+    status: "running",
+    accepted: false,
+    result: "",
+    delivered: false,
+  }),
+);
+const run: OrchestrationRun = {
+  version: 1,
+  leadId: "lead",
+  cwd: "/repo",
+  status: "active",
+  allowedHarnesses: ["claude"],
+  maxWorkers: 2,
+  cli: "monocode",
+  tasks,
+  continuations: 0,
+  requests: {},
+};
+
+describe("orchestration workspace", () => {
+  it("releases both live and transcript ownership when a lead is deleted", () => {
+    const worker = {
+      ...newSession("claude", "/repo"),
+      orchestrationLeadId: "lead",
+      blocks: [
+        {
+          id: "u",
+          role: "user" as const,
+          text: "Task",
+          orchestrationLeadId: "lead",
+        },
+      ],
+    };
+    const released = releaseOrchestrationWorker(worker, "lead");
+    expect(released.orchestrationLeadId).toBeUndefined();
+    expect(released.blocks[0].orchestrationLeadId).toBeUndefined();
+    expect(released.blocks[0].text).toBe("Task");
+    expect(releaseOrchestrationWorker(worker, "other")).toBe(worker);
+  });
+  it("waits for a slow lead load before opening fast worker transcripts", async () => {
+    const sessions = new Set<string>();
+    let finishLead!: () => void;
+    const host = {
+      openLead: vi.fn(
+        () =>
+          new Promise<void>((resolve) => {
+            finishLead = () => {
+              sessions.add("lead");
+              resolve();
+            };
+          }),
+      ),
+      openWorker: vi.fn(async (id: string) => {
+        sessions.add(id);
+      }),
+      hasSession: (id: string) => sessions.has(id),
+    };
+    const worker = { leadId: "lead", sessionId: "worker-a" };
+    const opening = prepareOrchestrationWorkerDetails([worker], host);
+    await Promise.resolve();
+    expect(host.openWorker).not.toHaveBeenCalled();
+    finishLead();
+    expect(await opening).toEqual({ leadId: "lead", workers: [worker] });
+    expect(host.openWorker).toHaveBeenCalledExactlyOnceWith("worker-a");
+  });
+
+  it("does not publish worker panes when their lead is missing or closed during loading", async () => {
+    const worker = { leadId: "lead", sessionId: "worker-a" };
+    const sessions = new Set<string>();
+    const host = {
+      openLead: vi.fn(async () => {}),
+      openWorker: vi.fn(async () => {
+        sessions.delete("lead");
+      }),
+      hasSession: (id: string) => sessions.has(id),
+    };
+    expect(await prepareOrchestrationWorkerDetails([worker], host)).toBeNull();
+    expect(host.openWorker).not.toHaveBeenCalled();
+    sessions.add("lead");
+    expect(await prepareOrchestrationWorkerDetails([worker], host)).toBeNull();
+  });
+
+  it("folds earlier worker tabs into the lead and moves focus back to it", () => {
+    const tabs = [
+      newTab("lead"),
+      newTab("worker-a"),
+      newTab("worker-b"),
+      newTab("unrelated"),
+    ];
+    const result = consolidateOrchestrationTabs(tabs, tabs[1].id, [run]);
+    expect(result.tabs).toEqual([tabs[0], tabs[3]]);
+    expect(result.activeTabId).toBe(tabs[0].id);
+    expect(
+      consolidateOrchestrationTabs(result.tabs, result.activeTabId, [run]).tabs,
+    ).toBe(result.tabs);
+  });
+  it("keeps unrelated panes when a worker shared a split tab", () => {
+    const lead = newTab("lead");
+    const split = newTab("worker-a");
+    split.layout = splitPane(split.layout, "worker-a", "right", "unrelated");
+    const result = consolidateOrchestrationTabs([lead, split], lead.id, [run]);
+    expect(result.tabs).toHaveLength(2);
+    expect(leafIds(result.tabs[1].layout)).toEqual(["unrelated"]);
+    expect(result.tabs[1].focusedId).toBe("unrelated");
+  });
+  it("retains worker ownership for tabless sessions and leaves other sessions intact", () => {
+    const sessions = ["lead", "worker-a", "worker-b", "unrelated"].map(
+      (id) => ({ ...newSession("claude", "/repo"), id }),
+    );
+    const next = attachOrchestrationWorkers(sessions, [run]);
+    expect(next[0]).toBe(sessions[0]);
+    expect(next[1].orchestrationLeadId).toBe("lead");
+    expect(next[2].orchestrationLeadId).toBe("lead");
+    expect(next[3]).toBe(sessions[3]);
+    expect(attachOrchestrationWorkers(next, [run])).toBe(next);
+  });
+});
diff --git a/src/lib/orchestrationWorkspace.ts b/src/lib/orchestrationWorkspace.ts
new file mode 100644
index 00000000..c849574d
--- /dev/null
+++ b/src/lib/orchestrationWorkspace.ts
@@ -0,0 +1,109 @@
+import { closeLeaf, leafIds, type WorkspaceTab } from "./layout";
+import type { OrchestrationRun } from "./orchestration";
+import type { Session } from "./session";
+
+export function releaseOrchestrationWorker(
+  session: Session,
+  leadId: string,
+): Session {
+  if (
+    session.orchestrationLeadId !== leadId &&
+    !session.blocks.some((block) => block.orchestrationLeadId === leadId)
+  )
+    return session;
+  return {
+    ...session,
+    orchestrationLeadId:
+      session.orchestrationLeadId === leadId
+        ? undefined
+        : session.orchestrationLeadId,
+    blocks: session.blocks.map((block) =>
+      block.orchestrationLeadId === leadId
+        ? { ...block, orchestrationLeadId: undefined }
+        : block,
+    ),
+  };
+}
+
+/** Load the lead first so a fast worker read cannot publish panes without a tab. */
+export async function prepareOrchestrationWorkerDetails<
+  T extends { leadId: string; sessionId: string },
+>(
+  workers: T[],
+  host: {
+    openLead: (id: string) => Promise<void>;
+    openWorker: (id: string) => Promise<unknown>;
+    hasSession: (id: string) => boolean;
+  },
+) {
+  const list = workers.filter(
+    (worker) => worker.leadId && worker.leadId !== worker.sessionId,
+  );
+  if (!list.length) return null;
+  const leadId = list[0].leadId;
+  await host.openLead(leadId);
+  if (!host.hasSession(leadId)) return null;
+  await Promise.all(list.map((worker) => host.openWorker(worker.sessionId)));
+  if (!host.hasSession(leadId)) return null;
+  return {
+    leadId,
+    workers: list.filter((worker) => host.hasSession(worker.sessionId)),
+  };
+}
+
+/**
+ * Adopt worker tabs made by the earlier preview into an already-open lead.
+ * A worker the user asked to inspect is a tab inside an editor pane rather
+ * than a session leaf, so it never reaches this.
+ */
+export function consolidateOrchestrationTabs(
+  tabs: WorkspaceTab[],
+  activeTabId: string,
+  runs: OrchestrationRun[],
+) {
+  const parents = new Map(
+    runs.flatMap((run) =>
+      tabs.some((tab) => leafIds(tab.layout).includes(run.leadId))
+        ? run.tasks.map((task) => [task.sessionId, run.leadId] as const)
+        : [],
+    ),
+  );
+  const active = tabs.find((tab) => tab.id === activeTabId);
+  const lead = active && parents.get(active.focusedId);
+  let changed = false;
+  const next = tabs.flatMap((tab) => {
+    let remaining: WorkspaceTab | null = tab;
+    for (const id of leafIds(tab.layout)) {
+      if (remaining && parents.has(id)) {
+        remaining = closeLeaf(remaining, id);
+        changed = true;
+      }
+    }
+    return remaining ? [remaining] : [];
+  });
+  return {
+    tabs: changed ? next : tabs,
+    activeTabId: lead
+      ? next.find((tab) => leafIds(tab.layout).includes(lead))!.id
+      : activeTabId,
+  };
+}
+
+export function attachOrchestrationWorkers(
+  sessions: Session[],
+  runs: OrchestrationRun[],
+) {
+  const parents = new Map(
+    runs.flatMap((run) =>
+      run.tasks.map((task) => [task.sessionId, run.leadId] as const),
+    ),
+  );
+  let changed = false;
+  const next = sessions.map((session) => {
+    const parent = parents.get(session.id);
+    if (!parent || session.orchestrationLeadId === parent) return session;
+    changed = true;
+    return { ...session, orchestrationLeadId: parent };
+  });
+  return changed ? next : sessions;
+}
diff --git a/src/lib/promptOutline.ts b/src/lib/promptOutline.ts
index 00b50559..b3e99811 100644
--- a/src/lib/promptOutline.ts
+++ b/src/lib/promptOutline.ts
@@ -8,7 +8,7 @@ export type OutlineAnchor = OutlineBand & { id: string };
 export const NEAR_END_PX = 16;
 
 export function promptBlocks(blocks: Block[]): Block[] {
-  return blocks.filter((block) => block.role === "user");
+  return blocks.filter((block) => block.role === "user" && !block.internal);
 }
 
 /**
diff --git a/src/lib/session.ts b/src/lib/session.ts
index 5477fabf..947b1ceb 100644
--- a/src/lib/session.ts
+++ b/src/lib/session.ts
@@ -4,6 +4,7 @@ import type { HandoffComposerCard } from "./handoff";
 import type { InboxComposerCard } from "./githubTasks";
 import type { InboxAskContext } from "./inboxAsk";
 import type { NoteCardMeta, NoteComposerCard } from "./notes";
+import type { OrchestrationProposal } from "./orchestrationPlan";
 import type { LinkedWorkItemUpdateCard } from "./linkedWorkItemActivity";
 import {
   defaultSessionChoice,
@@ -55,7 +56,8 @@ export type TaskListMeta = {
 };
 
 /** One-shot behavior selected in the composer for the next harness turn. */
-export type TurnIntent = "default" | "plan" | "build";
+export type TurnIntent = "default" | "plan" | "build" | "orchestrate";
+export type ComposerTurnOptions = { intent?: TurnIntent };
 
 export type PlanStatus = "streaming" | "ready" | "building" | "built";
 
@@ -232,6 +234,15 @@ export type Block = {
   agentRun?: AgentRunMeta;
   taskList?: TaskListMeta;
   plan?: PlanBlockMeta;
+  orchestration?: OrchestrationProposal;
+  /** Parent conversation for an internal orchestration worker. */
+  orchestrationLeadId?: string;
+  /**
+   * A turn the app wrote on the user's behalf to keep an orchestration moving.
+   * The harness needs it; the transcript hides it, so a run reads as one
+   * conversation rather than the user narrating their own agents.
+   */
+  internal?: boolean;
   handoff?: HandoffMeta;
   secondOpinion?: SecondOpinionMeta;
   /** Note chip shown on this user turn. Body is not stored; the harness already received it. */
@@ -275,6 +286,8 @@ export const RUNTIME_MODE_HINT: Record<RuntimeMode, string> = {
 };
 
 export type Session = {
+  /** Internal worker: displayed in its lead's panel rather than a workspace tab. */
+  orchestrationLeadId?: string;
   /** Temporary Inbox conversation: shares the runtime, never saved as a session. */
   inboxAsk?: InboxAskContext;
   id: string;
diff --git a/src/lib/sessionHistory.test.ts b/src/lib/sessionHistory.test.ts
index 7a8505e3..65647470 100644
--- a/src/lib/sessionHistory.test.ts
+++ b/src/lib/sessionHistory.test.ts
@@ -9,12 +9,9 @@ import {
 } from "./sessionHistory";
 import { newSession } from "./session";
 import type { SessionSummary } from "./sessionStore";
+import type { OrchestrationRun } from "./orchestration";
 
-function summary(
-  id: string,
-  cwd: string,
-  updatedAt = 1,
-): SessionSummary {
+function summary(id: string, cwd: string, updatedAt = 1): SessionSummary {
   return {
     id,
     cwd,
@@ -30,6 +27,93 @@ function summary(
 }
 
 describe("historyWithLiveSessions", () => {
+  const run: OrchestrationRun = {
+    version: 1,
+    leadId: "lead",
+    cwd: "/tmp/project-a",
+    status: "active",
+    allowedHarnesses: ["codex"],
+    maxWorkers: 2,
+    cli: "monocode",
+    continuations: 0,
+    requests: {},
+    tasks: ["worker-a", "worker-b"].map((id) => ({
+      id,
+      sessionId: id,
+      title: id,
+      harness: "codex",
+      model: "codex:test",
+      prompt: "Task",
+      files: [id],
+      scopes: [id],
+      dependsOn: [],
+      status: "running",
+      accepted: false,
+      result: "",
+      delivered: false,
+    })),
+  };
+
+  it("groups live and already-saved workers under their lead before adoption effects run", () => {
+    const sessions = ["lead", "worker-a", "worker-b"].map((id) => ({
+      ...newSession("codex", run.cwd),
+      id,
+      blocks: [{ id: "u", role: "user" as const, text: "Build" }],
+      busy: id !== "lead",
+    }));
+    const rows = historyWithLiveSessions(
+      [
+        summary("lead", run.cwd),
+        summary("worker-a", run.cwd),
+        summary("unrelated", run.cwd),
+      ],
+      sessions,
+      run.cwd,
+      undefined,
+      [run],
+    );
+    expect(rows.map((row) => row.id).sort()).toEqual(["lead", "unrelated"]);
+    expect(rows.find((row) => row.id === "lead")?.orchestration).toMatchObject({
+      live: true,
+      status: "active",
+      tasks: [{ sessionId: "worker-a" }, { sessionId: "worker-b" }],
+    });
+  });
+
+  it("keeps ownership after restart, cache merges, and replacement runs", () => {
+    const history: SessionSummary[] = [
+      {
+        ...summary("lead", run.cwd),
+        orchestration: { status: "paused", tasks: run.tasks },
+      },
+      summary("worker-a", run.cwd),
+      { ...summary("older-worker", run.cwd), orchestrationLeadId: "lead" },
+    ];
+    const merged = mergeHistorySummary(history, summary("lead", run.cwd, 2));
+    const rows = historyWithLiveSessions(merged, [], run.cwd);
+    expect(rows.map((row) => row.id)).toEqual(["lead"]);
+    expect(rows[0].orchestration?.tasks).toHaveLength(2);
+    const replacement = historyWithLiveSessions(
+      merged,
+      [],
+      run.cwd,
+      undefined,
+      [{ ...run, tasks: [] }],
+    );
+    expect(replacement.map((row) => row.id)).toEqual(["lead"]);
+    expect(replacement[0].orchestration?.tasks).toEqual([]);
+  });
+
+  it("does not inject an internal worker without a loaded run", () => {
+    const worker = {
+      ...newSession("codex", run.cwd),
+      id: "worker",
+      orchestrationLeadId: "lead",
+      busy: true,
+    };
+    expect(historyWithLiveSessions([], [worker], run.cwd)).toEqual([]);
+  });
+
   it("drops persisted sessions from other projects", () => {
     const history = [
       summary("a1", "/tmp/project-a"),
@@ -105,12 +189,10 @@ describe("historyWithLiveSessions", () => {
     session.busy = true;
     session.branch = "feat/picker";
 
-    const rows = historyWithLiveSessions(
-      [],
-      [session],
-      "/tmp/agent-terminal",
-      { repo: "monocode", branch: "main" },
-    );
+    const rows = historyWithLiveSessions([], [session], "/tmp/agent-terminal", {
+      repo: "monocode",
+      branch: "main",
+    });
     expect(rows[0]).toMatchObject({
       id: session.id,
       repo: "monocode",
@@ -162,12 +244,18 @@ describe("filterSessionsByQuery", () => {
 
   it("matches conversation titles", () => {
     const rows = [
-      { ...summary("a1", "/tmp/project-a"), title: "cursor · Fix sidebar search" },
-      { ...summary("a2", "/tmp/project-a"), title: "cursor · Archive sessions" },
+      {
+        ...summary("a1", "/tmp/project-a"),
+        title: "cursor · Fix sidebar search",
+      },
+      {
+        ...summary("a2", "/tmp/project-a"),
+        title: "cursor · Archive sessions",
+      },
     ];
-    expect(filterSessionsByQuery(rows, "sidebar").map((row) => row.id)).toEqual([
-      "a1",
-    ]);
+    expect(filterSessionsByQuery(rows, "sidebar").map((row) => row.id)).toEqual(
+      ["a1"],
+    );
   });
 
   it("matches model and branch labels", () => {
@@ -252,9 +340,7 @@ describe("pinned sessions", () => {
   });
 
   it("preserves pin when an incoming summary omits it", () => {
-    const current = [
-      { ...summary("pin", "/tmp/project-a", 5), pinned: true },
-    ];
+    const current = [{ ...summary("pin", "/tmp/project-a", 5), pinned: true }];
     const next = mergeHistorySummary(
       current,
       summary("pin", "/tmp/project-a", 9),
diff --git a/src/lib/sessionHistory.ts b/src/lib/sessionHistory.ts
index 59fffd7d..149283c6 100644
--- a/src/lib/sessionHistory.ts
+++ b/src/lib/sessionHistory.ts
@@ -1,7 +1,13 @@
+import type { OrchestrationRun } from "./orchestration";
+import { summarizeOrchestration } from "./orchestrationSummary";
 import { fuzzyMatch } from "./fuzzy";
 import { projectName } from "./paths";
 import { sameProjectPath } from "./recents";
-import { sessionDisplayTitle, sessionNeedsInput, type Session } from "./session";
+import {
+  sessionDisplayTitle,
+  sessionNeedsInput,
+  type Session,
+} from "./session";
 import { shouldPersistSession, type SessionSummary } from "./sessionStore";
 
 export type SessionGitHint = {
@@ -27,6 +33,9 @@ export function mergeHistorySummary(
     ...summary,
     archived: summary.archived ?? previous?.archived,
     pinned: summary.pinned ?? previous?.pinned,
+    orchestration: summary.orchestration ?? previous?.orchestration,
+    orchestrationLeadId:
+      summary.orchestrationLeadId ?? previous?.orchestrationLeadId,
   };
   return [next, ...current.filter((entry) => entry.id !== summary.id)].sort(
     compareSessionSummaries,
@@ -95,6 +104,7 @@ export function summaryFromSession(
 ): SessionSummary {
   return {
     id: session.id,
+    orchestrationLeadId: session.orchestrationLeadId,
     cwd: session.cwd,
     harness: session.harness,
     model: session.model,
@@ -137,12 +147,30 @@ export function historyWithLiveSessions(
   sessions: Session[],
   cwd: string,
   git?: SessionGitHint,
+  runs: readonly OrchestrationRun[] = [],
 ): SessionSummary[] {
-  const inboxIds = new Set(sessions.filter(session => session.inboxAsk).map(session => session.id));
-  let rows = history.filter((entry) => !inboxIds.has(entry.id) && sameProjectPath(entry.cwd, cwd));
+  const workerIds = new Set([
+    ...sessions
+      .filter((session) => session.orchestrationLeadId)
+      .map((session) => session.id),
+    ...history.flatMap(
+      (row) => row.orchestration?.tasks.map((task) => task.sessionId) ?? [],
+    ),
+    ...runs.flatMap((run) => run.tasks.map((task) => task.sessionId)),
+  ]);
+  const inboxIds = new Set(
+    sessions.filter((session) => session.inboxAsk).map((session) => session.id),
+  );
+  let rows = history.filter(
+    (entry) =>
+      !inboxIds.has(entry.id) &&
+      !entry.orchestrationLeadId &&
+      !workerIds.has(entry.id) &&
+      sameProjectPath(entry.cwd, cwd),
+  );
   const hint = projectGitHint(rows, gitOverlayForCwd(cwd, git));
   for (const session of sessions) {
-    if (session.inboxAsk) continue;
+    if (session.inboxAsk || workerIds.has(session.id)) continue;
     if (!sameProjectPath(session.cwd, cwd)) continue;
     const live = session.busy || sessionNeedsInput(session);
     if (!shouldPersistSession(session) && !live) continue;
@@ -153,5 +181,13 @@ export function historyWithLiveSessions(
     };
     rows = mergeHistorySummary(rows, summaryFromSession(session, sessionHint));
   }
-  return [...rows].sort(compareSessionSummaries);
+  const byLead = new Map(runs.map((run) => [run.leadId, run]));
+  return rows
+    .map((row) => {
+      const run = byLead.get(row.id);
+      return run
+        ? { ...row, orchestration: summarizeOrchestration(run, sessions) }
+        : row;
+    })
+    .sort(compareSessionSummaries);
 }
diff --git a/src/lib/sessionStore.test.ts b/src/lib/sessionStore.test.ts
index a762b648..29755152 100644
--- a/src/lib/sessionStore.test.ts
+++ b/src/lib/sessionStore.test.ts
@@ -92,6 +92,35 @@ describe("persisting a subagent's trail", () => {
 });
 
 describe("sanitizeSessionForPersist", () => {
+  it("preserves an internal worker's lead, hidden turns, and token metrics", () => {
+    const session = {
+      ...newSession("claude", "/repo"),
+      orchestrationLeadId: "lead",
+    };
+    session.blocks = [
+      {
+        id: "u",
+        role: "user",
+        text: "Bounded assignment",
+        internal: true,
+        turnMetrics: { inputTokens: 100, outputTokens: 20 },
+      },
+    ];
+    const saved = sanitizeSessionForPersist(session);
+    expect(saved.blocks[0]).toMatchObject({
+      orchestrationLeadId: "lead",
+      internal: true,
+      turnMetrics: { inputTokens: 100, outputTokens: 20 },
+    });
+    expect(session.blocks[0].orchestrationLeadId).toBeUndefined();
+    expect(
+      sanitizeSessionForPersist({
+        ...session,
+        orchestrationLeadId: undefined,
+        blocks: saved.blocks,
+      }).blocks[0],
+    ).toEqual(saved.blocks[0]);
+  });
   it("persists model provenance recorded on a user turn", () => {
     const session = newSession("claude", "/tmp/project", "claude:opus-5");
     session.blocks = [
diff --git a/src/lib/sessionStore.ts b/src/lib/sessionStore.ts
index ae9170da..2d80f896 100644
--- a/src/lib/sessionStore.ts
+++ b/src/lib/sessionStore.ts
@@ -23,8 +23,13 @@ import type {
   TurnMetrics,
 } from "./session";
 import { HARNESSES, RUNTIME_MODES } from "./session";
+import { restoreOrchestrationProposal } from "./orchestrationPlan";
+
+import type { OrchestrationSummary } from "./orchestrationSummary";
 
 export type SessionSummary = {
+  orchestrationLeadId?: string;
+  orchestration?: OrchestrationSummary;
   id: string;
   cwd: string;
   harness: HarnessId;
@@ -44,6 +49,7 @@ export type SessionSummary = {
 };
 
 type SessionRecord = {
+  orchestrationLeadId?: string;
   id: string;
   cwd: string;
   harness: string;
@@ -148,10 +154,17 @@ export function sanitizeLinkedWorkItem(
 export function sanitizeSessionForPersist(
   session: Session,
 ): SessionUpsertPayload {
+  const firstUser = session.blocks.findIndex((block) => block.role === "user");
   return {
     ...persistableMeta(session),
     blocks: session.blocks
-      .map(sanitizeBlock)
+      .map((block, index) =>
+        sanitizeBlock(
+          index === firstUser && session.orchestrationLeadId
+            ? { ...block, orchestrationLeadId: session.orchestrationLeadId }
+            : block,
+        ),
+      )
       .filter((block): block is Block => block != null),
   };
 }
@@ -193,7 +206,17 @@ export async function upsertSession(
   const payload = sanitizeSessionForPersist(session);
   const summary = await enqueueSessionWrite(session.id, async () => {
     if (deletedSessionIds.has(session.id)) return null;
-    return invoke<SessionSummary>("session_upsert", { session: payload });
+    return invoke<SessionSummary>("session_upsert", {
+      session: {
+        ...payload,
+        blocks: payload.blocks.map((block) =>
+          block.orchestrationLeadId &&
+          deletedSessionIds.has(block.orchestrationLeadId)
+            ? { ...block, orchestrationLeadId: undefined }
+            : block,
+        ),
+      },
+    });
   });
   return summary ? normalizeSummary(summary) : null;
 }
@@ -217,7 +240,7 @@ function blockToken(block: Block): number {
 }
 
 export function persistFingerprint(session: Session): string {
-  return `${JSON.stringify(persistableMeta(session))}|${session.blocks
+  return `${JSON.stringify(persistableMeta(session))}|${session.orchestrationLeadId ?? ""}|${session.blocks
     .map(blockToken)
     .join(",")}`;
 }
@@ -309,6 +332,9 @@ export async function getSession(sessionId: string): Promise<Session | null> {
 export async function deleteSession(sessionId: string): Promise<void> {
   deletedSessionIds.add(sessionId);
   try {
+    // A lead's workers may still have writes in flight. Finish those before
+    // the deletion transaction strips their ownership metadata.
+    await Promise.all([...sessionWriteQueues.values()]);
     await enqueueSessionWrite(sessionId, () =>
       invoke<void>("session_delete", { sessionId }),
     );
@@ -409,6 +435,15 @@ function sanitizeBlock(block: Block): Block | null {
   if (block.durationMs != null) next.durationMs = block.durationMs;
   const turnModel = sanitizeTurnModel(block.turnModel);
   if (block.role === "user" && turnModel) next.turnModel = turnModel;
+  if (
+    block.role === "user" &&
+    typeof block.orchestrationLeadId === "string" &&
+    isPersistableId(block.orchestrationLeadId)
+  )
+    next.orchestrationLeadId = block.orchestrationLeadId;
+  // Without this the transcript would show the app's orchestration turns as
+  // the user's own after a reload.
+  if (block.role === "user" && block.internal) next.internal = true;
   const turnMetrics = sanitizeTurnMetrics(block.turnMetrics);
   if (block.role === "user" && turnMetrics) next.turnMetrics = turnMetrics;
   if (block.tool) next.tool = block.tool;
@@ -427,6 +462,8 @@ function sanitizeBlock(block: Block): Block | null {
   if (taskList) next.taskList = taskList;
   else if (block.role === "tasks") return null;
   const plan = sanitizePlan(block.plan, block.text);
+  if (block.orchestration)
+    next.orchestration = restoreOrchestrationProposal(block.orchestration);
   if (plan) next.plan = plan;
   else if (block.role === "plan") {
     next.plan = { status: "ready", originalText: block.text };
@@ -673,6 +710,10 @@ function recordToSession(record: SessionRecord): Session {
     title: record.title,
     blocks,
     busy: false,
+    orchestrationLeadId: record.orchestrationLeadId ?? blocks.find(
+      (block) =>
+        block.orchestrationLeadId && block.orchestrationLeadId !== record.id,
+    )?.orchestrationLeadId,
     ...(record.providerSessionId
       ? { providerSessionId: record.providerSessionId }
       : {}),
diff --git a/src/lib/sessionStoreConcurrency.test.ts b/src/lib/sessionStoreConcurrency.test.ts
index ece0fd4b..96da414c 100644
--- a/src/lib/sessionStoreConcurrency.test.ts
+++ b/src/lib/sessionStoreConcurrency.test.ts
@@ -41,6 +41,37 @@ afterEach(() => {
 });
 
 describe("session persistence concurrency", () => {
+  it("drains worker writes before deleting a lead and strips ownership from later snapshots", async () => {
+    const firstWrite = deferred<unknown>();
+    const commands: string[] = [];
+    mocks.invoke.mockImplementation((command: string) => {
+      commands.push(command);
+      return command === "session_upsert" && commands.length === 1
+        ? firstWrite.promise
+        : Promise.resolve();
+    });
+    const { deleteSession, upsertSession } = await loadStore();
+    const worker = { ...session("worker"), orchestrationLeadId: "lead" };
+    const writing = upsertSession(worker);
+    await vi.waitFor(() => expect(commands).toEqual(["session_upsert"]));
+    const queued = upsertSession(worker);
+    const deleting = deleteSession("lead");
+    expect(commands).toEqual(["session_upsert"]);
+    firstWrite.resolve(undefined);
+    await Promise.all([writing, queued, deleting]);
+    expect(commands).toEqual([
+      "session_upsert",
+      "session_upsert",
+      "session_delete",
+    ]);
+    await upsertSession(worker);
+    for (const [, args] of mocks.invoke.mock.calls
+      .slice(1)
+      .filter(([command]) => command === "session_upsert")) {
+      expect(args.session.blocks[0].orchestrationLeadId).toBeUndefined();
+    }
+  });
+
   it("serializes deletion after an active write and drops a queued late upsert", async () => {
     const firstWrite = deferred<unknown>();
     const commands: string[] = [];
diff --git a/src/lib/workspaceSnapshot.test.ts b/src/lib/workspaceSnapshot.test.ts
index f762da53..93e8b689 100644
--- a/src/lib/workspaceSnapshot.test.ts
+++ b/src/lib/workspaceSnapshot.test.ts
@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 import { INTERRUPT_MESSAGE } from "./inFlight";
 import {
   leaf,
+  leafIds,
+  newAgentTab,
   newChangesTab,
   newCommitTab,
   newFileTab,
@@ -9,6 +11,7 @@ import {
   newSessionChangesTab,
   newTab,
   newTerminalFile,
+  splitPane,
 } from "./layout";
 import { createProjectTerminal } from "./projectTerminal";
 import { newSession, type Session } from "./session";
@@ -177,6 +180,45 @@ describe("collectWorkspaceSnapshot", () => {
     expect(snapshot.projectTerminals).toEqual([]);
   });
 
+  it("drops agent tabs, and the pane holding only them", () => {
+    const file = newFileTab("/tmp/a/README.md", "/tmp/a");
+    const agent = newAgentTab("Audit the UI", "/tmp/a", {
+      sessionId: "worker",
+      leadId: "s1",
+      harness: "codex",
+    });
+    const mixed = newAgentTab("Audit the engine", "/tmp/a", {
+      sessionId: "worker-2",
+      leadId: "s1",
+      harness: "codex",
+    });
+    const tab = {
+      ...newTab("s1"),
+      id: "t1",
+      layout: splitPane(newTab("s1").layout, "s1", "right", "e1"),
+      editorPanes: [
+        { id: "e1", files: [agent], activeFileId: agent.id },
+        { id: "e2", files: [file, mixed], activeFileId: mixed.id },
+      ],
+    };
+    const snapshot = collectWorkspaceSnapshot(
+      [tab],
+      [],
+      "t1",
+      "/tmp/a",
+      new Map(),
+    );
+    const panes = snapshot.tabs[0]!.editorPanes;
+    // The agent-only pane is gone along with its leaf; the mixed one keeps its
+    // file and falls back to it as the active tab.
+    expect(panes.map((pane) => pane.id)).toEqual(["e2"]);
+    expect(panes[0]!.files.map((entry) => entry.path)).toEqual([
+      "/tmp/a/README.md",
+    ]);
+    expect(panes[0]!.activeFileId).toBe(file.id);
+    expect(leafIds(snapshot.tabs[0]!.layout)).toEqual(["s1"]);
+  });
+
   it("round-trips a unified Changes tab", () => {
     const file = newChangesTab("/tmp/a", "/tmp/a/src/lib.rs", "staged");
     const tab = {
diff --git a/src/lib/workspaceSnapshot.ts b/src/lib/workspaceSnapshot.ts
index 250403a2..22ac57ac 100644
--- a/src/lib/workspaceSnapshot.ts
+++ b/src/lib/workspaceSnapshot.ts
@@ -1,6 +1,7 @@
 import { markTurnInterrupted, type ResumedWorkspace } from "./inFlight";
 import {
   closeLeaf,
+  isAgentTab,
   isTerminalTab,
   leafIds,
   newTab,
@@ -63,7 +64,7 @@ export function collectWorkspaceSnapshot(
   projectTerminals: ProjectTerminalDock[] = [],
 ): WorkspaceSnapshot {
   const snapshot = withoutInboxSessions({
-    tabs: tabs.map(sanitizeTab).filter((tab): tab is WorkspaceTab => tab != null),
+    tabs: withoutAgentTabs(tabs).map(sanitizeTab).filter((tab): tab is WorkspaceTab => tab != null),
     sessions: sessions.map(sessionStub).filter((stub): stub is WorkspaceSessionStub => stub != null),
     activeTabId,
     projectCwd: projectCwd.trim() || "~",
@@ -111,6 +112,36 @@ function parseProjectReturnTargets(raw: unknown): ProjectReturnMemory {
   return memory;
 }
 
+/**
+ * Agent tabs watch a live worker, and a run does not outlive the window that
+ * started it. Dropping them in `sanitizeFile` would strand an empty pane and
+ * cost the whole workspace tab on restore, so the pane is closed here instead.
+ */
+function withoutAgentTabs(tabs: WorkspaceTab[]): WorkspaceTab[] {
+  return tabs.flatMap(tab => {
+    if (!tab.editorPanes.some(pane => pane.files.some(isAgentTab))) return [tab];
+    let remaining: WorkspaceTab | null = tab;
+    const panes: EditorPane[] = [];
+    for (const pane of tab.editorPanes) {
+      const files = pane.files.filter(file => !isAgentTab(file));
+      if (files.length === pane.files.length) {
+        panes.push(pane);
+      } else if (files.length === 0) {
+        remaining = remaining && closeLeaf(remaining, pane.id);
+      } else {
+        panes.push({
+          ...pane,
+          files,
+          activeFileId: files.some(file => file.id === pane.activeFileId)
+            ? pane.activeFileId
+            : files[0].id,
+        });
+      }
+    }
+    return remaining ? [{ ...remaining, editorPanes: panes }] : [];
+  });
+}
+
 /** Also removes tabs saved by the earlier, persistent Inbox implementation. */
 function withoutInboxSessions(snapshot: WorkspaceSnapshot): WorkspaceSnapshot {
   const inboxIds = snapshot.sessions.filter(session => session.inboxAsk).map(session => session.id);
diff --git a/src/surfaces/AgentTabView.tsx b/src/surfaces/AgentTabView.tsx
new file mode 100644
index 00000000..5625bfad
--- /dev/null
+++ b/src/surfaces/AgentTabView.tsx
@@ -0,0 +1,61 @@
+import { AgentTranscript } from "./AgentTranscript";
+import { HarnessIcon } from "../chrome/HarnessIcon";
+import { findModel } from "../lib/models";
+import { HARNESS_TITLE, sessionWorkCwd, type Session } from "../lib/session";
+
+/**
+ * One orchestration worker, watched from its lead's workspace.
+ *
+ * Read-only on purpose: the run belongs to the orchestrator, which decides
+ * what each worker is asked and when. A composer here would put a second
+ * voice into a conversation the lead is holding, so the way to change course
+ * is to say so in the lead's own transcript.
+ */
+export function AgentTabView({
+  title,
+  session,
+  visible,
+  onOpenFile,
+}: {
+  title: string;
+  session?: Session;
+  visible: boolean;
+  onOpenFile?: (path: string) => void;
+}) {
+  if (!session) {
+    return (
+      <div className="grid h-full place-items-center px-6 text-center">
+        <p className="max-w-sm text-[12px] leading-5 text-content/45">
+          This agent is no longer running. Its work is summarised in the
+          orchestrator's conversation.
+        </p>
+      </div>
+    );
+  }
+  const model = findModel(session.model)?.name ?? session.model;
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="min-h-0 flex-1">
+        <AgentTranscript
+          blocks={session.blocks}
+          busy={session.busy}
+          cwd={sessionWorkCwd(session)}
+          harness={session.harness}
+          model={session.model}
+          visible={visible}
+          onOpenFile={onOpenFile}
+          managed
+        />
+      </div>
+      <footer className="flex shrink-0 items-center gap-1.5 border-t border-content/10 px-3 py-1.5 font-sans text-[11px] text-content/45">
+        <HarnessIcon harness={session.harness} className="size-3.5 shrink-0" />
+        <span className="min-w-0 truncate" title={title}>
+          {model} · {HARNESS_TITLE[session.harness]}
+        </span>
+        <span className="ml-auto shrink-0">
+          Run by the orchestrator · read-only
+        </span>
+      </footer>
+    </div>
+  );
+}
diff --git a/src/surfaces/AgentTranscript.test.ts b/src/surfaces/AgentTranscript.test.ts
index 7088bb62..e3c2d88c 100644
--- a/src/surfaces/AgentTranscript.test.ts
+++ b/src/surfaces/AgentTranscript.test.ts
@@ -25,6 +25,57 @@ function render(
 }
 
 describe("AgentTranscript collapsed work", () => {
+  it("reveals an orchestration result after the finished turn and before its action row", () => {
+    const card: Block = {
+      id: "proposal",
+      role: "plan",
+      text: "Assignment plan",
+      orchestration: {
+        version: 1,
+        leadId: "lead",
+        cwd: "/repo",
+        request: "Build",
+        author: { harness: "claude", model: "claude:test", name: "Lead" },
+        settings: {
+          choices: [
+            { harness: "claude", model: "claude:test", name: "Worker" },
+          ],
+          maxWorkers: 2,
+        },
+        status: "ready",
+        title: "Proposed assignments",
+        summary: "Implement and verify",
+        tasks: [],
+      },
+    };
+    const blocks: Block[] = [
+      {
+        id: "user",
+        role: "user",
+        text: "Build",
+        startedAt: 1000,
+        durationMs: 500,
+      },
+      card, // Existing records have the card before the work.
+      tool("inspection"),
+      {
+        id: "answer",
+        role: "assistant",
+        text: "The investigation is complete.",
+      },
+    ];
+    expect(render(blocks, true)).not.toContain("data-orchestration-review");
+    const finished = render(blocks);
+    expect(finished.indexOf("The investigation is complete.")).toBeLessThan(
+      finished.indexOf("data-orchestration-result"),
+    );
+    expect(finished.indexOf("data-orchestration-review")).toBeLessThan(
+      finished.indexOf('aria-label="Worked for 1s"'),
+    );
+    expect(finished.match(/data-orchestration-review/g)).toHaveLength(1);
+    card.orchestration!.status = "planning";
+    expect(render(blocks)).not.toContain("data-orchestration-review");
+  });
   it("renders a standalone user URL as a compact link preview", () => {
     const markup = render([
       { id: "user", role: "user", text: "https://www.example.com/docs" },
@@ -374,3 +425,26 @@ describe("AgentTranscript collapsed work", () => {
     expect(markup).toContain("Checked.");
   });
 });
+
+describe("worker assignment prompts", () => {
+  it("hides the assignment envelope and keeps the task text", () => {
+    const markup = renderToStaticMarkup(
+      createElement(AgentTranscript, {
+        managed: true,
+        blocks: [
+          {
+            id: "u1",
+            role: "user",
+            internal: true,
+            text: "Review the current branch against main.\n\n<monocode_assignment>\nYou are a worker managed by a MonoCode lead. Your assigned write scope is: src/App.tsx.\n</monocode_assignment>",
+          },
+          { id: "a1", role: "assistant", text: "Looking now" },
+        ],
+      }),
+    );
+    expect(markup).toContain("Review the current branch against main.");
+    expect(markup).toContain("Looking now");
+    expect(markup).not.toContain("monocode_assignment");
+    expect(markup).not.toContain("You are a worker managed by a MonoCode lead");
+  });
+});
diff --git a/src/surfaces/AgentTranscript.tsx b/src/surfaces/AgentTranscript.tsx
index 10a64c88..83cbeca1 100644
--- a/src/surfaces/AgentTranscript.tsx
+++ b/src/surfaces/AgentTranscript.tsx
@@ -29,6 +29,7 @@ import { FilePreview } from "../chrome/FilePreview";
 import { FileTypeIcon } from "../chrome/FileTypeIcon";
 import { ToolDiffPreview } from "../chrome/ToolDiffPreview";
 import { PlanPreview } from "../chrome/PlanPreview";
+import { OrchestrationPreview } from "../chrome/OrchestrationPreview";
 import { TaskListPreview } from "../chrome/TaskListPreview";
 import {
   HandoffButton,
@@ -47,6 +48,7 @@ import {
   stubFilePreview,
 } from "../lib/harness/preview";
 import { copyText } from "../lib/clipboard";
+import { visibleUserPrompt } from "../lib/orchestration";
 import { playCue } from "../lib/sounds";
 import { legacyTaskListFromText } from "../lib/taskList";
 import { displayPath, resolveWorkspacePath } from "../lib/paths";
@@ -135,6 +137,8 @@ type Props = {
   latestTurnAccessory?: ReactNode;
   /** False while another tab is in front; local transcript state is retained. */
   visible?: boolean;
+  /** A worker's transcript: show the orchestrator's turns instead of hiding them. */
+  managed?: boolean;
 };
 
 function AgentTranscriptComponent({
@@ -159,6 +163,7 @@ function AgentTranscriptComponent({
   onRevealReady,
   latestTurnAccessory,
   visible = true,
+  managed = false,
 }: Props) {
   const lockOverscroll = useLockOverscroll<HTMLDivElement>();
   const scroller = useRef<HTMLDivElement>(null);
@@ -184,7 +189,7 @@ function AgentTranscriptComponent({
   );
   const transcriptLayout = useTranscriptLayout();
   const promptAnchor = useTranscriptAnchor();
-  const lastUserId = lastUserBlockId(blocks);
+  const lastUserId = lastUserBlockId(blocks, managed);
   const seenUserId = useRef(lastUserId);
   if (lastUserId !== seenUserId.current) {
     seenUserId.current = lastUserId;
@@ -312,7 +317,7 @@ function AgentTranscriptComponent({
     return () => observer.disconnect();
   }, [scrollerEl, setShowJump, visible]);
 
-  const turns = groupTurns(blocks);
+  const turns = groupTurns(blocks, managed);
   const firstVisibleTurn = Math.max(0, turns.length - visibleTurnCount);
   const visibleTurns = turns.slice(firstVisibleTurn);
   const turnsRef = useRef(turns);
@@ -383,10 +388,15 @@ function AgentTranscriptComponent({
         ) : null}
         {visibleTurns.map((turn, turnIndex) => {
           const isLastTurn = firstVisibleTurn + turnIndex === turns.length - 1;
-          const userBlock = turnUserBlock(turn);
+          const userBlock = turnUserBlock(turn, managed);
           const durationMs = userBlock?.durationMs;
           const settled = !(busy && isLastTurn);
-          const items = groupTurnItems(turn);
+          const proposals = turn.filter((block) => block.orchestration);
+          // Proposals are turn results, like the changes card. Keep them out
+          // of the live work and append them after all of the lead's output.
+          const items = groupTurnItems(
+            turn.filter((block) => !block.orchestration),
+          );
           // Earlier activity groups have already been followed by prose or
           // more work. Only the last one can still be the live group.
           const foldedAt = lastActivityIndex(items);
@@ -508,12 +518,10 @@ function AgentTranscriptComponent({
           // do not collapse with it: they are lifted out and parked under the
           // work, where they stay put however often it re-folds.
           const foldEntries = fold
-            ? items
-                .slice(fold.start, fold.end + 1)
-                .map((entry, offset) => ({
-                  entry,
-                  index: fold.start + offset,
-                }))
+            ? items.slice(fold.start, fold.end + 1).map((entry, offset) => ({
+                entry,
+                index: fold.start + offset,
+              }))
             : [];
           const foldSubagents = foldEntries.filter(
             ({ entry }) => entry.type === "subagents",
@@ -588,6 +596,18 @@ function AgentTranscriptComponent({
                 return [foldLineRow, row];
               })}
               {foldLineAt >= items.length ? foldLineRow : null}
+              {settled &&
+                proposals
+                  .filter((block) => block.orchestration?.status !== "planning")
+                  .map((block) => (
+                    <div
+                      key={block.id}
+                      className="px-4 pt-1 pb-2"
+                      data-orchestration-result
+                    >
+                      <OrchestrationPreview block={block} busy={!!busy} />
+                    </div>
+                  ))}
               {isLastTurn && latestTurnAccessory ? latestTurnAccessory : null}
               {durationMs != null && settled ? (
                 <TurnDuration
@@ -806,7 +826,7 @@ function TurnMetricsBadge({
   return (
     <div
       ref={root}
-      className="relative shrink-0"
+      className="relative shrink-0 pl-1"
       onMouseEnter={() => setHovered(true)}
       onMouseLeave={() => setHovered(false)}
       onFocus={() => setHovered(true)}
@@ -1012,6 +1032,7 @@ const TranscriptBlock = memo(function TranscriptBlock({
   }
 
   if (block.role === "plan") {
+    if (block.orchestration) return null;
     const legacyTasks = legacyTaskListFromText(block.text);
     if (legacyTasks) {
       return (
@@ -1099,7 +1120,8 @@ function UserMessageBlock({
   const textRef = useRef<HTMLElement>(null);
   const card = block.secondOpinion;
   const note = block.noteCard;
-  const text = card && card.kind !== "handoff" ? "" : block.text;
+  const text =
+    card && card.kind !== "handoff" ? "" : visibleUserPrompt(block.text);
   const messageLink = text ? parseUserMessageLink(text) : null;
   const displayText = messageLink
     ? `${messageLink.beforeText}${messageLink.afterText}`
@@ -2767,13 +2789,14 @@ function InterjectionDivider({ block }: { block: Block }) {
   );
 }
 
-function lastUserBlockId(blocks: Block[]): string | undefined {
-  return turnUserBlock(blocks)?.id;
+function lastUserBlockId(blocks: Block[], managed = false): string | undefined {
+  return turnUserBlock(blocks, managed)?.id;
 }
 
-function turnUserBlock(blocks: Block[]): Block | undefined {
+function turnUserBlock(blocks: Block[], managed = false): Block | undefined {
   for (let i = blocks.length - 1; i >= 0; i--) {
-    if (blocks[i].role === "user") return blocks[i];
+    const block = blocks[i];
+    if (block.role === "user" && (managed || !block.internal)) return block;
   }
   return undefined;
 }
diff --git a/src/surfaces/FilePane.agent.test.ts b/src/surfaces/FilePane.agent.test.ts
new file mode 100644
index 00000000..81130868
--- /dev/null
+++ b/src/surfaces/FilePane.agent.test.ts
@@ -0,0 +1,95 @@
+// @vitest-environment happy-dom
+import { act, createElement, type ComponentProps } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { newAgentTab, newEditorPane } from "../lib/layout";
+import { newSession } from "../lib/session";
+import { FilePane } from "./FilePane";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn(async () => []),
+  isTauri: () => false,
+  convertFileSrc: (path: string) => path,
+}));
+vi.mock("@tauri-apps/api/event", () => ({ listen: async () => () => {} }));
+
+describe("file pane agent tabs", () => {
+  let root: Root;
+  let container: HTMLDivElement;
+  let props: ComponentProps<typeof FilePane>;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.append(container);
+    root = createRoot(container);
+    const file = newAgentTab("Audit the engine", "/repo", {
+      sessionId: "worker",
+      leadId: "lead",
+      harness: "codex",
+    });
+    const noop = () => {};
+    props = {
+      pane: newEditorPane(file),
+      focused: true,
+      dirtyFileIds: new Set(),
+      fileErrorCounts: new Map(),
+      sessions: [],
+      onFocus: noop,
+      onSelectFile: noop,
+      onCloseFile: noop,
+      onCloseOtherFiles: noop,
+      onDirtyChange: noop,
+      onErrorCountChange: noop,
+      onReorderFiles: noop,
+      onOpenFile: noop,
+      onUpdatePlan: noop,
+      onBuildPlan: noop,
+    };
+  });
+
+  afterEach(async () => {
+    await act(async () => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows a worker transcript after its session arrives", async () => {
+    await act(async () => root.render(createElement(FilePane, props)));
+    expect(container.textContent).toContain("This agent is no longer running");
+
+    const session = {
+      ...newSession("codex", "/repo"),
+      id: "worker",
+      blocks: [
+        { id: "u1", role: "user" as const, text: "Audit the engine" },
+        { id: "a1", role: "assistant" as const, text: "Looking now" },
+      ],
+    };
+    await act(async () =>
+      root.render(createElement(FilePane, { ...props, sessions: [session] })),
+    );
+    expect(container.textContent).toContain("Looking now");
+    expect(container.textContent).not.toContain(
+      "This agent is no longer running",
+    );
+
+    await act(async () =>
+      root.render(
+        createElement(FilePane, {
+          ...props,
+          sessions: [
+            {
+              ...session,
+              blocks: [
+                ...session.blocks,
+                { id: "a2", role: "assistant" as const, text: "Done" },
+              ],
+            },
+          ],
+        }),
+      ),
+    );
+    expect(container.textContent).toContain("Done");
+  });
+});
diff --git a/src/surfaces/FilePane.tsx b/src/surfaces/FilePane.tsx
index 916c8c57..e659d666 100644
--- a/src/surfaces/FilePane.tsx
+++ b/src/surfaces/FilePane.tsx
@@ -6,6 +6,7 @@ import {
 } from "../chrome/MarkdownModeToggle";
 import { SurfaceTabs } from "../chrome/SurfaceTabs";
 import {
+  isAgentTab,
   isChangesTab,
   isCommitTab,
   isPlanTab,
@@ -24,6 +25,7 @@ import type { PlanBuildTarget, Session } from "../lib/session";
 import { Play } from "../chrome/icons";
 import { BuildTargetButton } from "../chrome/SecondOpinionButton";
 import { loadDiffViewer, subscribeDiffViewer } from "../lib/settings";
+import { AgentTabView } from "./AgentTabView";
 import { MarkdownPreview } from "./AgentMarkdown";
 import { BinaryFileView } from "./BinaryFileView";
 import { CommitDiff } from "./CommitDiff";
@@ -149,7 +151,16 @@ function FilePaneComponent({
                   : "hidden"
               }
             >
-              {isPlanTab(file) ? (
+              {isAgentTab(file) ? (
+                <AgentTabView
+                  title={file.path}
+                  session={sessions.find(
+                    (entry) => entry.id === file.agent.sessionId,
+                  )}
+                  visible={file.id === pane.activeFileId}
+                  onOpenFile={onOpenFile}
+                />
+              ) : isPlanTab(file) ? (
                 <PlanSurface
                   file={file}
                   sessions={sessions}
@@ -223,7 +234,8 @@ export const FilePane = memo(FilePaneComponent, (previous, next) => {
   }
 
   for (const file of next.pane.files) {
-    const sessionId = file.plan?.sessionId;
+    // Plans and agent tabs both read a live session object from this pane.
+    const sessionId = file.plan?.sessionId ?? file.agent?.sessionId;
     if (!sessionId) continue;
     const before = previous.sessions.find(
       (session) => session.id === sessionId,
diff --git a/src/surfaces/PaneTree.tsx b/src/surfaces/PaneTree.tsx
index b5cc73d3..5b5dde22 100644
--- a/src/surfaces/PaneTree.tsx
+++ b/src/surfaces/PaneTree.tsx
@@ -31,7 +31,7 @@ import {
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
-  type TurnIntent,
+  type ComposerTurnOptions,
 } from "../lib/session";
 import { FilePane } from "./FilePane";
 import { SessionPane } from "./SessionPane";
@@ -69,7 +69,7 @@ type Shared = {
     sessionId: string,
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop: (sessionId: string) => void;
   onCompactContext: (sessionId: string) => boolean;
diff --git a/src/surfaces/SessionPane.tsx b/src/surfaces/SessionPane.tsx
index 9d3e5322..bd27e4c5 100644
--- a/src/surfaces/SessionPane.tsx
+++ b/src/surfaces/SessionPane.tsx
@@ -10,6 +10,7 @@ import {
   type PointerEvent as ReactPointerEvent,
 } from "react";
 import { Composer } from "../chrome/Composer";
+import { orchestrator, sameCheckout } from "../lib/orchestration";
 import { DiscussionEmpty } from "../chrome/DiscussionEmpty";
 import { LinkedWorkItemUpdateNotice } from "../chrome/LinkedWorkItemUpdateNotice";
 import { SessionReview } from "../chrome/SessionReview";
@@ -30,7 +31,7 @@ import {
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
-  type TurnIntent,
+  type ComposerTurnOptions,
 } from "../lib/session";
 import { AgentTranscript } from "./AgentTranscript";
 import { EmptySession } from "./EmptySession";
@@ -84,7 +85,7 @@ type Props = {
     sessionId: string,
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop: (sessionId: string) => void;
   onCompactContext: (sessionId: string) => boolean;
@@ -191,6 +192,16 @@ export const SessionPane = memo(function SessionPane({
   onNewTerminal,
   onPaneDragStart,
 }: Props) {
+  const orchestrationRuns = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const managed = orchestrationRuns.some(
+    (run) =>
+      (run.status === "active" || run.status === "paused") &&
+      sameCheckout(run.cwd, sessionWorkCwd(session)),
+  );
   const title = sessionDisplayTitle(session.title, session.harness);
   const isEmpty = session.blocks.length === 0;
   const backgroundRevision = useSyncExternalStore(
@@ -248,6 +259,11 @@ export const SessionPane = memo(function SessionPane({
   useEffect(() => {
     if (!visible) setAstraWelcomeRun(null);
   }, [visible]);
+  // Restore a saved run for this lead; its agents render on the sidebar card.
+  useEffect(() => {
+    if (!session.inboxAsk)
+      void orchestrator.hydrate(session.id).catch(console.error);
+  }, [session.id, session.inboxAsk]);
   const [quoteRequest, setQuoteRequest] = useState<QuoteRequest>();
   const onJumpToBottomReady = useCallback((jump: () => void) => {
     jumpToBottomRef.current = jump;
@@ -335,7 +351,7 @@ export const SessionPane = memo(function SessionPane({
         !!session.inboxAsk ||
         (hideProjectPicker ? !showDeckProjectPicker : false)
       }
-      hideBranchPicker={!!session.inboxAsk}
+      hideBranchPicker={!!session.inboxAsk || managed}
       hideTopBar={!!session.inboxAsk}
       context={session.context}
       quoteRequest={quoteRequest}
@@ -460,120 +476,138 @@ export const SessionPane = memo(function SessionPane({
           </button>
         </div>
       ) : null}
-      <div ref={transcriptScope} className="@container relative min-h-0 flex-1">
-        {visible && focused && !session.inboxAsk ? (
-          <LinkedWorkItemUpdateNotice
-            sessionId={session.id}
-            card={session.linkedWorkItemUpdateCard}
-            onAcknowledge={() => {
-              const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;
-              if (updatedAt != null) {
-                markLinkedSessionUpdateSeen(session.id, updatedAt);
-              }
-            }}
-            onDismiss={() => onLinkedWorkItemUpdateCardDismiss?.(session.id)}
-            onOpenDiscussion={() => {
-              if (session.linkedWorkItem) {
-                onOpenLinkedWorkItem?.(session.linkedWorkItem);
-              }
-            }}
-            onAddToChat={(text) => addSelectionToChat(text, "plain")}
-            onArchiveSession={
-              onArchiveSession
-                ? () => onArchiveSession(session.id, true)
-                : undefined
-            }
-            onDeleteSession={
-              onDeleteSession ? () => onDeleteSession(session.id) : undefined
-            }
-          />
-        ) : null}
-        {isEmpty ? (
-          session.inboxAsk ? (
-            <div className="scrollbar-none h-full min-h-0 overflow-y-auto">
-              <DiscussionEmpty message="Explore this item with your agent." />
-            </div>
-          ) : (
-            <EmptySession
-              cwd={session.cwd}
-              hasChatBackground={Boolean(
-                projectBackground || globalBackgroundPath,
-              )}
-              composer={dockComposer ? undefined : composer}
-            />
-          )
-        ) : (
-          <>
-            <AgentTranscript
-              blocks={session.blocks}
-              busy={!!session.busy}
-              visible={visible}
-              cwd={workCwd}
-              harness={session.harness}
-              model={session.model}
-              pendingQuestion={!!session.pendingQuestion}
-              onApproval={approve}
-              onAddToChat={addSelectionToChat}
-              onSaveNote={notesEnabled ? saveNote : undefined}
-              onSaveSelectionNote={notesEnabled ? saveSelectionNote : undefined}
-              onOpenFile={onOpenFile}
-              onOpenDiff={onOpenDiff}
-              onOpenPlan={openPlan}
-              onBuildPlan={buildPlan}
-              onSecondOpinion={
-                !session.inboxAsk && onSecondOpinion
-                  ? (harness, turn, model) =>
-                      onSecondOpinion(session.id, harness, turn, model)
-                  : undefined
-              }
-              onHandoff={
-                !session.inboxAsk && onHandoff
-                  ? (harness, turn, model) =>
-                      onHandoff(session.id, harness, turn, model)
+      <div className="flex min-h-0 min-w-0 flex-1 flex-col">
+        <div
+          ref={transcriptScope}
+          className="@container relative min-h-0 flex-1"
+        >
+          {visible && focused && !session.inboxAsk ? (
+            <LinkedWorkItemUpdateNotice
+              sessionId={session.id}
+              card={session.linkedWorkItemUpdateCard}
+              onAcknowledge={() => {
+                const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;
+                if (updatedAt != null) {
+                  markLinkedSessionUpdateSeen(session.id, updatedAt);
+                }
+              }}
+              onDismiss={() => onLinkedWorkItemUpdateCardDismiss?.(session.id)}
+              onOpenDiscussion={() => {
+                if (session.linkedWorkItem) {
+                  onOpenLinkedWorkItem?.(session.linkedWorkItem);
+                }
+              }}
+              onAddToChat={(text) => addSelectionToChat(text, "plain")}
+              onArchiveSession={
+                onArchiveSession
+                  ? () => onArchiveSession(session.id, true)
                   : undefined
               }
-              onJumpToBottomChange={setShowJumpToBottom}
-              onJumpToBottomReady={onJumpToBottomReady}
-              onRevealReady={onRevealReady}
-              latestTurnAccessory={
-                session.inboxAsk ? undefined : (
-                  <SessionReview
-                    sessionId={session.id}
-                    cwd={workCwd}
-                    enabled={visible}
-                    busy={!!session.busy}
-                    undoLocked={reviewUndoLocked}
-                    onOpenDiff={onOpenDiff}
-                  />
-                )
+              onDeleteSession={
+                onDeleteSession ? () => onDeleteSession(session.id) : undefined
               }
             />
-            <PromptOutline
-              blocks={session.blocks}
-              scope={transcriptScope}
-              visible={visible}
-              revealBlock={revealBlock}
-            />
-            {showJumpToBottom ? (
-              <div className="pointer-events-none absolute inset-x-0 bottom-2 z-30 flex justify-center">
-                <button
-                  type="button"
-                  title="Jump to latest"
-                  aria-label="Jump to latest"
-                  data-jump-to-bottom
-                  onClick={() => jumpToBottomRef.current?.()}
-                  className="pointer-events-auto grid size-6 place-items-center rounded-md border border-content/15 bg-content/10 text-content shadow-md hover:bg-content/5 backdrop-blur-md"
-                >
-                  <ChevronDown className="size-4" strokeWidth={2} />
-                </button>
+          ) : null}
+          {isEmpty ? (
+            session.inboxAsk ? (
+              <div className="scrollbar-none h-full min-h-0 overflow-y-auto">
+                <DiscussionEmpty message="Explore this item with your agent." />
               </div>
-            ) : null}
-          </>
-        )}
+            ) : (
+              <EmptySession
+                cwd={session.cwd}
+                hasChatBackground={Boolean(
+                  projectBackground || globalBackgroundPath,
+                )}
+                composer={dockComposer ? undefined : composer}
+              />
+            )
+          ) : (
+            <>
+              <AgentTranscript
+                blocks={session.blocks}
+                busy={!!session.busy}
+                visible={visible}
+                cwd={workCwd}
+                harness={session.harness}
+                model={session.model}
+                pendingQuestion={!!session.pendingQuestion}
+                onApproval={approve}
+                onAddToChat={addSelectionToChat}
+                onSaveNote={notesEnabled ? saveNote : undefined}
+                onSaveSelectionNote={
+                  notesEnabled ? saveSelectionNote : undefined
+                }
+                onOpenFile={onOpenFile}
+                onOpenDiff={onOpenDiff}
+                onOpenPlan={openPlan}
+                onBuildPlan={buildPlan}
+                onSecondOpinion={
+                  !session.inboxAsk && onSecondOpinion
+                    ? (harness, turn, model) =>
+                        onSecondOpinion(session.id, harness, turn, model)
+                    : undefined
+                }
+                onHandoff={
+                  !session.inboxAsk && onHandoff
+                    ? (harness, turn, model) =>
+                        onHandoff(session.id, harness, turn, model)
+                    : undefined
+                }
+                onJumpToBottomChange={setShowJumpToBottom}
+                onJumpToBottomReady={onJumpToBottomReady}
+                onRevealReady={onRevealReady}
+                latestTurnAccessory={
+                  session.inboxAsk ? undefined : (
+                    <SessionReview
+                      sessionId={session.id}
+                      cwd={workCwd}
+                      enabled={visible}
+                      busy={!!session.busy}
+                      undoLocked={
+                        reviewUndoLocked ||
+                        orchestrationRuns.some(
+                          (run) =>
+                            (run.status === "active" ||
+                              run.status === "paused") &&
+                            (run.leadId === session.id ||
+                              run.tasks.some(
+                                (task) => task.sessionId === session.id,
+                              )),
+                        )
+                      }
+                      onOpenDiff={onOpenDiff}
+                    />
+                  )
+                }
+              />
+              <PromptOutline
+                blocks={session.blocks}
+                scope={transcriptScope}
+                visible={visible}
+                revealBlock={revealBlock}
+              />
+              {showJumpToBottom ? (
+                <div className="pointer-events-none absolute inset-x-0 bottom-2 z-30 flex justify-center">
+                  <button
+                    type="button"
+                    title="Jump to latest"
+                    aria-label="Jump to latest"
+                    data-jump-to-bottom
+                    onClick={() => jumpToBottomRef.current?.()}
+                    className="pointer-events-auto grid size-6 place-items-center rounded-md border border-content/15 bg-content/10 text-content shadow-md hover:bg-content/5 backdrop-blur-md"
+                  >
+                    <ChevronDown className="size-4" strokeWidth={2} />
+                  </button>
+                </div>
+              ) : null}
+            </>
+          )}
+        </div>
+        {dockComposer ? (
+          <div className="mx-auto w-full max-w-4xl shrink-0">{composer}</div>
+        ) : null}
       </div>
-      {dockComposer ? (
-        <div className="mx-auto w-full max-w-4xl shrink-0">{composer}</div>
-      ) : null}
     </div>
   );
 });
diff --git a/src/surfaces/transcriptActivity.test.ts b/src/surfaces/transcriptActivity.test.ts
index d3fe6a8b..ec7c49f0 100644
--- a/src/surfaces/transcriptActivity.test.ts
+++ b/src/surfaces/transcriptActivity.test.ts
@@ -332,6 +332,26 @@ describe("turnCopyText", () => {
 });
 
 describe("groupTurns", () => {
+  it("folds an orchestration turn the app wrote into the turn above", () => {
+    const turns = groupTurns([
+      { id: "u1", role: "user", text: "Review the changes" },
+      { id: "a1", role: "assistant", text: "Delegating." },
+      {
+        id: "u2",
+        role: "user",
+        text: "Worker results are ready.",
+        internal: true,
+      },
+      { id: "a2", role: "assistant", text: "All three look right." },
+      { id: "u3", role: "user", text: "Ship it" },
+      { id: "a3", role: "assistant", text: "Done." },
+    ]);
+    // One thread: the app's turn neither splits it nor shows up in it.
+    expect(turns.map((turn) => turn.map((block) => block.id))).toEqual([
+      ["u1", "a1", "a2"],
+      ["u3", "a3"],
+    ]);
+  });
   it("keeps a handoff divider on its own row between providers", () => {
     const turns = groupTurns([
       { id: "u1", role: "user", text: "go" },
diff --git a/src/surfaces/transcriptActivity.ts b/src/surfaces/transcriptActivity.ts
index 3b2ba00b..21367345 100644
--- a/src/surfaces/transcriptActivity.ts
+++ b/src/surfaces/transcriptActivity.ts
@@ -173,11 +173,20 @@ export function editVerb(label: string): string {
   return "Edit";
 }
 
-/** User turns, with handoff dividers sitting on their own row. */
-export function groupTurns(blocks: Block[]): Block[][] {
+/**
+ * User turns, with handoff dividers sitting on their own row. `managed` is for
+ * a worker's own transcript, where the app-written turns are the orchestrator
+ * talking to it — the whole prompt side of that conversation, and the only
+ * thing its replies are answering.
+ */
+export function groupTurns(blocks: Block[], managed = false): Block[][] {
   const turns: Block[][] = [];
   let current: Block[] = [];
   for (const block of blocks) {
+    // A turn the app wrote to keep an orchestration moving is not a user
+    // message. Dropping it here folds the reply into the turn above, so a
+    // supervised run reads as one conversation.
+    if (block.internal && !managed) continue;
     if (block.role === "handoff") {
       if (current.length > 0) turns.push(current);
       turns.push([block]);

From fdcd3ca5ec4ed99350ffe0929686b67fc4bdc2c9 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 12:16:02 +0100
Subject: [PATCH 16/17] Release 0.1.46

---
 CHANGELOG.md              | 36 +++++++++++++++++++++++++++++++-----
 Cargo.lock                |  2 +-
 Cargo.toml                |  2 +-
 package-lock.json         |  4 ++--
 package.json              |  2 +-
 src-tauri/tauri.conf.json |  2 +-
 6 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c0158f4..30aa0ff4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,9 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.46] - 2026-09-14
+
+### Added
+
+- **Agent orchestration v1** lets a lead agent coordinate up to four workers in the same checkout. Choose worker providers and models, review and edit the proposed assignments before starting, and let the lead manage dependencies, review results, request corrections, and redirect supported workers mid-turn. Overlapping write scopes are queued, and worker approvals and questions are routed through the lead. In #228.
+- Orchestration workers are grouped under their lead in the sidebar, with status, model, and expandable details. **View agents** opens their transcripts beside the lead. Run history survives restarts, interrupted work pauses for review, and stopping the lead stops its workers too.
+- Completed agent turns show provider-reported token usage, cache metrics, and output rate in a hover or keyboard-focus preview, with metrics retained in saved conversations.
+- Web links in user messages show compact page-title and favicon previews while preserving the surrounding text. Preview requests validate public destinations and keep fetching outside the webview.
+- Settings → Appearance includes a **Dark-mode lightness** slider and remembers its value independently of light mode.
+- Chat backgrounds have separate opacity controls for empty and active sessions, including project-specific overrides. In #191 by @shxntanu.
+- GitHub pull-request reviews in the Inbox can switch between changed hunks and full-file context. In #189 by @UtkarshRahim.
+- **Close All Tabs** is available from the menu and Command/Ctrl+Shift+W. It closes the active tab's editor files first, then closes the workspace tabs on a subsequent invocation, retaining a blank session and confirming unsaved files and running terminals. In #215 by @kartava.
+- Notes can be moved between projects without changing their order or losing edits during navigation. In #187 by @ognjeeen.
+
+### Changed
+
+- Closed conversations are prefetched on hover or press and retained in a bounded cache for faster reopening, with safeguards against stale loads and duplicate tabs.
+- Inbox cards mount progressively to keep large lists responsive. In #209 by @notsapinho.
+- Reordering tabs and projects uses shared motion settings, with smoother scrolling and consecutive drag gestures. In #206 by @ognjeeen.
+- Sidebar session cards place linked work-item and archive controls together in the footer, show a single provider icon, and retain the default cursor on reorderable items.
+- Linked work-item update notices now sit inside their session pane, make the agent action more prominent, and offer clearer open and dismiss controls.
+
 ### Fixed
 
 - OpenCode falls back to readable local paths for unsupported attachment formats instead of sending provider-rejected file parts, and repairs sessions already stuck on an unsupported file turn. Fixes #211.
+- **Supervised** access explicitly sets Claude Code's permission mode, preventing local default settings from silently switching the session to automatic approvals or bypassed permissions. In #203 by @prkl78.
+- OMP advisor interjections no longer fold away complete answers or break assistant streams. Saved conversations recover interjection boundaries and status-split continuations, while long interjections collapse by default. In #156 by @elijah7x.
+- Continuing a conversation dismisses its due reminder and linked-update notices while preserving future reminders. Linked-activity sounds no longer repeat when the same update remounts.
+- Opening the sidebar project picker focuses its search field reliably. In #226 by @actuallyakshat.
+- Background GitHub CLI and related helper commands no longer flash console windows on Windows. In #221 by @korefs.
+- Nested transcript scrollers keep receiving wheel gestures when the outer transcript reaches an edge, including gestures over SVG icons and containers that scroll on only one axis.
+- Orchestration cleanup releases checkout reservations when a window closes and removes stale run and worker ownership records when conversations are deleted. Worker tabs wait for their lead to open, sidebar controls remain independently keyboard accessible, and completed or stopped runs release the Undo lock.
 
 ## [0.1.45] - 2026-09-13
 
@@ -35,10 +64,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Claude Sonnet 5 appears only with Claude Code 2.1.197 or newer, preventing older CLI versions from receiving an unsupported model argument. In #199 by @nulljosh.
 - Claude model choices resolve consistently between the CLI's short live aliases and MonoCode's full startup model IDs, so relaunching no longer switches a saved session to a different model family.
 
-### Fixed
-
-- **Supervised** access now reaches Claude Code as a permission flag. It was the one mode MonoCode sent nothing for, so the CLI fell back to `permissions.defaultMode` from your settings files, and a session the picker labelled Supervised could run as `auto` or `bypassPermissions` without asking.
-
 ## [0.1.44] - 2026-09-12
 
 ### Added
@@ -747,7 +772,8 @@ First public release. macOS (Apple Silicon) only.
 - Updater endpoint and minisign public key are injected at release time rather than committed, so forks do not inherit the maintainer's update channel.
 - macOS release builds sign with `APPLE_SIGNING_IDENTITY` via a config overlay; the committed default remains ad-hoc `-` for community builds.
 
-[Unreleased]: https://github.com/hardbeat920/monocode/compare/v0.1.45...HEAD
+[Unreleased]: https://github.com/hardbeat920/monocode/compare/v0.1.46...HEAD
+[0.1.46]: https://github.com/hardbeat920/monocode/compare/v0.1.45...v0.1.46
 [0.1.45]: https://github.com/hardbeat920/monocode/compare/v0.1.44...v0.1.45
 [0.1.44]: https://github.com/hardbeat920/monocode/compare/v0.1.43...v0.1.44
 [0.1.43]: https://github.com/hardbeat920/monocode/compare/v0.1.42...v0.1.43
diff --git a/Cargo.lock b/Cargo.lock
index d6f08232..750923ad 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2214,7 +2214,7 @@ dependencies = [
 
 [[package]]
 name = "monocode"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "base64 0.22.1",
  "block2",
diff --git a/Cargo.toml b/Cargo.toml
index 02a91329..d981956e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["src-tauri"]
 exclude = ["vendor/portable-pty"]
 
 [workspace.package]
-version = "0.1.45"
+version = "0.1.46"
 edition = "2021"
 license = "MIT"
 
diff --git a/package-lock.json b/package-lock.json
index 5e5fc248..ac345c7d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "monocode-desktop",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "monocode-desktop",
-      "version": "0.1.45",
+      "version": "0.1.46",
       "dependencies": {
         "@codemirror/lang-css": "^6.3.1",
         "@codemirror/lang-html": "^6.4.12",
diff --git a/package.json b/package.json
index d5c52362..25ee2e4e 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "monocode-desktop",
   "private": true,
-  "version": "0.1.45",
+  "version": "0.1.46",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 20f3048f..21530fbe 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "MonoCode",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "identifier": "com.monocode.desktop",
   "build": {
     "beforeDevCommand": "npm run dev",

From 1dd21a2603389175fcbc3ed5b824f24c29585d94 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Mon, 14 Sep 2026 14:42:15 +0100
Subject: [PATCH 17/17] Improve Codex shell command presentation

- Unwrap shell launchers and infer readable Read, Find, and List actions
- Preserve command previews and summarize historical transcript activity
- Add coverage for Codex command actions and shell intent parsing
---
 src/lib/harness/codexProtocol.test.ts   |  84 +++++++++++++++++++
 src/lib/harness/codexProtocol.ts        | 102 ++++++++++++++++++++++--
 src/lib/harness/preview.ts              |   9 ++-
 src/lib/harness/shellIntent.test.ts     |  59 +++++++++++++-
 src/lib/harness/shellIntent.ts          |  36 ++++++++-
 src/surfaces/transcriptActivity.test.ts |  38 +++++++++
 src/surfaces/transcriptActivity.ts      |  15 +++-
 7 files changed, 326 insertions(+), 17 deletions(-)

diff --git a/src/lib/harness/codexProtocol.test.ts b/src/lib/harness/codexProtocol.test.ts
index 7c35f2f9..22555966 100644
--- a/src/lib/harness/codexProtocol.test.ts
+++ b/src/lib/harness/codexProtocol.test.ts
@@ -340,6 +340,59 @@ describe("mapCodexNotification", () => {
     });
   });
 
+  it("uses Codex command actions for readable command rows", () => {
+    const mapped = mapCodexNotification("item/started", {
+      item: {
+        id: "cmd_read",
+        type: "commandExecution",
+        command: `/bin/zsh -lc "nl -ba src/lib/orchestration.ts | sed -n '1,260p'"`,
+        cwd: "/Users/me/project",
+        status: "inProgress",
+        commandActions: [
+          {
+            type: "read",
+            command: "nl -ba src/lib/orchestration.ts",
+            name: "orchestration.ts",
+            path: "/Users/me/project/src/lib/orchestration.ts",
+          },
+          { type: "unknown", command: "sed -n '1,260p'" },
+        ],
+      },
+    });
+
+    expect(mapped.events[0]).toMatchObject({
+      type: "tool.started",
+      callId: "cmd_read",
+      title: "Read src/lib/orchestration.ts",
+      kind: "execute",
+      preview: {
+        kind: "shell",
+        path: "/Users/me/project/src/lib/orchestration.ts",
+        fileName: "orchestration.ts",
+      },
+    });
+  });
+
+  it("falls back to unwrapping Codex shell launchers", () => {
+    const mapped = mapCodexNotification("item/started", {
+      item: {
+        id: "cmd_find",
+        type: "commandExecution",
+        command: `/bin/zsh -lc "rg -n 'submissionError|hydrate' src/lib"`,
+        status: "inProgress",
+      },
+    });
+
+    expect(mapped.events[0]).toMatchObject({
+      title: "Find submissionError|hydrate",
+      preview: {
+        kind: "shell",
+        path: "src/lib",
+        query: "submissionError|hydrate",
+      },
+    });
+  });
+
   it("maps file change items", () => {
     const mapped = mapCodexNotification("item/started", {
       item: {
@@ -609,6 +662,37 @@ describe("approvals", () => {
     });
   });
 
+  it("keeps readable Codex actions on command approvals", () => {
+    const mapped = mapApprovalRequest(
+      "item/commandExecution/requestApproval",
+      {
+        itemId: "cmd_read",
+        command: `/bin/zsh -lc "cat src/App.tsx"`,
+        cwd: "/Users/me/project",
+        reason: "Inspect the app",
+        commandActions: [
+          {
+            type: "read",
+            command: "cat src/App.tsx",
+            name: "App.tsx",
+            path: "/Users/me/project/src/App.tsx",
+          },
+        ],
+      },
+      8,
+    );
+
+    expect(mapped?.event).toMatchObject({
+      title: "Read src/App.tsx",
+      kind: "execute",
+      preview: {
+        kind: "shell",
+        path: "/Users/me/project/src/App.tsx",
+        fileName: "App.tsx",
+      },
+    });
+  });
+
   it("maps file-change approval requests", () => {
     const mapped = mapApprovalRequest(
       "item/fileChange/requestApproval",
diff --git a/src/lib/harness/codexProtocol.ts b/src/lib/harness/codexProtocol.ts
index cdf46e6f..5a5eeff7 100644
--- a/src/lib/harness/codexProtocol.ts
+++ b/src/lib/harness/codexProtocol.ts
@@ -12,12 +12,14 @@ import {
   isVisionImage,
   normalizeImageMime,
 } from "../attachments";
+import { displayPath } from "../paths";
 import { normalizeTaskListStatus } from "../taskList";
 import {
   composeToolTitle,
   extractToolPreview,
   formatAgentType,
 } from "./preview";
+import { formatShellIntent, inferShellIntent } from "./shellIntent";
 import { streamTextDelta } from "./streamText";
 import type { HarnessEvent } from "./types";
 
@@ -614,26 +616,26 @@ function mapToolItem(
     const status = mapItemStatus(stringField(item, "status"), completed);
     const output =
       stringField(item, "aggregatedOutput") ?? stringField(item, "output");
-    const preview: ToolPreview | undefined = undefined;
+    const presentation = codexCommandPresentation(item, command);
     const eventType = completed ? "tool.updated" : "tool.started";
     if (eventType === "tool.started") {
       return {
         type: "tool.started",
         callId,
-        title: command,
+        title: presentation.title,
         kind: "execute",
         status,
-        preview,
+        preview: presentation.preview,
       };
     }
     return {
       type: "tool.updated",
       callId,
-      title: command,
+      title: presentation.title,
       kind: "execute",
       status,
       ...(output ? { detail: output } : {}),
-      preview,
+      preview: presentation.preview,
     };
   }
 
@@ -719,6 +721,86 @@ function mapToolItem(
   return null;
 }
 
+/** Prefer Codex's own best-effort command parsing, then our legacy fallback. */
+function codexCommandPresentation(
+  item: Record<string, unknown>,
+  command: string,
+): { title: string; preview?: ToolPreview } {
+  const cwd = stringField(item, "cwd");
+  const actions = Array.isArray(item.commandActions)
+    ? item.commandActions.flatMap((value) => {
+        const action = asRecord(value);
+        return action ? [action] : [];
+      })
+    : [];
+
+  // The last meaningful stage usually describes the pipeline's visible goal
+  // (`cat file | grep term` is a Find), while unknown filters are ignored.
+  for (let index = actions.length - 1; index >= 0; index -= 1) {
+    const action = actions[index];
+    const type = stringField(action, "type");
+    const path = stringField(action, "path");
+    const shownPath = path ? displayPath(path, cwd) : undefined;
+    if (type === "search") {
+      const query = stringField(action, "query");
+      if (!query) continue;
+      return {
+        title: `Find ${query}`,
+        preview: shellCommandPreview(command, path, query),
+      };
+    }
+    if (type === "read" && path) {
+      return {
+        title: `Read ${shownPath}`,
+        preview: shellCommandPreview(command, path),
+      };
+    }
+    if (type === "listFiles") {
+      return {
+        title: shownPath ? `List ${shownPath}` : "List",
+        preview: shellCommandPreview(command, path),
+      };
+    }
+  }
+
+  const inferred = inferShellIntent(command);
+  if (!inferred) return { title: command };
+  const path = inferred.path;
+  const shownPath = path ? displayPath(path, cwd) : undefined;
+  return {
+    title: formatShellIntent(inferred, shownPath, inferred.query) ?? command,
+    preview: shellCommandPreview(
+      command,
+      path,
+      inferred.query,
+      inferred.startLine,
+    ),
+  };
+}
+
+function shellCommandPreview(
+  command: string,
+  path?: string,
+  query?: string,
+  startLine?: number,
+): ToolPreview {
+  return {
+    kind: "shell",
+    title: command,
+    ...(path
+      ? {
+          path,
+          fileName: path
+            .replace(/[/\\]+$/, "")
+            .split(/[/\\]/)
+            .pop(),
+        }
+      : {}),
+    ...(query ? { query } : {}),
+    ...(startLine ? { startLine } : {}),
+  };
+}
+
 function mapSubAgentActivity(
   item: Record<string, unknown>,
   callId: string,
@@ -1116,15 +1198,21 @@ export function mapApprovalRequest(
     const command = stringField(rec, "command") ?? "Shell";
     const callId = stringField(rec, "itemId");
     const reason = stringField(rec, "reason");
+    const presentation = codexCommandPresentation(rec, command);
+    const readable = presentation.title !== command;
     return {
       kind: "command",
       event: {
         type: "approval.requested",
         requestId,
-        title: reason ? `${command} — ${reason}` : command,
+        title: readable
+          ? presentation.title
+          : reason
+            ? `${command} — ${reason}`
+            : command,
         kind: "execute",
         callId,
-        preview: undefined,
+        preview: presentation.preview,
       },
     };
   }
diff --git a/src/lib/harness/preview.ts b/src/lib/harness/preview.ts
index 57922d05..bdcd8f19 100644
--- a/src/lib/harness/preview.ts
+++ b/src/lib/harness/preview.ts
@@ -4,6 +4,7 @@ import {
   formatShellIntent,
   inferShellIntent,
   rewriteReadableTitle,
+  unwrapShellCommand,
 } from "./shellIntent";
 
 export const MAX_PREVIEW_LINES = 6;
@@ -373,7 +374,7 @@ export function composeToolTitle(opts: {
   const path = opts.path?.trim();
   const query = opts.query?.trim();
   const previewKind = opts.previewKind;
-  const command = firstLine(opts.command);
+  const command = opts.command?.trim();
   const skill = formatSkillName(opts.skill);
 
   if (isAgentTool(kind, title)) {
@@ -404,7 +405,7 @@ export function composeToolTitle(opts: {
   if (previewKind === "shell" || isExecuteTool(kind, title)) {
     const rewritten = rewriteReadableTitle(title, path, query);
     if (rewritten) return rewritten;
-    const script = command || stripExecutePrefix(title);
+    const script = unwrapShellCommand(command || stripExecutePrefix(title));
     const inferred = inferShellIntent(script);
     if (inferred) {
       const inferredPath =
@@ -415,8 +416,8 @@ export function composeToolTitle(opts: {
       const readable = formatShellIntent(inferred, inferredPath, query);
       if (readable) return readable;
     }
-    if (command) return command;
-    const rest = stripExecutePrefix(title);
+    if (command) return firstLine(script);
+    const rest = firstLine(script);
     if (rest && !isWeakToolTitle(rest)) return rest;
     if (title && !isWeakToolTitle(title)) return title;
     return "Shell";
diff --git a/src/lib/harness/shellIntent.test.ts b/src/lib/harness/shellIntent.test.ts
index 8b699069..52168743 100644
--- a/src/lib/harness/shellIntent.test.ts
+++ b/src/lib/harness/shellIntent.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { formatShellIntent, inferShellIntent } from "./shellIntent";
+import {
+  formatShellIntent,
+  inferShellIntent,
+  unwrapShellCommand,
+} from "./shellIntent";
 
 describe("inferShellIntent", () => {
   it("reads a file from cat / head / sed -n", () => {
@@ -28,6 +32,25 @@ describe("inferShellIntent", () => {
       path: "src/surfaces/AgentTranscript.tsx",
       startLine: 713,
     });
+    expect(
+      inferShellIntent(
+        `/bin/zsh -lc "nl -ba src/lib/orchestration.ts | sed -n '1,260p'"`,
+      ),
+    ).toEqual({
+      verb: "Read",
+      path: "src/lib/orchestration.ts",
+    });
+    expect(
+      inferShellIntent(
+        `/bin/zsh -lc "sed -n '1,260p' src/surfaces/transcriptActivity.ts
+sed -n '880,980p' src/surfaces/transcriptActivity.test.ts
+sed -n '960,1060p' src/index.css"`,
+      ),
+    ).toEqual({
+      verb: "Read",
+      path: "src/index.css",
+      startLine: 960,
+    });
   });
 
   it("treats grep / rg as Find", () => {
@@ -45,6 +68,26 @@ describe("inferShellIntent", () => {
       query: "isReadTool",
       path: "src/lib/harness",
     });
+    expect(
+      inferShellIntent(
+        `/bin/bash -lc "rg -n 'submissionError|hydrate' src/lib"`,
+      ),
+    ).toEqual({
+      verb: "Find",
+      query: "submissionError|hydrate",
+      path: "src/lib",
+    });
+    expect(
+      inferShellIntent(
+        `/bin/zsh -lc "rg -n \\\"function upsertTool\\\" src/lib/harness/apply.ts && sed -n '520,620p' src/lib/harness/apply.ts
+rg -n \\\"mapApprovalRequest\\\" src/lib/harness/codexProtocol.test.ts | head -n 60
+sed -n '560,640p' src/lib/harness/codexProtocol.test.ts"`,
+      ),
+    ).toEqual({
+      verb: "Read",
+      path: "src/lib/harness/codexProtocol.test.ts",
+      startLine: 560,
+    });
     expect(inferShellIntent("find src -name '*.ts'")).toEqual({
       verb: "Find",
       query: "*.ts",
@@ -58,10 +101,15 @@ describe("inferShellIntent", () => {
       path: "src/lib/harness",
     });
     expect(inferShellIntent("ls -la")).toBeUndefined();
+    expect(inferShellIntent("rg --files | sed -n '1,240p'")).toEqual({
+      verb: "Find",
+      query: "files",
+    });
   });
 
   it("leaves real shell as the command", () => {
     expect(inferShellIntent("git status -s")).toBeUndefined();
+    expect(inferShellIntent("/bin/zsh -lc 'git status -s'")).toBeUndefined();
     expect(inferShellIntent("git diff src/surfaces/AgentTranscript.tsx")).toBeUndefined();
     expect(inferShellIntent("npm test")).toBeUndefined();
     expect(inferShellIntent("cat file && python script.py")).toBeUndefined();
@@ -133,3 +181,12 @@ describe("formatShellIntent", () => {
     ).toBe("Read src/app.ts");
   });
 });
+
+describe("unwrapShellCommand", () => {
+  it("removes the shell transport wrapper without changing ordinary commands", () => {
+    expect(unwrapShellCommand(`/bin/zsh -lc "npm test -- --run app.test.ts"`)).toBe(
+      "npm test -- --run app.test.ts",
+    );
+    expect(unwrapShellCommand("git status --short")).toBe("git status --short");
+  });
+});
diff --git a/src/lib/harness/shellIntent.ts b/src/lib/harness/shellIntent.ts
index 51ef7adc..35fd65a1 100644
--- a/src/lib/harness/shellIntent.ts
+++ b/src/lib/harness/shellIntent.ts
@@ -18,7 +18,7 @@ const READABLE_BIN =
  * should stay as typed (git, npm, scripts, mixed opaque work).
  */
 export function inferShellIntent(command: string): ShellIntent | undefined {
-  const text = command.trim();
+  const text = unwrapShellCommand(command);
   if (!text || text.length > MAX_COMMAND_CHARS) return undefined;
   if (/^(Read|Find|List|Edit|Write)\s+\S/.test(text)) return undefined;
   if (looksUnsafe(text)) return undefined;
@@ -52,6 +52,34 @@ export function inferShellIntent(command: string): ShellIntent | undefined {
   );
 }
 
+/**
+ * Codex may expose a command through the argv used to launch the user's shell,
+ * for example `/bin/zsh -lc "cat package.json"`. The launcher is transport
+ * noise for this visual-only classifier; inspect the script it was given.
+ */
+export function unwrapShellCommand(command: string): string {
+  let current = command.trim();
+  for (let depth = 0; depth < 2; depth += 1) {
+    const argv = tokenize(current);
+    if (!argv || argv.length < 3 || !SHELL_LAUNCHERS.has(binName(argv[0]))) {
+      break;
+    }
+    const scriptIndex = argv.findIndex(
+      (arg, index) => index > 0 && isCommandFlag(arg),
+    );
+    const script = scriptIndex >= 0 ? argv[scriptIndex + 1]?.trim() : undefined;
+    if (!script || script === current) break;
+    current = script;
+  }
+  return current;
+}
+
+const SHELL_LAUNCHERS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+
+function isCommandFlag(arg: string): boolean {
+  return arg === "--command" || /^-[A-Za-z]*c[A-Za-z]*$/.test(arg);
+}
+
 export function formatShellIntent(
   intent: ShellIntent,
   path?: string,
@@ -89,6 +117,9 @@ function classifyArgv(argv: string[]): Classified {
   if (bin === "head" || bin === "tail") return headTailIntent(argv);
   if (bin === "sed") return sedIntent(argv);
   if (bin === "tee") return teeIntent(argv);
+  if (bin === "rg" && argv.includes("--files")) {
+    return { verb: "Find", query: "files" };
+  }
   if (SEARCH_BINS.has(bin)) return grepIntent(argv);
   if (bin === "find") return findIntent(argv);
   if (bin === "ls" || bin === "tree") return listIntent(argv);
@@ -418,7 +449,6 @@ function looksUnsafe(command: string): boolean {
       i += 1;
       continue;
     }
-    if (c === "\n" || c === "\r") return true;
     if (c === "`") return true;
     if (c === "$" && (command[i + 1] === "(" || command[i + 1] === "{")) {
       return true;
@@ -476,6 +506,8 @@ function readUnquotedToken(text: string, start: number): string {
 
 function chainSep(text: string, i: number): number {
   if (text.startsWith("&&", i) || text.startsWith("||", i)) return 2;
+  if (text.startsWith("\r\n", i)) return 2;
+  if (text[i] === "\n" || text[i] === "\r") return 1;
   if (text[i] === ";") return 1;
   return 0;
 }
diff --git a/src/surfaces/transcriptActivity.test.ts b/src/surfaces/transcriptActivity.test.ts
index ec7c49f0..bb4421d6 100644
--- a/src/surfaces/transcriptActivity.test.ts
+++ b/src/surfaces/transcriptActivity.test.ts
@@ -595,6 +595,30 @@ describe("activityPhaseTitle", () => {
     ).toBe("Ran 3 commands · Searched the project · Edited 2 files");
   });
 
+  it("summarises readable historical Codex shell rows by their inferred work", () => {
+    const storedCodexTool = (id: string, text: string): Block => ({
+      id,
+      role: "tool",
+      text,
+      tool: { kind: "execute", title: text, status: "completed" },
+    });
+
+    expect(
+      title([
+        storedCodexTool(
+          "r1",
+          `/bin/zsh -lc "sed -n '1,120p' src/lib/paths.ts
+sed -n '330,430p' src/lib/harness/codexProtocol.test.ts"`,
+        ),
+        storedCodexTool(
+          "r2",
+          `/bin/zsh -lc "nl -ba src/lib/harness/apply.ts | sed -n '520,620p'"`,
+        ),
+        storedCodexTool("run", "/bin/zsh -lc 'npm test'"),
+      ]),
+    ).toBe("Read 2 files · Ran a command");
+  });
+
   it("puts only the call in flight in the present tense", () => {
     expect(
       title([edit("e1", "a.ts"), edit("e2", "b.ts"), shell("c1")], true),
@@ -924,6 +948,20 @@ describe("toolCallLabel", () => {
     ).toBe("Skill /code-review");
   });
 
+  it("hides Codex's shell launcher on commands that stay commands", () => {
+    expect(
+      toolCallLabel({
+        id: "wrapped",
+        role: "tool",
+        text: `/bin/zsh -lc "npm test -- --run src/lib/app.test.ts"`,
+        tool: {
+          kind: "execute",
+          title: `/bin/zsh -lc "npm test -- --run src/lib/app.test.ts"`,
+        },
+      }),
+    ).toBe("npm test -- --run src/lib/app.test.ts");
+  });
+
   it("renders file-reading bash as a Read/Find label", () => {
     expect(
       toolCallLabel({
diff --git a/src/surfaces/transcriptActivity.ts b/src/surfaces/transcriptActivity.ts
index 21367345..95902f20 100644
--- a/src/surfaces/transcriptActivity.ts
+++ b/src/surfaces/transcriptActivity.ts
@@ -454,10 +454,13 @@ export function toolCategory(block: Block): ActivityWorkKind {
   const kind = block.tool?.kind;
   const title = block.text || block.tool?.title;
   const preview = block.tool?.preview;
+  const label = toolCallLabel(block);
   if (isAgentTool(kind, title)) return "agent";
   if (isEditTool(kind, title, preview)) return "edit";
   if (isSearchTool(kind, title, preview)) return "research";
   if (isReadTool(kind, title, preview)) return "research";
+  if (/^(?:Edit|Write)\s+\S/i.test(label)) return "edit";
+  if (/^(?:Read|List|Find)\b/i.test(label)) return "research";
   if (isExecuteTool(kind, title)) return "run";
   return "other";
 }
@@ -568,7 +571,12 @@ function tallySteps(steps: Block[]): PhaseTally {
     const kind = block.tool?.kind;
     const title = block.text || block.tool?.title;
     const preview = block.tool?.preview;
-    const target = preview?.path ?? preview?.fileName ?? block.id;
+    const label = toolCallLabel(block);
+    const labelledTarget = label.match(
+      /^(?:Read|List|Edit|Write)\s+(.+)$/i,
+    )?.[1];
+    const target =
+      preview?.path ?? preview?.fileName ?? labelledTarget ?? block.id;
     const category = toolCategory(block);
     if (!tally.order.includes(category)) tally.order.push(category);
     switch (category) {
@@ -582,8 +590,9 @@ function tallySteps(steps: Block[]): PhaseTally {
         tally.runs += 1;
         break;
       case "research":
-        if (isSearchTool(kind, title, preview)) tally.searches += 1;
-        else tally.reads.add(target);
+        if (/^Find\b/i.test(label) || isSearchTool(kind, title, preview)) {
+          tally.searches += 1;
+        } else tally.reads.add(target);
         break;
       default:
         tally.others += 1;