@fresh-editor/fresh-editor 0.3.8 → 0.3.10

package/plugins/orchestrator.ts

@@ -76,6 +76,18 @@ interface AgentSession {
   state: AgentState;
   // Wall-clock ms when orchestrator.new fired createWindow.
   createdAt: number;
+  // `true` when this row is a worktree discovered on disk (via
+  // `git worktree list`) that has no live editor window yet.
+  // Discovered rows carry a synthetic negative `id`, no
+  // `terminalId`, and dive by *attaching* a new session to
+  // `root` rather than switching to an existing window. They are
+  // dropped from `orchestratorSessions` the moment a real window
+  // is opened at the same `root`.
+  discovered?: boolean;
+  // Branch checked out in this worktree (best-effort, for
+  // display). Set for discovered rows; left undefined for live
+  // sessions where the tab/label already carries the identity.
+  branch?: string;
 }
 
 // =============================================================================
@@ -84,6 +96,25 @@ interface AgentSession {
 
 const orchestratorSessions = new Map<number, AgentSession>();
 
+// Stable synthetic ids for discovered (on-disk, not-yet-opened)
+// worktrees, keyed by canonical path. Live windows own the
+// positive id space (editor `WindowId`s); discovered rows take
+// negative ids so the two never collide and the existing
+// `orchestratorSessions.get(id)` call sites keep working. Ids
+// stay stable across rescans so the dialog selection doesn't
+// jump when the worktree set is refreshed. `-1` is reserved as a
+// "no selection" sentinel elsewhere, so allocation starts at `-2`.
+const discoveredIdByPath = new Map<string, number>();
+let nextDiscoveredId = -2;
+function discoveredIdFor(path: string): number {
+  let id = discoveredIdByPath.get(path);
+  if (id === undefined) {
+    id = nextDiscoveredId--;
+    discoveredIdByPath.set(path, id);
+  }
+  return id;
+}
+
 // New-session form state. `null` ⇒ the floating form isn't
 // open. Each field's `value` + `cursor` mirrors what the host
 // renders inside the panel's TextInput widgets; the `submitting`
@@ -118,6 +149,14 @@ interface NewSessionForm {
   // (checkbox disabled, branch field inert). `null`: probe
   // in flight (keep checkbox in its last-known state).
   projectPathIsGit: boolean | null;
+  // `true` when the resolved Project Path is itself an existing
+  // *linked* worktree (created by `git worktree add`). In that
+  // case leaving "Create a new git worktree" unchecked attaches
+  // the session to it as a managed worktree rather than treating
+  // it as a shared root. The probe defaults the checkbox to
+  // unchecked when it first detects this, and `buildFormSpec`
+  // surfaces an explanatory hint. `null` while the probe runs.
+  projectPathIsLinkedWorktree: boolean | null;
   // Concrete session name the auto-generator would produce
   // for the current Project Path (e.g. "session-3"). Surfaced
   // as the Session Name placeholder so the user sees the
@@ -208,10 +247,42 @@ interface OpenDialogState {
   // anchor it needs.
   originalActiveSession: number;
   // When non-null, the preview pane swaps to a confirmation
-  // panel for the named action against the named session id.
-  // Cleared on Cancel or after the action completes.
+  // panel for the named action against the listed session ids.
+  // A single-element `ids` is the per-row Stop/Archive/Delete
+  // path; a multi-element `ids` is a bulk action over the
+  // checkbox selection. Cleared on Cancel or after the action
+  // completes.
   pendingConfirm:
-    | { action: "stop" | "archive" | "delete"; sessionId: number }
+    | { action: "stop" | "archive" | "delete"; ids: number[] }
+    | null;
+  // Rows the user has checkbox-selected (Space, or click) for a
+  // bulk Stop/Archive/Delete. Holds session ids — positive for
+  // live windows, negative for discovered on-disk worktrees
+  // (which bulk-delete via `git worktree remove`). Survives filter
+  // and scope changes; pruned against the live set on every
+  // refresh. Bulk mode (the dedicated selection bar) engages once
+  // two or more rows are checked.
+  selectedIds: Set<number>;
+  // `true` shows the discovered on-disk worktree rows in the list.
+  // The "Show all worktrees" checkbox below the scope control toggles
+  // it (Alt+T / `orchestrator_toggle_worktrees`). Defaults to false
+  // (worktrees hidden) — discovery is opt-in. Remembered across opens
+  // via `lastShowWorktrees`.
+  showWorktrees: boolean;
+  // `true` hides "trivial" sessions — those with no terminal and at
+  // most one open file/buffer (empty-unnamed-buffer and single-file
+  // shells left behind by one-off editor launches). The "Show
+  // empty/1-file sessions" checkbox (Alt+I / `orchestrator_toggle_trivial`)
+  // flips it. Defaults to true; remembered across opens via
+  // `lastHideTrivial`. The active session and discovered worktree rows
+  // are never hidden by this filter regardless of the flag.
+  hideTrivial: boolean;
+  // Progress marker for an in-flight *bulk* action. While set, the
+  // selection bar shows "Archiving 2/3…" and its buttons are
+  // hidden so a second Enter can't re-fire mid-batch. Cleared when
+  // the batch finishes.
+  bulkInFlight:
+    | { action: "stop" | "archive" | "delete"; total: number; done: number }
     | null;
   // Rows the embed reserves and rows the sessions list shows.
   // Captured once at dialog-open from the editor's viewport so
@@ -265,6 +336,92 @@ let openPanel: FloatingWidgetPanel | null = null;
 // showing every session; flipping it with the Project control / Alt+P
 // updates this and the next open honours it.
 let lastOpenScope: "current" | "all" = "all";
+// Remembered across opens, like `lastOpenScope`: whether the
+// discovered on-disk worktree rows are shown. Defaults to false
+// (worktrees hidden) — surfacing them is opt-in via "Show all
+// worktrees" (Alt+T).
+let lastShowWorktrees = false;
+// Remembered across opens: whether "trivial" sessions are hidden.
+// Defaults to true — every editor launch on a throwaway directory or a
+// single file leaves a workspace file behind, which restores as a shell
+// window and clutters the list. Hiding them by default keeps the picker
+// focused on real sessions; the "Show empty/1-file sessions" checkbox
+// (Alt+I) reveals them.
+let lastHideTrivial = true;
+
+// Per-session content summary keyed by canonical session root, built
+// from the on-disk workspace files. The restored shell windows don't
+// carry their open-tab layout (it's lazily re-warmed on first dive), so
+// the workspace file is the only place to learn how much a session
+// holds. Rebuilt each time the picker opens. A session is "trivial"
+// when it has no terminal and at most one real file/unnamed buffer —
+// the empty-unnamed-buffer and single-file cases the filter targets.
+interface SessionContent {
+  files: number;
+  hasTerminal: boolean;
+  trivial: boolean;
+}
+const sessionContentByRoot = new Map<string, SessionContent>();
+
+// Roots from the editor (`WindowInfo.root`) and from workspace files
+// (`working_dir`) are both canonical absolute paths, but normalise a
+// trailing slash so the two always key the same map entry.
+function normRoot(p: string): string {
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+
+// Scan `<dataDir>/workspaces/*.json` and summarise each session's open
+// content. Mirrors the host's own `discover_sessions` (which keys on the
+// file's `working_dir`), so a root matches regardless of how the
+// filename was percent-encoded. Best-effort: unreadable / unparseable
+// files are skipped, and a missing summary is treated as "not trivial"
+// (shown) by the filter, so we never hide a session we couldn't classify.
+function scanSessionContent(): void {
+  sessionContentByRoot.clear();
+  const dir = editor.pathJoin(editor.getDataDir(), "workspaces");
+  let entries: DirEntry[];
+  try {
+    entries = editor.readDir(dir);
+  } catch {
+    return;
+  }
+  if (!entries) return;
+  for (const e of entries) {
+    if (!e.is_file || !e.name.endsWith(".json")) continue;
+    const raw = editor.readFile(editor.pathJoin(dir, e.name));
+    if (!raw) continue;
+    let ws: Record<string, unknown>;
+    try {
+      ws = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const wd = ws["working_dir"];
+    if (typeof wd !== "string") continue;
+    let files = 0;
+    let hasTerminal = Array.isArray(ws["terminals"]) &&
+      (ws["terminals"] as unknown[]).length > 0;
+    const splits = ws["split_states"];
+    if (splits && typeof splits === "object") {
+      for (const sv of Object.values(splits as Record<string, unknown>)) {
+        const tabs = (sv as Record<string, unknown> | null)?.["open_tabs"];
+        if (!Array.isArray(tabs)) continue;
+        for (const t of tabs) {
+          if (t && typeof t === "object") {
+            if ("File" in t || "Unnamed" in t) files++;
+            else if ("Terminal" in t) hasTerminal = true;
+          }
+        }
+      }
+    }
+    sessionContentByRoot.set(normRoot(wd), {
+      files,
+      hasTerminal,
+      trivial: !hasTerminal && files <= 1,
+    });
+  }
+}
+
 const OPEN_MODE = "orchestrator-open";
 
 // =============================================================================
@@ -298,11 +455,122 @@ function reconcileSessions(): void {
       if (s.shared_worktree != null) existing.sharedWorktree = s.shared_worktree;
     }
   }
+  // Live windows live in the positive id space; their absence from
+  // `listWindows()` means they were closed, so drop them. Discovered
+  // worktrees (negative ids) are NOT backed by a window and must
+  // survive this sweep — they're pruned separately, against the
+  // on-disk worktree set, by `refreshDiscoveredWorktrees`.
   for (const id of orchestratorSessions.keys()) {
-    if (!seen.has(id)) orchestratorSessions.delete(id);
+    if (id > 0 && !seen.has(id)) orchestratorSessions.delete(id);
+  }
+  // A worktree that's now open as a live window must not also linger
+  // as a discovered row. Drop any discovered entry whose root a live
+  // session already occupies.
+  const liveRoots = new Set<string>();
+  for (const s of orchestratorSessions.values()) {
+    if (!s.discovered) liveRoots.add(s.root);
+  }
+  for (const [id, s] of orchestratorSessions) {
+    if (s.discovered && liveRoots.has(s.root)) orchestratorSessions.delete(id);
   }
 }
 
+// =============================================================================
+// Discovered-worktree scan
+//
+// Surfaces worktrees that exist on disk but have no live editor
+// window, so the user doesn't have to add them by hand. Because
+// open sessions can span several repos, `git worktree list` must
+// run once *per project*: the scan set is the distinct canonical
+// repo roots of every live session, plus the editor's cwd repo.
+// Each linked worktree not already open (and not an
+// orchestrator-internal tree) becomes a discovered row that dives
+// by attaching a fresh session to it.
+// =============================================================================
+
+let discoveryInFlight = false;
+
+function isInternalWorktreePath(path: string): boolean {
+  // The sync-workspace and the `.archived/` graveyard are
+  // orchestrator bookkeeping, not user sessions.
+  return path.includes(".sync-workspace") || path.includes("/.archived/");
+}
+
+async function refreshDiscoveredWorktrees(): Promise<void> {
+  if (discoveryInFlight) return;
+  discoveryInFlight = true;
+  try {
+    reconcileSessions();
+
+    // (1) Candidate dirs: every live session's root + the editor
+    //     cwd. Resolve each to its canonical main repo root and
+    //     dedupe so a repo with N open worktrees is scanned once.
+    const candidates = new Set<string>([editor.getCwd()]);
+    for (const s of orchestratorSessions.values()) {
+      if (!s.discovered) candidates.add(s.root);
+    }
+    const mainRoots = new Set<string>();
+    for (const dir of candidates) {
+      const canonical = await resolveCanonicalRepoRoot(dir);
+      if (canonical) mainRoots.add(canonical);
+    }
+
+    // (2) Roots already occupied by a live session — discovered rows
+    //     for these would be duplicates.
+    const liveRoots = new Set<string>();
+    for (const s of orchestratorSessions.values()) {
+      if (!s.discovered) liveRoots.add(s.root);
+    }
+
+    // (3) Scan each repo and collect the linked worktrees worth
+    //     surfacing.
+    const foundPaths = new Set<string>();
+    for (const repoRoot of mainRoots) {
+      const listed = await listLinkedWorktrees(repoRoot);
+      if (!listed) continue;
+      for (const wt of listed.worktrees) {
+        if (liveRoots.has(wt.path)) continue;
+        if (isInternalWorktreePath(wt.path)) continue;
+        foundPaths.add(wt.path);
+        const id = discoveredIdFor(wt.path);
+        const label = wt.branch || editor.pathBasename(wt.path);
+        const existing = orchestratorSessions.get(id);
+        if (existing) {
+          existing.label = label;
+          existing.root = wt.path;
+          existing.projectPath = listed.mainRoot;
+          existing.branch = wt.branch;
+        } else {
+          orchestratorSessions.set(id, {
+            id,
+            label,
+            root: wt.path,
+            projectPath: listed.mainRoot,
+            sharedWorktree: false,
+            terminalId: null,
+            state: "ready",
+            createdAt: Date.now(),
+            discovered: true,
+            branch: wt.branch,
+          });
+        }
+      }
+    }
+
+    // (4) Prune discovered rows that vanished from disk (or got
+    //     opened, picked up by the liveRoots check above).
+    for (const [id, s] of orchestratorSessions) {
+      if (s.discovered && !foundPaths.has(s.root)) {
+        orchestratorSessions.delete(id);
+        discoveredIdByPath.delete(s.root);
+      }
+    }
+  } finally {
+    discoveryInFlight = false;
+  }
+  if (openPanel) refreshOpenDialog();
+}
+
 // =============================================================================
 // Session display helpers
 // =============================================================================
@@ -381,12 +649,38 @@ function projectLabel(key: string): string {
 function filterSessions(needle: string): number[] {
   reconcileSessions();
   const scope = openDialog?.scope ?? "current";
+  const showWorktrees = openDialog?.showWorktrees ?? false;
+  const hideTrivial = openDialog?.hideTrivial ?? false;
   const cur = currentProjectKey();
-  const allIds = Array.from(orchestratorSessions.keys());
+  let allIds = Array.from(orchestratorSessions.keys());
+  // "Show all worktrees" is opt-in: by default the discovered on-disk
+  // worktree rows are filtered out.
+  if (!showWorktrees) {
+    allIds = allIds.filter((id) => !orchestratorSessions.get(id)!.discovered);
+  }
+  // "Hide empty/1-file sessions": drop the restored shells that hold no
+  // real work. The active session is always kept (you must be able to
+  // see where you are), and discovered worktree rows are governed by
+  // their own toggle, not this one. A session with no summary (e.g. a
+  // freshly created agent session not yet written to disk) is kept too.
+  if (hideTrivial) {
+    const activeId = editor.activeWindow();
+    allIds = allIds.filter((id) => {
+      const s = orchestratorSessions.get(id)!;
+      if (s.discovered || id === activeId) return true;
+      const c = sessionContentByRoot.get(normRoot(s.root));
+      return !c || !c.trivial;
+    });
+  }
+
+  const isDisc = (id: number): number =>
+    orchestratorSessions.get(id)!.discovered ? 1 : 0;
 
-  // Sort by (current-project-first, then id) so an "all" view
-  // groups the current project's sessions at the top and other
-  // projects' sessions below in a stable order.
+  // Sort by (current-project-first, project, live-before-discovered,
+  // then id) so an "all" view groups the current project's sessions
+  // at the top and other projects' below, and within each project the
+  // pre-existing live sessions come first with the discovered on-disk
+  // worktrees listed after them.
   const byProjectThenId = (a: number, b: number): number => {
     const sa = orchestratorSessions.get(a)!;
     const sb = orchestratorSessions.get(b)!;
@@ -396,6 +690,9 @@ function filterSessions(needle: string): number[] {
     const ka = projectKeyOf(sa);
     const kb = projectKeyOf(sb);
     if (ka !== kb) return ka < kb ? -1 : 1;
+    const da = isDisc(a);
+    const db = isDisc(b);
+    if (da !== db) return da - db;
     return a - b;
   };
 
@@ -422,25 +719,33 @@ function filterSessions(needle: string): number[] {
       matches.push({ id, score: 2, len: label.length });
     }
   }
-  matches.sort((a, b) => a.score - b.score || a.len - b.len || a.id - b.id);
+  // Live sessions before discovered worktrees at equal relevance, so
+  // the on-disk rows still trail the real sessions in search results.
+  matches.sort(
+    (a, b) =>
+      a.score - b.score || isDisc(a.id) - isDisc(b.id) || a.len - b.len ||
+      a.id - b.id,
+  );
   return matches.map((m) => m.id);
 }
 
-// Column widths for the tabular session list. ID holds `[NN] `;
-// NAME holds the label plus the BASE / ⇄ badges; PROJECT (filled
-// only for cross-project rows) trails. Kept in sync with
-// `sessionsColumnHeader`.
-const LIST_ID_W = 5;
-const LIST_NAME_W = 20;
+// Width of the NAME column before the trailing PROJECT column kicks
+// in (filled only for cross-project rows). Kept in sync with
+// `sessionsColumnHeader`. There is no id column — the numeric window
+// id is an internal handle the user never needs in the list; rows are
+// identified by name, the active one rendered bold and on-disk
+// worktrees flagged with a `· on-disk` tag.
+const LIST_NAME_W = 24;
 
-// Header row above the session list: `ID   NAME …   PROJECT`.
+// Header row above the session list: `NAME …   PROJECT`.
 function sessionsColumnHeader(): WidgetSpec {
   return {
     kind: "raw",
     entries: [
       styledRow([
         {
-          text: "ID".padEnd(LIST_ID_W) + "NAME".padEnd(LIST_NAME_W) + "PROJECT",
+          // 4-space lead aligns under the per-row `[ ] ` checkbox.
+          text: "    " + "NAME".padEnd(LIST_NAME_W) + "PROJECT",
           style: { fg: "ui.menu_disabled_fg" },
         },
       ]),
@@ -448,39 +753,51 @@ function sessionsColumnHeader(): WidgetSpec {
   };
 }
 
-// Build one rendered list-item row for `id`, laid out in columns:
-//   `[id]`  <name + BASE/⇄ badges>   <project basename>
-// The active session's id renders in the active-tab colour (the
-// list has no separate state column); the project column is filled
-// only for sessions that don't belong to the current project.
+// Build one rendered list-item row for `id`:
+//   `[ ] ` <name + on-disk tag>   <project basename>
+// The active session's name renders bold; discovered (on-disk,
+// unopened) worktrees render dim with a `· on-disk` tag instead of a
+// glyph. The project column is filled only for sessions that don't
+// belong to the current project.
 function renderListItem(id: number, activeId: number): TextPropertyEntry {
   const s = orchestratorSessions.get(id);
   if (!s) {
-    return styledRow([{ text: `[${id}] (unknown)` }]);
+    return styledRow([{ text: "(unknown)" }]);
   }
   const isActive = id === activeId;
-  const isBase = id === 1;
+  const isDiscovered = !!s.discovered;
+  const isChecked = openDialog?.selectedIds.has(id) ?? false;
+
+  // Leading multi-select checkbox. `[x]` when this row is in the
+  // bulk selection, `[ ]` otherwise — toggled with Space (the
+  // rebindable `orchestrator_toggle_select`) or a click.
+  const checkbox = {
+    text: isChecked ? "[x] " : "[ ] ",
+    style: isChecked
+      ? { fg: "ui.help_key_fg", bold: true }
+      : { fg: "ui.menu_disabled_fg" },
+  };
 
-  const idText = `[${id}]`.padEnd(LIST_ID_W);
   const entries: { text: string; style?: Record<string, unknown> }[] = [
+    checkbox,
     {
-      text: idText,
+      text: s.label,
       style: isActive
-        ? { fg: "ui.tab_active_fg", bold: true }
-        : { fg: "ui.help_key_fg" },
+        ? { fg: "ui.help_key_fg", bold: true }
+        : isDiscovered
+        ? { fg: "ui.menu_disabled_fg" }
+        : undefined,
     },
-    { text: s.label, style: isActive ? { bold: true } : undefined },
   ];
-  // Visible width of the NAME column so far (label + badges), used
+  // Visible width of the NAME column so far (label + tags), used
   // to pad out to LIST_NAME_W before the PROJECT column.
   let nameWidth = s.label.length;
-  if (isBase) {
-    entries.push({ text: " BASE", style: { fg: "ui.help_key_fg", bold: true } });
-    nameWidth += 5;
-  }
-  if (s.sharedWorktree || countSiblingsAtRoot(s.root) > 1) {
-    entries.push({ text: " ⇄", style: { fg: "ui.menu_disabled_fg" } });
-    nameWidth += 2;
+  if (isDiscovered) {
+    entries.push({
+      text: " · on-disk",
+      style: { fg: "ui.menu_disabled_fg", italic: true },
+    });
+    nameWidth += 10;
   }
   // PROJECT column: basename for cross-project rows only; current-
   // project rows leave it blank (the whole list is one project when
@@ -515,57 +832,24 @@ function buildPreviewEntries(
   }
   const activeId = editor.activeWindow();
   const isActive = s.id === activeId;
-  const isBase = s.id === 1;
   const stateText = isActive ? "ACT" : STATE_GLYPH[s.state].trim();
-  // Count siblings sharing the same `root`. The set includes
-  // `s` itself; `> 1` means at least one other session lives at
-  // the same path (shared-worktree mode, or two sessions
-  // explicitly aimed at the same directory).
-  const sharedCount = countSiblingsAtRoot(s.root);
   const headerEntries: { text: string; style?: Record<string, unknown> }[] = [
     {
       text: stateText,
       style: isActive
-        ? { fg: "ui.tab_active_fg", bold: true }
+        ? { fg: "ui.help_key_fg", bold: true }
         : { fg: "ui.menu_disabled_fg" },
     },
     { text: "  " },
     { text: ageString(s.createdAt), style: { fg: "ui.menu_disabled_fg" } },
   ];
-  if (isBase) {
-    // BASE badge in the preview — the long-form counterpart to
-    // the list-row badge, with an inline explanation so the user
-    // doesn't have to wonder why Stop / Archive / Delete are
-    // greyed out.
-    headerEntries.push(
-      { text: "  " },
-      {
-        text: "BASE",
-        style: { fg: "ui.help_key_fg", bold: true },
-      },
-      { text: " — editor session", style: { fg: "ui.menu_disabled_fg", italic: true } },
-    );
-  }
-  if (sharedCount > 1) {
+  if (!s.discovered && !ownsWorktree(s)) {
+    // In-place / launch session: runs inside a real checkout, owns no
+    // dedicated worktree. Surfaced so the user knows Archive doesn't
+    // apply (Delete just forgets it, leaving the directory untouched).
     headerEntries.push(
       { text: "  " },
-      {
-        text: `SHARED ×${sharedCount}`,
-        style: { fg: "ui.status_error_indicator_fg", bold: true },
-      },
-    );
-  } else if (s.sharedWorktree) {
-    // Single-session shared-worktree mode (the user opted out of
-    // a dedicated worktree even though no second session is on
-    // this root yet). Still worth surfacing so the user knows
-    // why Archive / Delete refuse to run a `git worktree
-    // remove` here.
-    headerEntries.push(
-      { text: "  " },
-      {
-        text: "SHARED",
-        style: { fg: "ui.menu_disabled_fg", italic: true },
-      },
+      { text: "in-place", style: { fg: "ui.menu_disabled_fg", italic: true } },
     );
   }
   return [
@@ -576,16 +860,85 @@ function buildPreviewEntries(
   ];
 }
 
-/// Return the number of orchestrator sessions whose `root`
-/// equals `root`. Used to surface "SHARED ×N" in the preview
-/// pane and to refuse Archive / Delete on a shared root
-/// while another session still lives there.
-function countSiblingsAtRoot(root: string): number {
-  let n = 0;
-  for (const s of orchestratorSessions.values()) {
-    if (s.root === root) n += 1;
+// A session "owns" a removable git worktree when it was created as a
+// dedicated `git worktree add` (project path set, not a shared/in-place
+// root) or was discovered on disk via `git worktree list`. Only these
+// have a worktree to `git worktree remove`/`move`. The launch session
+// (the dir the editor was started in) and in-place sessions run inside
+// a real checkout, so Archive (which moves the worktree) doesn't apply
+// and Delete simply forgets the session without touching the directory.
+function ownsWorktree(s: AgentSession): boolean {
+  return !!s.discovered || (!!s.projectPath && !s.sharedWorktree);
+}
+
+// =============================================================================
+// Multi-select / bulk actions
+//
+// The user checkbox-selects rows (Space — the rebindable
+// `orchestrator_toggle_select` — or a click). Once two or more rows
+// are checked the preview pane swaps to the bulk selection bar
+// (`buildBulkPane`) offering Stop / Archive / Delete over the whole
+// set, with a single confirmation for the batch. Rows ineligible for
+// a given action (the base session; live sessions sharing a worktree)
+// are skipped, and each button's count reflects only the eligible
+// members.
+// =============================================================================
+
+type BulkAction = "stop" | "archive" | "delete";
+
+// Checked ids that still resolve to a known session, in the dialog's
+// current display order (so the bulk bar lists them the way the list
+// shows them). Selection persists across filter/scope changes, so an
+// id can be checked while filtered out of view — those still count.
+function selectedSessions(): number[] {
+  if (!openDialog) return [];
+  const order = openDialog.filteredIds;
+  const seen = new Set<number>();
+  const out: number[] = [];
+  for (const id of order) {
+    if (openDialog.selectedIds.has(id) && orchestratorSessions.has(id)) {
+      out.push(id);
+      seen.add(id);
+    }
+  }
+  // Checked-but-filtered-out rows, appended in id order so the count
+  // stays honest even when a search hides part of the selection.
+  for (const id of openDialog.selectedIds) {
+    if (!seen.has(id) && orchestratorSessions.has(id)) out.push(id);
+  }
+  return out;
+}
+
+// Is `id` a legal target for `action`? Base session is never
+// touched. Stop only applies to live windows. Archive/Delete apply
+// to discovered worktrees (removable on disk) and to live sessions
+// that own their worktree outright (not shared with siblings or the
+// project root).
+function bulkEligible(action: BulkAction, id: number): boolean {
+  const s = orchestratorSessions.get(id);
+  if (!s) return false;
+  // Stop kills the agent process group — only meaningful for a live
+  // session that actually spawned one (never the launch session, which
+  // has no agent terminal, so signalling it can't touch the editor).
+  if (action === "stop") return !s.discovered && id > 0 && !!s.terminalId;
+  // Delete forgets any session. When it owns a worktree the worktree is
+  // removed too; otherwise (launch/in-place) it's just dropped.
+  if (action === "delete") return id > 0 || !!s.discovered;
+  // Archive moves the worktree to the graveyard, so it needs one.
+  return ownsWorktree(s);
+}
+
+function eligibleSelected(action: BulkAction): number[] {
+  return selectedSessions().filter((id) => bulkEligible(action, id));
+}
+
+// Drop checked ids whose session has vanished (closed window,
+// pruned worktree) so the selection can't grow stale references.
+function pruneSelection(): void {
+  if (!openDialog) return;
+  for (const id of [...openDialog.selectedIds]) {
+    if (!orchestratorSessions.has(id)) openDialog.selectedIds.delete(id);
   }
-  return n;
 }
 
 // Blank-row separator used inside the Sessions column between
@@ -610,10 +963,10 @@ function maxListRowsForScreen(): number {
   const panelH = Math.floor(h * 0.9);
   // Chrome that isn't list rows: panel borders (2) + title (1) +
   // spacer (1) + footer (1) + sessions-section borders (2) +
-  // column chrome above the list (New + Project + Filter +
-  // separator + header = 5) = 12. Floor at MIN_LIST_ROWS so a tiny
-  // terminal still shows something.
-  return Math.max(MIN_LIST_ROWS, panelH - 12);
+  // column chrome above the list (New + Project + Worktree-filter +
+  // Trivial-filter + Filter + separator + header = 7) = 14. Floor at
+  // MIN_LIST_ROWS so a tiny terminal still shows something.
+  return Math.max(MIN_LIST_ROWS, panelH - 14);
 }
 
 // Compose the right-hand preview pane. Normally it shows info
@@ -658,130 +1011,28 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
       ),
     });
   }
-  if (openDialog?.pendingConfirm && s && openDialog.pendingConfirm.sessionId === s.id) {
-    const action = openDialog.pendingConfirm.action;
-    if (action === "stop") {
-      return labeledSection({
-        label: "Confirm Stop",
-        child: col(
-          {
-            kind: "raw",
-            entries: [
-              styledRow([
-                {
-                  text: `Stop session [${s.id}] ${s.label}?`,
-                  style: { bold: true },
-                },
-              ]),
-              styledRow([{ text: "" }]),
-              styledRow([{ text: "This will:" }]),
-              styledRow([{ text: "  • send SIGTERM to all session processes" }]),
-              styledRow([{ text: "  • SIGKILL after a short grace period" }]),
-              styledRow([{ text: "" }]),
-              styledRow([{ text: "The worktree and session record remain." }]),
-            ],
-          },
-          spacer(0),
-          row(
-            flexSpacer(),
-            button("Cancel", { key: "confirm-cancel" }),
-            spacer(2),
-            button("Confirm Stop", {
-              intent: "danger",
-              key: "confirm-stop",
-            }),
-          ),
-        ),
-      });
-    }
-    if (action === "archive") {
-      return labeledSection({
-        label: "Confirm Archive",
-        child: col(
-          {
-            kind: "raw",
-            entries: [
-              styledRow([
-                {
-                  text: `Archive session [${s.id}] ${s.label}?`,
-                  style: { bold: true },
-                },
-              ]),
-              styledRow([{ text: "" }]),
-              styledRow([{ text: "This will:" }]),
-              styledRow([{ text: "  • SIGKILL all session processes" }]),
-              styledRow([{ text: "  • close the editor session" }]),
-              styledRow([{ text: "  • move the worktree to .archived/" }]),
-              styledRow([{ text: "" }]),
-              styledRow([{ text: "Reversible via Unarchive." }]),
-            ],
-          },
-          spacer(0),
-          row(
-            flexSpacer(),
-            button("Cancel", { key: "confirm-cancel" }),
-            spacer(2),
-            button("Confirm Archive", {
-              intent: "danger",
-              key: "confirm-archive",
-            }),
-          ),
-        ),
-      });
-    }
-    if (action === "delete") {
-      return labeledSection({
-        label: "Confirm Delete",
-        child: col(
-          {
-            kind: "raw",
-            entries: [
-              styledRow([
-                {
-                  text: `Delete session [${s.id}] ${s.label}?`,
-                  style: { bold: true },
-                },
-              ]),
-              styledRow([{ text: "" }]),
-              styledRow([{ text: "This will:" }]),
-              styledRow([{ text: "  • stop all session processes" }]),
-              styledRow([{ text: "  • run `git worktree remove`" }]),
-              styledRow([{ text: "  • drop the session record" }]),
-              styledRow([{ text: "" }]),
-              styledRow([
-                {
-                  text: "Uncommitted changes will be lost.",
-                  style: {
-                    fg: "ui.status_error_indicator_fg",
-                    bold: true,
-                  },
-                },
-              ]),
-            ],
-          },
-          spacer(0),
-          row(
-            flexSpacer(),
-            button("Cancel", { key: "confirm-cancel" }),
-            spacer(2),
-            button("Confirm Delete", {
-              intent: "danger",
-              key: "confirm-delete",
-            }),
-          ),
-        ),
-      });
-    }
+  // Confirmation panel — single-row Stop/Archive/Delete or a bulk
+  // batch. Independent of the cursor row: the confirmed ids live in
+  // `pendingConfirm`, so it renders whenever a confirm is pending.
+  if (openDialog?.pendingConfirm) {
+    return buildConfirmPane(openDialog.pendingConfirm);
+  }
+  // Bulk selection bar: two or more rows checked (or a bulk action
+  // in flight) → operate on the whole batch rather than the cursor
+  // row.
+  if (selectedSessions().length >= 2 || openDialog?.bulkInFlight) {
+    return buildBulkPane();
   }
   // Match the sessions column's content height so the two panes'
   // bottom borders land on the same row. Sessions column inside its
-  // borders = New (1) + Project (1) + Filter (1) + separator (1) +
-  // header (1) + list (listVisibleRows) = listVisibleRows + 5.
-  // Preview inside its borders = button row (1) + spacer (1) +
-  // embedRows, so embedRows must equal listVisibleRows + 3. When
-  // details ARE shown, two info rows + a spacer eat three more
-  // lines — `_DETAILS_CHROME_ROWS` accounts for that.
-  const totalEmbedBase = (openDialog?.listVisibleRows ?? MIN_LIST_ROWS) + 3;
+  // borders = New (1) + Project (1) + Worktree-filter (1) +
+  // Trivial-filter (1) + Filter (1) + separator (1) + header (1) +
+  // list (listVisibleRows) = listVisibleRows + 7. Preview inside its
+  // borders = button row (1) + spacer (1) + embedRows, so embedRows
+  // must equal listVisibleRows + 5. When details ARE shown, two info
+  // rows + a spacer eat three more lines — `_DETAILS_CHROME_ROWS`
+  // accounts for that.
+  const totalEmbedBase = (openDialog?.listVisibleRows ?? MIN_LIST_ROWS) + 5;
   const detailsOn = openDialog?.showDetails ?? false;
   const _DETAILS_CHROME_ROWS = 3; // 2 info rows + 1 spacer
   const embedRows = Math.max(
@@ -814,6 +1065,48 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
   // turns details on, pressing `[ Preview ]` turns them off
   // (back to compact).
   const detailsToggleLabel = detailsOn ? "Preview" : "Details";
+  // Discovered worktree: no live window to embed, so there's
+  // nothing to Stop / Archive / Delete yet. Offer only "Open"
+  // (Visit attaches a fresh session to the worktree) and describe
+  // what diving will do. The empty `windowId: 0` embed keeps the
+  // pane the same height as live-session previews so the dialog
+  // doesn't jump when the selection moves between row kinds.
+  if (s.discovered) {
+    const openButtonRow = row(
+      button("Open", { intent: "primary", key: "visit" }),
+      flexSpacer(),
+      button("Stop", { key: "stop", disabled: true }),
+      spacer(2),
+      button("Archive", { key: "archive", disabled: true }),
+      spacer(2),
+      button("Delete", { intent: "danger", key: "delete", disabled: true }),
+    );
+    const info: TextPropertyEntry[] = [
+      styledRow([
+        { text: "On-disk worktree (not open)", style: { fg: "ui.menu_disabled_fg", bold: true } },
+      ]),
+      styledRow([{ text: "" }]),
+      styledRow([{ text: "branch  ", style: { fg: "ui.menu_disabled_fg" } }, { text: s.branch || "(detached)" }]),
+      styledRow([{ text: "path    ", style: { fg: "ui.menu_disabled_fg" } }, { text: s.root }]),
+      styledRow([{ text: "" }]),
+      styledRow([
+        {
+          text: "Press Enter to open this worktree as a session.",
+          style: { fg: "ui.help_key_fg", italic: true },
+        },
+      ]),
+    ];
+    return labeledSection({
+      label: `${s.label}  —  on-disk worktree`,
+      child: col(
+        openButtonRow,
+        spacer(0),
+        { kind: "raw", entries: info },
+        spacer(0),
+        windowEmbed({ windowId: 0, rows: Math.max(3, embedRows - 6), key: "live-preview" }),
+      ),
+    });
+  }
   // Per-action availability. The row always renders all four
   // buttons (no layout shift between selections), but each is
   // marked disabled when its action would be refused against the
@@ -822,17 +1115,18 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
   // same conditions that `stopSelectedSession`, `enterConfirm`,
   // and the lifecycle handlers already check internally.
   //
-  //  * Stop: refused on the base session (id 1).
-  //  * Archive / Delete: also refused on the base session, plus
-  //    when this session shares its worktree with the project
-  //    root (no `git worktree` entry to remove) or shares a root
-  //    with other live sessions (would yank disk out from
-  //    under them).
-  const isBase = s.id === 1;
-  const siblings = countSiblingsAtRoot(s.root);
-  const sharesRoot = siblings > 1 || s.sharedWorktree;
-  const stopDisabled = isBase;
-  const lifecycleDisabled = isBase || sharesRoot;
+  //  * Stop: only a live session with an agent terminal can be
+  //    stopped (the launch session has none).
+  //  * Archive: needs an owned worktree to move to the graveyard.
+  //  * Delete: forgets the session, removing the worktree only when one
+  //    is owned (otherwise the directory is left untouched).
+  //  * Archive/Delete are both refused on the last live window — the
+  //    editor must always host at least one.
+  const hasWorktree = ownsWorktree(s);
+  const isLastWindow = s.id > 0 && liveWindowCount() <= 1;
+  const stopDisabled = s.discovered || !s.terminalId;
+  const archiveDisabled = !hasWorktree || isLastWindow;
+  const deleteDisabled = isLastWindow;
   const buttonRow = row(
     button("Visit", { intent: "primary", key: "visit" }),
     spacer(2),
@@ -841,12 +1135,12 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
     spacer(2),
     button("Stop", { key: "stop", disabled: stopDisabled }),
     spacer(2),
-    button("Archive", { key: "archive", disabled: lifecycleDisabled }),
+    button("Archive", { key: "archive", disabled: archiveDisabled }),
     spacer(2),
     button("Delete", {
       intent: "danger",
       key: "delete",
-      disabled: lifecycleDisabled,
+      disabled: deleteDisabled,
     }),
   );
   const embedWidget = windowEmbed({
@@ -863,20 +1157,225 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
         embedWidget,
       )
     : col(buttonRow, spacer(0), embedWidget);
-  // Surface BASE in the preview section label so it's always visible
-  // (the list-row badge gets truncated at 25% column width). The
-  // base session is the editor process itself — closing or moving
-  // its worktree would close the editor / break the user's current
-  // tree, so Stop / Archive / Delete refuse against it.
-  const sectionLabel = isBase
-    ? `[${s.id}] ${s.label}  BASE — editor session`
-    : `[${s.id}] ${s.label}`;
+  // Surface the launch session in the preview label so it's always
+  // visible (the list-row badge gets truncated at 25% column width).
+  // It's the dir the editor was started in — informational only; it's
+  // deletable like any other session once another window exists.
+  const sectionLabel = s.id === 1
+    ? `${s.label}  —  launch session`
+    : s.label;
   return labeledSection({
     label: sectionLabel,
     child: body,
   });
 }
 
+// The per-action bullet lines shown in the confirmation panel.
+// `delete` adds a separate red "uncommitted changes" line in the
+// caller because it needs distinct styling.
+function confirmActionLines(action: BulkAction): string[] {
+  switch (action) {
+    case "stop":
+      return [
+        "  • send SIGTERM to all session processes",
+        "  • SIGKILL after a short grace period",
+        "",
+        "The worktree and session record remain.",
+      ];
+    case "archive":
+      return [
+        "  • SIGKILL all session processes",
+        "  • close the editor session",
+        "  • move the worktree to .archived/",
+        "",
+        "Reversible via Unarchive.",
+      ];
+    case "delete":
+      return [
+        "  • stop all session processes",
+        "  • run `git worktree remove`",
+        "  • drop the session record",
+      ];
+  }
+}
+
+// Confirmation panel for a Stop/Archive/Delete over one or many
+// sessions. A single id renders the familiar per-session prompt; two
+// or more render a batch prompt that lists the targets. The Confirm
+// button reuses the same `confirm-<action>` key the single path
+// always used, so the existing widget_event handlers fire for both —
+// they read `pendingConfirm.ids`.
+function buildConfirmPane(
+  confirm: { action: BulkAction; ids: number[] },
+): WidgetSpec {
+  const { action, ids } = confirm;
+  const cap = action[0].toUpperCase() + action.slice(1);
+  const existing = ids.filter((id) => orchestratorSessions.has(id));
+  const bulk = existing.length > 1;
+  const diskNote = (id: number): string =>
+    orchestratorSessions.get(id)?.discovered ? "  · on-disk" : "";
+  const entries: TextPropertyEntry[] = [];
+  if (bulk) {
+    entries.push(
+      styledRow([
+        { text: `${cap} these ${existing.length} sessions?`, style: { bold: true } },
+      ]),
+      styledRow([{ text: "" }]),
+    );
+    for (const id of existing.slice(0, 8)) {
+      const ss = orchestratorSessions.get(id)!;
+      entries.push(
+        styledRow([
+          { text: `  ${ss.label}` },
+          { text: diskNote(id), style: { fg: "ui.menu_disabled_fg", italic: true } },
+        ]),
+      );
+    }
+    if (existing.length > 8) {
+      entries.push(
+        styledRow([
+          {
+            text: `  … and ${existing.length - 8} more`,
+            style: { fg: "ui.menu_disabled_fg", italic: true },
+          },
+        ]),
+      );
+    }
+  } else {
+    const id = existing[0];
+    const ss = id !== undefined ? orchestratorSessions.get(id) : undefined;
+    entries.push(
+      styledRow([
+        { text: `${cap} session ${ss?.label ?? ""}?`, style: { bold: true } },
+      ]),
+    );
+  }
+  entries.push(
+    styledRow([{ text: "" }]),
+    styledRow([{ text: bulk ? "For each session this will:" : "This will:" }]),
+  );
+  for (const line of confirmActionLines(action)) {
+    entries.push(styledRow([{ text: line }]));
+  }
+  if (action === "delete") {
+    entries.push(
+      styledRow([{ text: "" }]),
+      styledRow([
+        {
+          text: "Uncommitted changes will be lost.",
+          style: { fg: "ui.status_error_indicator_fg", bold: true },
+        },
+      ]),
+    );
+  }
+  return labeledSection({
+    label: bulk ? `Confirm ${cap} — ${existing.length} sessions` : `Confirm ${cap}`,
+    child: col(
+      { kind: "raw", entries },
+      spacer(0),
+      row(
+        flexSpacer(),
+        button("Cancel", { key: "confirm-cancel" }),
+        spacer(2),
+        button(`Confirm ${cap}`, { intent: "danger", key: `confirm-${action}` }),
+      ),
+    ),
+  });
+}
+
+// The dedicated bulk selection bar (Layout B). Shown in place of the
+// per-session preview when two or more rows are checked. The bulk
+// action buttons sit at the *top* of the pane; the list of affected
+// sessions renders below as a scrollable `list` widget (so a long
+// selection scrolls — keyboard, wheel, and the draggable scrollbar —
+// rather than overflowing the pane). Each action's count is the
+// number of *eligible* members; an action with no eligible members is
+// disabled.
+function buildBulkPane(): WidgetSpec {
+  const sel = selectedSessions();
+  const stopN = eligibleSelected("stop").length;
+  const archiveN = eligibleSelected("archive").length;
+  const deleteN = eligibleSelected("delete").length;
+
+  const inflight = openDialog?.bulkInFlight ?? null;
+  const actionRow = inflight
+    ? row(
+        {
+          kind: "raw",
+          entries: [
+            styledRow([
+              {
+                text: `${inflight.action[0].toUpperCase()}${inflight.action.slice(1)}ing ${inflight.done}/${inflight.total}…`,
+                style: { fg: "ui.menu_disabled_fg", italic: true },
+              },
+            ]),
+          ],
+        },
+        flexSpacer(),
+      )
+    : row(
+        button(`Stop (${stopN})`, { key: "bulk-stop", disabled: stopN === 0 }),
+        spacer(2),
+        button(`Archive (${archiveN})`, {
+          key: "bulk-archive",
+          disabled: archiveN === 0,
+        }),
+        spacer(2),
+        button(`Delete (${deleteN})`, {
+          intent: "danger",
+          key: "bulk-delete",
+          disabled: deleteN === 0,
+        }),
+        flexSpacer(),
+        button("Clear", { key: "bulk-clear" }),
+      );
+
+  // Affected-sessions list. Flag the rows a destructive action will
+  // skip so the count discrepancy explains itself.
+  const items: TextPropertyEntry[] = sel.map((id) => {
+    const ss = orchestratorSessions.get(id)!;
+    const rowParts: StyledSegment[] = [{ text: `  ${ss.label}` }];
+    if (!ss.discovered && !ownsWorktree(ss)) {
+      rowParts.push({
+        text: "  · in-place (forgotten, not removed)",
+        style: { fg: "ui.menu_disabled_fg", italic: true },
+      });
+    } else if (ss.discovered) {
+      rowParts.push({
+        text: "  · on-disk worktree",
+        style: { fg: "ui.menu_disabled_fg", italic: true },
+      });
+    }
+    return styledRow(rowParts);
+  });
+  const itemKeys = sel.map((id) => `bulksel-${id}`);
+  // Match the preview pane's height: content = action row (1) +
+  // spacer (1) + list, and the embed pane reserves `listVisibleRows
+  // + 4` for its body — so the list takes that height and the two
+  // panes' bottom borders line up.
+  const listRows = Math.max(3, (openDialog?.listVisibleRows ?? MIN_LIST_ROWS) + 4);
+
+  return labeledSection({
+    label: `Bulk actions — ${sel.length} selected`,
+    child: col(
+      actionRow,
+      spacer(0),
+      list({
+        items,
+        itemKeys,
+        // Display-only: no highlighted row, and out of the Tab cycle
+        // (focus belongs on the action buttons). Up/Down still scroll
+        // it via the host's smart-key forwarding, and the scrollbar
+        // drags it.
+        selectedIndex: -1,
+        visibleRows: listRows,
+        focusable: false,
+        key: "bulk-list",
+      }),
+    ),
+  });
+}
+
 function buildOpenSpec(): WidgetSpec {
   if (!openDialog) return col();
   const filtered = openDialog.filteredIds;
@@ -890,9 +1389,11 @@ function buildOpenSpec(): WidgetSpec {
   const selIdx = filtered.length === 0
     ? -1
     : Math.max(0, Math.min(openDialog.selectedIndex, filtered.length - 1));
-  const selectedId = selIdx >= 0 ? filtered[selIdx] : -1;
-  const selectedSession = selectedId > 0
-    ? orchestratorSessions.get(selectedId)
+  // Gate on the *index* (selIdx < 0 means "filter matched nothing"),
+  // not the sign of the id: discovered worktrees carry negative ids
+  // and must still resolve to their row here.
+  const selectedSession = selIdx >= 0
+    ? orchestratorSessions.get(filtered[selIdx])
     : undefined;
 
   // The "New Session" button advertises Alt+N (or whatever the
@@ -974,6 +1475,43 @@ function buildOpenSpec(): WidgetSpec {
     scopeButton,
     flexSpacer(),
   );
+  // Per-project filter checkbox, on its own row under the Project
+  // control: opt-in toggle that surfaces the discovered on-disk
+  // worktree rows. A `toggle` (single `[ ]`/`[v]` — no double
+  // bracket) that's clickable and bound to Alt+T
+  // (`orchestrator_toggle_worktrees`, rebindable). The label carries
+  // the live keybinding hint, mirroring the Project control's
+  // "(Alt+P)". Inert while a confirm prompt is up.
+  const worktreeKey = editor.getKeybindingLabel(
+    "orchestrator_toggle_worktrees",
+    OPEN_MODE,
+  );
+  const worktreeLabel = worktreeKey
+    ? `Show all worktrees   (${worktreeKey})`
+    : "Show all worktrees";
+  const worktreeFilterRow = row(
+    toggle(openDialog.showWorktrees, worktreeLabel, {
+      key: openDialog.pendingConfirm !== null ? undefined : "worktree-show",
+    }),
+    flexSpacer(),
+  );
+  // Content filter checkbox, beneath the worktree one. The flag is
+  // `hideTrivial`, but the checkbox reads as an opt-in "show" toggle to
+  // match the worktree row: unchecked (default) hides the empty /
+  // single-file shells, checking it reveals them. Inert during confirm.
+  const trivialKey = editor.getKeybindingLabel(
+    "orchestrator_toggle_trivial",
+    OPEN_MODE,
+  );
+  const trivialLabel = trivialKey
+    ? `Show empty/1-file sessions   (${trivialKey})`
+    : "Show empty/1-file sessions";
+  const trivialFilterRow = row(
+    toggle(!openDialog.hideTrivial, trivialLabel, {
+      key: openDialog.pendingConfirm !== null ? undefined : "hide-trivial",
+    }),
+    flexSpacer(),
+  );
 
   return col(
     {
@@ -1028,6 +1566,8 @@ function buildOpenSpec(): WidgetSpec {
             flexSpacer(),
           ),
           projectControlRow,
+          worktreeFilterRow,
+          trivialFilterRow,
           filterInput,
           sessionsSeparator(),
           sessionsColumnHeader(),
@@ -1067,6 +1607,11 @@ function buildOpenSpec(): WidgetSpec {
       hintBar([
         { keys: "↑↓", label: "nav" },
         { keys: "Enter", label: "dive" },
+        {
+          keys: editor.getKeybindingLabel("orchestrator_toggle_select", OPEN_MODE) ||
+            "Space",
+          label: "select",
+        },
         {
           keys: scopeKey || "⌥P",
           label: scope === "current" ? "all projects" : "current only",
@@ -1127,6 +1672,7 @@ function clearDialogError(): void {
 
 function refreshOpenDialog(): void {
   if (!openPanel || !openDialog) return;
+  pruneSelection();
   openDialog.filteredIds = filterSessions(openDialog.filter.value);
   // Clamp the selection into range so a fresh filter or a
   // session vanishing under us doesn't leave us pointing past
@@ -1149,6 +1695,9 @@ function refreshOpenDialog(): void {
 function openControlRoom(): void {
   if (openPanel) return;
   reconcileSessions();
+  // Summarise on-disk session content up front so the trivial filter
+  // has data on the first render.
+  scanSessionContent();
   const activeId = editor.activeWindow();
   // Seed with the screen-max; buildOpenSpec refits to the session
   // count on the first render (and every render after).
@@ -1167,6 +1716,10 @@ function openControlRoom(): void {
     // Restore the last-used scope (defaults to "all"); the Project
     // control / Alt+P updates it for next time.
     scope: lastOpenScope,
+    selectedIds: new Set<number>(),
+    showWorktrees: lastShowWorktrees,
+    hideTrivial: lastHideTrivial,
+    bulkInFlight: null,
   };
   openDialog.filteredIds = filterSessions("");
   const activeIdx = openDialog.filteredIds.indexOf(activeId);
@@ -1188,6 +1741,12 @@ function openControlRoom(): void {
   // safe — there's nothing to act on then anyway.
   openPanel.setFocusKey("visit");
   editor.setEditorMode(OPEN_MODE);
+
+  // Discover worktrees that exist on disk but aren't open yet and
+  // fold them into the list. Async (it shells out to git per
+  // project); the dialog renders immediately with live sessions and
+  // gains the discovered rows when the scan lands.
+  void refreshDiscoveredWorktrees();
 }
 
 function closeOpenDialog(): void {
@@ -1199,33 +1758,27 @@ function closeOpenDialog(): void {
   editor.setEditorMode(null);
 }
 
-// Stop every process the highlighted session owns. Sends
-// SIGTERM first via the host's `signalWindow` (which fans
-// out through the window's process-group tracker), then
-// follows up with SIGKILL after a short grace period so
-// ill-behaved agents that ignore SIGTERM still get reaped.
-// The session record stays put — Stop only kills processes,
-// it doesn't touch the worktree or the editor session.
-function stopSelectedSession(): void {
-  if (!openDialog) return;
-  const id = openDialog.filteredIds[openDialog.selectedIndex];
-  if (typeof id !== "number" || id <= 0) return;
-  if (id === 1) {
-    setDialogError("cannot stop the base session");
-    refreshOpenDialog();
-    return;
-  }
+// Stop every process one session owns. Sends SIGTERM first via the
+// host's `signalWindow` (which fans out through the window's
+// process-group tracker), then follows up with SIGKILL after a short
+// grace period so ill-behaved agents that ignore SIGTERM still get
+// reaped. The session record stays put — Stop only kills processes,
+// it doesn't touch the worktree or the editor session. Returns false
+// for ids it can't stop (base session, discovered worktrees with no
+// live window).
+function stopOne(id: number): boolean {
+  const s = orchestratorSessions.get(id);
+  if (!s || id <= 0 || s.discovered || !s.terminalId) return false;
   editor.signalWindow(id, "SIGTERM");
-  // SIGKILL fallback for agents that ignore SIGTERM. The
-  // host's signalWindow is idempotent on already-exited
-  // process groups, so the second call is safe whether or
-  // not the first one took. QuickJS has no `setTimeout`;
-  // the host exposes `editor.delay(ms)` as the asynchronous
+  // SIGKILL fallback for agents that ignore SIGTERM. The host's
+  // signalWindow is idempotent on already-exited process groups, so
+  // the second call is safe whether or not the first one took.
+  // QuickJS has no `setTimeout`; `editor.delay(ms)` is the async
   // sleep primitive, which we kick off but don't await.
   void editor.delay(2000).then(() => {
     editor.signalWindow(id, "SIGKILL");
   });
-  editor.setStatus(`Orchestrator: stop signal sent to session [${id}]`);
+  return true;
 }
 
 // ---------------------------------------------------------------------
@@ -1305,139 +1858,124 @@ function pickNextActiveSession(excludeId: number): number {
   for (const sid of orchestratorSessions.keys()) {
     if (sid !== excludeId && sid > 0) return sid;
   }
-  return 1;
+  // No other live window. Callers guard against closing the last
+  // window before reaching here, so this is a safe no-op swap (id 1
+  // is no longer guaranteed to exist — it's deletable like any other).
+  return excludeId;
 }
 
-// Archive flow: stop all processes (SIGKILL — archive is a
-// "I'm done with this for now" action, no graceful teardown
-// needed since the worktree stays on disk), close the editor
-// session, move the worktree to the `.archived/` graveyard,
-// and append a manifest entry so a future Unarchive flow can
-// reverse it.
-async function archiveSelectedSession(explicitId?: number): Promise<void> {
-  if (!openDialog) return;
-  // Prefer the explicit id from the confirm path. Otherwise read
-  // the currently selected row — used by the legacy direct-call
-  // entry points. Once the row is hidden synchronously after
-  // confirm, `filteredIds[selectedIndex]` no longer points at the
-  // session being archived (it shifts to whatever is now under
-  // the cursor).
-  const id = typeof explicitId === "number"
-    ? explicitId
-    : openDialog.filteredIds[openDialog.selectedIndex];
-  // Clear the in-flight marker so the preview pane stops showing
-  // "Archiving…" if the operation refuses or fails. After
-  // `closeWindow` succeeds the row is gone from `listWindows()`
-  // anyway, so clearing then is harmless.
-  const clearInFlight = () => {
-    if (
-      openDialog?.inFlight && typeof id === "number" &&
-      openDialog.inFlight.sessionId === id
-    ) {
-      openDialog.inFlight = null;
-      refreshOpenDialog();
-    }
-  };
-  if (typeof id !== "number" || id <= 0) return;
-  if (id === 1) {
-    setDialogError("cannot archive the base session");
-    clearInFlight();
-    return;
-  }
-  // close_window refuses to close the active window; swap to a
-  // different session first. The pick prefers something already
-  // in the dialog's current filter, falls back to the base
-  // session — both always exist (base is undeletable, and we'd
-  // have nothing to archive without at least one session).
-  if (id === editor.activeWindow()) {
-    editor.setActiveWindow(pickNextActiveSession(id));
-  }
-  const session = orchestratorSessions.get(id);
-  if (!session) {
-    clearInFlight();
-    return;
+// Number of real editor windows. Discovered on-disk rows have negative
+// ids and are not windows. The editor must always host at least one
+// window, so deleting/archiving the last live window is refused.
+function liveWindowCount(): number {
+  let n = 0;
+  for (const s of orchestratorSessions.values()) {
+    if (s.id > 0) n += 1;
   }
+  return n;
+}
 
-  // Resolve the repo root from cwd (the user is in the
-  // umbrella session's tree).
-  const cwd = editor.getCwd();
-  const top = await spawnCollect(
-    "git",
-    ["rev-parse", "--show-toplevel"],
-    cwd,
-  );
-  if (top.exit_code !== 0) {
-    editor.setStatus("Orchestrator: archive failed — not a git repository");
-    clearInFlight();
-    return;
+// Resolve the *main* repo root a session's worktree belongs to, so
+// `git worktree move/remove` runs from a stable directory (never from
+// inside the tree being moved/removed). Prefers the canonical
+// `projectPath` recorded at create/discovery time, falling back to
+// resolving from the worktree itself.
+async function worktreeRepoRoot(s: AgentSession): Promise<string | null> {
+  if (s.projectPath) {
+    const r = await resolveCanonicalRepoRoot(s.projectPath);
+    if (r) return r;
   }
-  const repoRoot = (top.stdout || "").trim();
+  return await resolveCanonicalRepoRoot(s.root);
+}
 
-  // SIGKILL the session's process group so the pty children
-  // release any locks on the worktree, then close the editor
-  // session. closeWindow already kills the pty via the child
-  // killer; signaling first via the window-level pg tracker
-  // catches stray subprocesses outside the pty.
-  editor.signalWindow(id, "SIGKILL");
-  editor.closeWindow(id);
+interface LifecycleResult {
+  ok: boolean;
+  err?: string;
+  repoRoot?: string;
+}
 
-  // Brief settle so the filesystem reflects the pty's exit
-  // before we move the worktree out from under it.
-  await editor.delay(250);
+// Archive a single session: SIGKILL its processes (archive is a
+// "done with this for now" action — no graceful teardown needed since
+// the worktree stays on disk), close the editor session, move the
+// worktree to the `.archived/` graveyard, and append a manifest
+// entry so Unarchive can reverse it. Handles both live sessions and
+// discovered on-disk worktrees (the latter have no window to close).
+// Does NOT trigger sync — the caller batches one sync per repo after
+// the whole run.
+async function archiveOne(id: number): Promise<LifecycleResult> {
+  const s = orchestratorSessions.get(id);
+  if (!s) return { ok: false, err: "session gone" };
+  // Archive moves the worktree to the graveyard — only sessions that
+  // own one can be archived. A launch/in-place session has no separate
+  // worktree, so there's nothing to move; use Delete to forget it.
+  if (!ownsWorktree(s)) {
+    return { ok: false, err: "no worktree to archive — use Delete to forget this session" };
+  }
+  // The editor must keep at least one window; closing the last one
+  // would orphan the move. Refuse before touching the worktree.
+  if (s.id > 0 && liveWindowCount() <= 1) {
+    return { ok: false, err: "cannot archive the last window — open another session first" };
+  }
+  const repoRoot = await worktreeRepoRoot(s);
+  if (!repoRoot) return { ok: false, err: "not a git repository" };
+
+  // Live session: close_window refuses to close the active window, so
+  // switch away first, then SIGKILL the process group (so pty
+  // children release worktree locks) and close the editor session.
+  if (!s.discovered && id > 0) {
+    if (id === editor.activeWindow()) {
+      editor.setActiveWindow(pickNextActiveSession(id));
+    }
+    if (s.terminalId) editor.signalWindow(id, "SIGKILL");
+    editor.closeWindow(id);
+    // Brief settle so the filesystem reflects the pty's exit before
+    // we move the worktree out from under it.
+    await editor.delay(250);
+  }
 
-  // git worktree move keeps git's internal bookkeeping
-  // consistent (the new path stays registered as a worktree).
   const archivedRoot = editor.pathJoin(
     editor.getDataDir(),
     "orchestrator",
     slugify(repoRoot),
     ".archived",
-    session.label,
+    s.label,
   );
   const parent = editor.pathDirname(archivedRoot);
   if (!editor.createDir(parent)) {
-    editor.setStatus(
-      `Orchestrator: archive failed — could not create ${parent}`,
-    );
-    clearInFlight();
-    return;
+    return { ok: false, err: `could not create ${parent}`, repoRoot };
   }
+  // git worktree move keeps git's internal bookkeeping consistent
+  // (the new path stays registered as a worktree).
   const moveRes = await spawnCollect(
     "git",
-    ["-C", repoRoot, "worktree", "move", session.root, archivedRoot],
+    ["-C", repoRoot, "worktree", "move", s.root, archivedRoot],
     repoRoot,
   );
   if (moveRes.exit_code !== 0) {
-    editor.setStatus(
-      `Orchestrator: worktree move failed: ${
-        lastNonEmptyLine(moveRes.stderr) || "unknown error"
-      }`,
-    );
-    clearInFlight();
-    return;
+    return {
+      ok: false,
+      err: lastNonEmptyLine(moveRes.stderr) || "worktree move failed",
+      repoRoot,
+    };
   }
 
-  // Append manifest entry. The branch info is best-effort:
-  // we assume Orchestrator's convention of branch==label (set in
-  // the new-session form) until a session knows its branch
-  // separately.
   const manifest = loadArchiveManifest(repoRoot);
   manifest.sessions.push({
-    label: session.label,
+    label: s.label,
     root: archivedRoot,
-    original_root: session.root,
-    branch: session.label,
+    original_root: s.root,
+    branch: s.branch || s.label,
     archived_at: new Date().toISOString(),
   });
-  if (!saveArchiveManifest(repoRoot, manifest)) {
-    editor.setStatus(
-      "Orchestrator: archived, but failed to write archived.json",
-    );
-  } else {
-    editor.setStatus(`Orchestrator: archived [${id}] ${session.label}`);
+  saveArchiveManifest(repoRoot, manifest);
+
+  // A discovered row has no window_closed hook to drop it — remove it
+  // from the model directly.
+  if (s.discovered) {
+    orchestratorSessions.delete(id);
+    discoveredIdByPath.delete(s.root);
   }
-  clearInFlight();
-  triggerSyncAsync(repoRoot);
+  return { ok: true, repoRoot };
 }
 
 // ---------------------------------------------------------------------
@@ -1640,86 +2178,149 @@ async function buildSyncSnapshot(repoRoot: string): Promise<unknown> {
   };
 }
 
-// Delete flow: stop processes (SIGKILL), close the editor
-// session, then `git worktree remove --force` to drop the
-// worktree from disk. If the session was archived (manifest
-// entry exists), the manifest entry is dropped too. No
-// recovery after this point.
-async function deleteConfirmedSession(): Promise<void> {
-  if (!openDialog || !openDialog.pendingConfirm) return;
-  const { sessionId: id } = openDialog.pendingConfirm;
-  openDialog.pendingConfirm = null;
-  // Clear the in-flight marker on early failure. Mirrors the
-  // pattern in `archiveSelectedSession` — the confirm-delete
-  // handler set `inFlight` before kicking off this async work,
-  // and any path that aborts before `closeWindow` needs to undo
-  // it so the "Deleting…" overlay disappears.
-  const clearInFlight = () => {
-    if (openDialog?.inFlight && openDialog.inFlight.sessionId === id) {
-      openDialog.inFlight = null;
-      refreshOpenDialog();
+// Delete a single session: close the editor session, then — only when
+// the session owns a worktree — `git worktree remove --force` to drop
+// it from disk (and prune any archive-manifest entry). A launch or
+// in-place session owns no worktree, so Delete just forgets it: the
+// window closes and the directory is left untouched (a fresh session
+// can always be opened there again). Handles discovered on-disk
+// worktrees (no window to close). Does NOT trigger sync — the caller
+// batches it.
+async function deleteOne(id: number): Promise<LifecycleResult> {
+  const s = orchestratorSessions.get(id);
+  if (!s) return { ok: false, err: "session gone" };
+  // The editor must keep at least one window. Refuse before any
+  // close/worktree-removal so a removable session can't `git worktree
+  // remove` the tree the live editor is still sitting in.
+  if (s.id > 0 && liveWindowCount() <= 1) {
+    return { ok: false, err: "cannot delete the last window — open another session first" };
+  }
+  const removable = ownsWorktree(s);
+
+  if (!s.discovered && id > 0) {
+    // close_window refuses to close the active (and the last) window,
+    // so swap away first. SIGKILL only when there's an agent terminal —
+    // a launch/in-place session has none, and signalling it must never
+    // touch the editor itself.
+    if (id === editor.activeWindow()) {
+      editor.setActiveWindow(pickNextActiveSession(id));
     }
-  };
-  const session = orchestratorSessions.get(id);
-  if (!session) {
-    clearInFlight();
-    return;
+    if (s.terminalId) editor.signalWindow(id, "SIGKILL");
+    editor.closeWindow(id);
+    if (removable) await editor.delay(250);
   }
-  // Same auto-switch as archive — close_window refuses to close
-  // the active window, so swap to a different session first.
-  if (id === editor.activeWindow()) {
-    editor.setActiveWindow(pickNextActiveSession(id));
+
+  let repoRoot: string | undefined;
+  if (removable) {
+    const rr = await worktreeRepoRoot(s);
+    if (!rr) return { ok: false, err: "not a git repository" };
+    repoRoot = rr;
+    // `--force` because the worktree may have unstaged changes the user
+    // explicitly chose to discard via the confirm step.
+    const removeRes = await spawnCollect(
+      "git",
+      ["-C", rr, "worktree", "remove", "--force", s.root],
+      rr,
+    );
+    if (removeRes.exit_code !== 0) {
+      return {
+        ok: false,
+        err: lastNonEmptyLine(removeRes.stderr) || "worktree remove failed",
+        repoRoot,
+      };
+    }
+
+    // Drop the matching manifest entry too, in case the session was
+    // already archived (delete-from-archived drops dormant sessions).
+    const manifest = loadArchiveManifest(rr);
+    const before = manifest.sessions.length;
+    manifest.sessions = manifest.sessions.filter((e) => e.label !== s.label);
+    if (manifest.sessions.length !== before) {
+      saveArchiveManifest(rr, manifest);
+    }
   }
 
-  const cwd = editor.getCwd();
-  const top = await spawnCollect(
-    "git",
-    ["rev-parse", "--show-toplevel"],
-    cwd,
-  );
-  if (top.exit_code !== 0) {
-    editor.setStatus("Orchestrator: delete failed — not a git repository");
-    clearInFlight();
-    return;
+  if (s.discovered) {
+    orchestratorSessions.delete(id);
+    discoveredIdByPath.delete(s.root);
   }
-  const repoRoot = (top.stdout || "").trim();
+  return { ok: true, repoRoot };
+}
 
-  editor.signalWindow(id, "SIGKILL");
-  editor.closeWindow(id);
-  await editor.delay(250);
+// Unified runner for a confirmed Stop / Archive / Delete over one or
+// many ids. Re-filters to eligible targets at execution time (the
+// selection or single row may have gone stale between confirm and
+// run), drives the in-flight progress markers, runs the per-id cores
+// sequentially, prunes acted-on ids from the selection, and triggers
+// one sync per touched repo at the end.
+async function runConfirmedAction(
+  action: BulkAction,
+  ids: number[],
+): Promise<void> {
+  if (!openDialog) return;
+  const targets = ids.filter((id) => bulkEligible(action, id));
+  if (targets.length === 0) {
+    setDialogError(`nothing eligible to ${action} in the selection`);
+    refreshOpenDialog();
+    return;
+  }
 
-  // `--force` because the worktree may have unstaged changes
-  // the user explicitly chose to discard via the confirm step.
-  const removeRes = await spawnCollect(
-    "git",
-    ["-C", repoRoot, "worktree", "remove", "--force", session.root],
-    repoRoot,
-  );
-  if (removeRes.exit_code !== 0) {
-    editor.setStatus(
-      `Orchestrator: worktree remove failed: ${
-        lastNonEmptyLine(removeRes.stderr) || "unknown error"
-      }`,
-    );
-    clearInFlight();
+  if (action === "stop") {
+    let n = 0;
+    for (const id of targets) if (stopOne(id)) n += 1;
+    editor.setStatus(`Orchestrator: stop signal sent to ${n} session(s)`);
+    // Stop leaves sessions in place; drop them from the selection so
+    // the bulk bar reflects that the action ran.
+    for (const id of targets) openDialog.selectedIds.delete(id);
+    refreshOpenDialog();
     return;
   }
 
-  // Drop the matching manifest entry too, in case the session
-  // was already archived (delete-from-archived is the natural
-  // way to drop dormant sessions).
-  const manifest = loadArchiveManifest(repoRoot);
-  const before = manifest.sessions.length;
-  manifest.sessions = manifest.sessions.filter(
-    (e) => e.label !== session.label,
-  );
-  if (manifest.sessions.length !== before) {
-    saveArchiveManifest(repoRoot, manifest);
+  const single = targets.length === 1;
+  if (single) {
+    openDialog.inFlight = { action, sessionId: targets[0] };
+  } else {
+    openDialog.bulkInFlight = { action, total: targets.length, done: 0 };
+  }
+  refreshOpenDialog();
+
+  const touchedRepos = new Set<string>();
+  let okCount = 0;
+  let lastErr = "";
+  for (let i = 0; i < targets.length; i++) {
+    const id = targets[i];
+    const res = action === "archive" ? await archiveOne(id) : await deleteOne(id);
+    if (res.ok) {
+      okCount += 1;
+      if (res.repoRoot) touchedRepos.add(res.repoRoot);
+    } else {
+      lastErr = res.err ?? "failed";
+    }
+    openDialog?.selectedIds.delete(id);
+    if (openDialog?.bulkInFlight) openDialog.bulkInFlight.done = i + 1;
+    refreshOpenDialog();
+  }
+  if (openDialog) {
+    openDialog.inFlight = null;
+    openDialog.bulkInFlight = null;
   }
 
-  editor.setStatus(`Orchestrator: deleted [${id}] ${session.label}`);
-  clearInFlight();
-  triggerSyncAsync(repoRoot);
+  const verb = action === "archive" ? "archived" : "deleted";
+  if (okCount === 0) {
+    setDialogError(`${action} failed: ${lastErr || "unknown error"}`);
+  } else if (lastErr) {
+    setDialogError(`${verb} ${okCount}/${targets.length}; last error: ${lastErr}`);
+  } else {
+    editor.setStatus(`Orchestrator: ${verb} ${okCount} session(s)`);
+  }
+  for (const repo of touchedRepos) triggerSyncAsync(repo);
+  refreshOpenDialog();
+  // The batch emptied the selection, so the pane is back in
+  // single-preview mode — restore focus to Visit (the bulk buttons
+  // it may have been on are gone).
+  if (openPanel && selectedSessions().length < 2 && !openDialog.pendingConfirm) {
+    openPanel.setFocusKey("visit");
+  }
 }
 
 // `Alt+N` from inside the picker opens the new-session form — saves
@@ -1742,6 +2343,25 @@ editor.defineMode(
     // text; session names don't contain `/`, so that's an
     // acceptable trade for the quick-focus.)
     ["/", "orchestrator_focus_filter"],
+    // Space toggles the highlighted row's membership in the bulk
+    // selection. Bound as a mode chord (not a widget smart-key) so
+    // it's user-rebindable in the keybinding editor and fires
+    // regardless of which control holds focus — the host's
+    // `dispatch_floating_widget_key` defers any explicitly-bound
+    // mode key, including bare chars, before the text-input path.
+    // The trade (same as `/`) is that Space can't be typed into the
+    // filter while the picker is open; session names don't contain
+    // spaces, so that's acceptable.
+    ["Space", "orchestrator_toggle_select"],
+    // Alt+T toggles "Show all worktrees" — the opt-in filter that
+    // surfaces discovered on-disk worktree rows. Rebindable, same as
+    // the scope toggle.
+    ["M-t", "orchestrator_toggle_worktrees"],
+    // Alt+I toggles "Show empty/1-file sessions" — reveals the trivial
+    // restored shells hidden by default. Rebindable, same as the others.
+    // (Alt+E is unavailable: it's the Edit menu's mnemonic, which the
+    // menu bar claims before the picker's mode keymap sees it.)
+    ["M-i", "orchestrator_toggle_trivial"],
   ],
   true,
   true,
@@ -1758,6 +2378,38 @@ registerHandler("orchestrator_focus_filter", () => {
   openPanel.setFocusKey("filter");
 });
 
+// Space (rebindable): toggle the highlighted row in/out of the bulk
+// selection. Manages focus across the single↔bulk transition: when
+// the second row is checked the preview pane swaps to the bulk bar
+// (so the now-absent "visit" focus would otherwise be clamped to a
+// random tabbable), and when the selection drops back below two the
+// per-session preview — with its "visit" button — returns.
+registerHandler("orchestrator_toggle_select", () => {
+  if (!openDialog || !openPanel) return;
+  // Inert while a confirm prompt is up — the selection is frozen
+  // behind the confirmation panel.
+  if (openDialog.pendingConfirm) return;
+  const id = openDialog.filteredIds[openDialog.selectedIndex];
+  if (typeof id !== "number") return;
+  const wasBulk = selectedSessions().length >= 2;
+  if (openDialog.selectedIds.has(id)) {
+    openDialog.selectedIds.delete(id);
+  } else {
+    openDialog.selectedIds.add(id);
+  }
+  clearDialogError();
+  refreshOpenDialog();
+  const isBulk = selectedSessions().length >= 2;
+  if (!wasBulk && isBulk) {
+    // Entering bulk mode — land focus on a bulk button (Up/Down from
+    // a button still drives the list, so navigation keeps working).
+    openPanel.setFocusKey("bulk-archive");
+  } else if (wasBulk && !isBulk) {
+    // Back to single preview — restore focus to Visit.
+    openPanel.setFocusKey("visit");
+  }
+});
+
 function toggleScope(): void {
   if (!openDialog) return;
   openDialog.scope = openDialog.scope === "current" ? "all" : "current";
@@ -1776,6 +2428,55 @@ function toggleScope(): void {
 
 registerHandler("orchestrator_toggle_scope", toggleScope);
 
+// Flip "Show all worktrees" — reveal/hide the discovered on-disk
+// worktree rows. Preserves the highlighted row across the re-filter
+// where possible; drops now-hidden discovered rows from the bulk
+// selection. Shared by the Alt+T chord and the checkbox click.
+function toggleShowWorktrees(): void {
+  if (!openDialog) return;
+  openDialog.showWorktrees = !openDialog.showWorktrees;
+  lastShowWorktrees = openDialog.showWorktrees;
+  // Hiding worktrees shouldn't leave them lingering in the selection.
+  if (!openDialog.showWorktrees) {
+    for (const id of [...openDialog.selectedIds]) {
+      if (orchestratorSessions.get(id)?.discovered) {
+        openDialog.selectedIds.delete(id);
+      }
+    }
+  }
+  const prevId = openDialog.filteredIds[openDialog.selectedIndex];
+  openDialog.filteredIds = filterSessions(openDialog.filter.value);
+  const nextIdx = prevId !== undefined ? openDialog.filteredIds.indexOf(prevId) : -1;
+  openDialog.selectedIndex = nextIdx >= 0 ? nextIdx : 0;
+  refreshOpenDialog();
+}
+
+registerHandler("orchestrator_toggle_worktrees", toggleShowWorktrees);
+
+// Flip "Show empty/1-file sessions" — reveal/hide the trivial restored
+// shells. Preserves the highlighted row across the re-filter where
+// possible; drops now-hidden rows from the bulk selection. Shared by the
+// Alt+I chord and the checkbox click.
+function toggleHideTrivial(): void {
+  if (!openDialog) return;
+  openDialog.hideTrivial = !openDialog.hideTrivial;
+  lastHideTrivial = openDialog.hideTrivial;
+  const prevId = openDialog.filteredIds[openDialog.selectedIndex];
+  openDialog.filteredIds = filterSessions(openDialog.filter.value);
+  // Hiding trivial rows shouldn't leave them lingering in the selection.
+  if (openDialog.hideTrivial) {
+    const visible = new Set(openDialog.filteredIds);
+    for (const id of [...openDialog.selectedIds]) {
+      if (!visible.has(id)) openDialog.selectedIds.delete(id);
+    }
+  }
+  const nextIdx = prevId !== undefined ? openDialog.filteredIds.indexOf(prevId) : -1;
+  openDialog.selectedIndex = nextIdx >= 0 ? nextIdx : 0;
+  refreshOpenDialog();
+}
+
+registerHandler("orchestrator_toggle_trivial", toggleHideTrivial);
+
 // =============================================================================
 // New-session floating form
 // =============================================================================
@@ -2078,6 +2779,130 @@ async function pathIsInsideGitWorkTree(
   return (res.stdout || "").trim() === "true";
 }
 
+// =============================================================================
+// Worktree classification & discovery
+//
+// Two distinct git facts drive the "attach to an existing worktree"
+// flows:
+//
+//   * `classifyWorktree(path)` answers "is this path a *linked*
+//     worktree, and if so what repo does it belong to?" — used by
+//     the new-session form to attach (rather than fork) when the
+//     user points Project Path at an existing worktree.
+//   * `listLinkedWorktrees(repoRoot)` enumerates every linked
+//     worktree of a repo (via `git worktree list --porcelain`) —
+//     used to surface on-disk worktrees in the Open dialog without
+//     the user adding them by hand.
+// =============================================================================
+
+interface WorktreeInfo {
+  // `git rev-parse --show-toplevel` for the path.
+  toplevel: string;
+  // Canonical main-worktree root (dirname of `--git-common-dir`).
+  // This is the repo the worktree belongs to, used as the
+  // session's `projectPath` so attached worktrees group under
+  // their repo in the picker.
+  mainRoot: string;
+  // `true` when the path is a *linked* worktree (its per-worktree
+  // git dir differs from the shared common dir), i.e. a tree
+  // created by `git worktree add` rather than the main checkout.
+  isLinked: boolean;
+  // Branch checked out there (`refs/heads/<name>` short form), or
+  // empty when detached.
+  branch: string;
+}
+
+/// Classify `path` as a git worktree. Returns `null` when `path`
+/// is not inside any git work tree (the caller then treats it as a
+/// plain directory / shared root).
+async function classifyWorktree(path: string): Promise<WorktreeInfo | null> {
+  if (!path) return null;
+  const top = await spawnCollect("git", ["-C", path, "rev-parse", "--show-toplevel"], path);
+  if (top.exit_code !== 0) return null;
+  const toplevel = (top.stdout || "").trim();
+  if (!toplevel) return null;
+
+  // The per-worktree git dir vs. the shared common dir: they are
+  // equal for the main worktree and differ for every linked
+  // worktree (`<common>/worktrees/<id>`). That difference is the
+  // canonical "is this a linked worktree?" test.
+  const [gitDir, commonDir] = await Promise.all([
+    spawnCollect("git", ["-C", toplevel, "rev-parse", "--path-format=absolute", "--git-dir"], toplevel),
+    spawnCollect(
+      "git",
+      ["-C", toplevel, "rev-parse", "--path-format=absolute", "--git-common-dir"],
+      toplevel,
+    ),
+  ]);
+  const gd = gitDir.exit_code === 0 ? (gitDir.stdout || "").trim() : "";
+  const cd = commonDir.exit_code === 0 ? (commonDir.stdout || "").trim() : "";
+  const isLinked = gd !== "" && cd !== "" && gd !== cd;
+  const mainRoot = cd ? editor.pathDirname(cd) : toplevel;
+
+  const head = await spawnCollect(
+    "git",
+    ["-C", toplevel, "rev-parse", "--abbrev-ref", "HEAD"],
+    toplevel,
+  );
+  let branch = head.exit_code === 0 ? (head.stdout || "").trim() : "";
+  if (branch === "HEAD") branch = ""; // detached
+
+  return { toplevel, mainRoot, isLinked, branch };
+}
+
+interface ParsedWorktree {
+  path: string;
+  branch: string;
+  detached: boolean;
+}
+
+/// Parse `git worktree list --porcelain` output. Blocks are
+/// separated by blank lines; the first block is the main worktree,
+/// the rest are linked. Each block has a `worktree <path>` line
+/// plus `branch refs/heads/<name>` or `detached`.
+function parseWorktreePorcelain(stdout: string): ParsedWorktree[] {
+  const out: ParsedWorktree[] = [];
+  let cur: ParsedWorktree | null = null;
+  for (const raw of (stdout || "").split(/\r?\n/)) {
+    const line = raw.trimEnd();
+    if (line.startsWith("worktree ")) {
+      if (cur) out.push(cur);
+      cur = { path: line.slice("worktree ".length), branch: "", detached: false };
+    } else if (cur && line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length);
+      cur.branch = ref.replace(/^refs\/heads\//, "");
+    } else if (cur && line === "detached") {
+      cur.detached = true;
+    } else if (line === "" && cur) {
+      out.push(cur);
+      cur = null;
+    }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+/// Enumerate the *linked* worktrees of `repoRoot` (excludes the
+/// main worktree, which is the repo's own checkout). Returns the
+/// parsed entries with the main-repo root resolved so callers can
+/// tag discovered sessions with the right `projectPath`.
+async function listLinkedWorktrees(
+  repoRoot: string,
+): Promise<{ mainRoot: string; worktrees: ParsedWorktree[] } | null> {
+  const res = await spawnCollect(
+    "git",
+    ["-C", repoRoot, "worktree", "list", "--porcelain"],
+    repoRoot,
+  );
+  if (res.exit_code !== 0) return null;
+  const all = parseWorktreePorcelain(res.stdout || "");
+  if (all.length === 0) return null;
+  // The first entry is always the main worktree.
+  const mainRoot = all[0].path;
+  const worktrees = all.slice(1);
+  return { mainRoot, worktrees };
+}
+
 async function nextAutoSessionName(
   repoRoot: string,
   options?: { persist?: boolean },
@@ -2164,9 +2989,11 @@ function buildFormSpec(): WidgetSpec {
   // inert when worktree creation is off.
   let branchPlaceholder: string;
   if (branchInert) {
-    branchPlaceholder = worktreeEnabled
-      ? "shared worktree — N/A"
-      : "no git — N/A";
+    branchPlaceholder = !worktreeEnabled
+      ? "no git — N/A"
+      : form.projectPathIsLinkedWorktree === true
+      ? "existing worktree — N/A"
+      : "shared worktree — N/A";
   } else if (!form.defaultBranch) {
     branchPlaceholder = "detecting default branch…";
   } else if (form.defaultBranchIsHeadFallback) {
@@ -2241,6 +3068,24 @@ function buildFormSpec(): WidgetSpec {
             ]),
           ],
         },
+    // Existing-worktree hint: when Project Path points at a linked
+    // worktree, explain what the (un)checked box now means so the
+    // attach behaviour isn't a silent surprise.
+    ...(form.projectPathIsLinkedWorktree === true
+      ? [{
+          kind: "raw" as const,
+          entries: [
+            styledRow([
+              {
+                text: form.createWorktree
+                  ? "  ↳ existing worktree here — uncheck to attach instead of forking a new one"
+                  : "  ↳ existing worktree — this session will attach to it",
+                style: { fg: "ui.help_key_fg", italic: true },
+              },
+            ]),
+          ],
+        }]
+      : []),
     // === Form body: labeled, full-width inputs. ==================
     // Labels are plain — the `▸` glyph used to be baked into all
     // three strings and stayed put regardless of focus, which was
@@ -2380,6 +3225,7 @@ function openForm(options?: { fromPicker?: boolean }): void {
     lastError: null,
     defaultProjectPath: "",
     projectPathIsGit: null,
+    projectPathIsLinkedWorktree: null,
     defaultSessionName: "",
     defaultBranch: "",
     defaultBranchIsHeadFallback: false,
@@ -2442,6 +3288,24 @@ async function probeProjectPathDefaults(): Promise<void> {
   if (!form || form.probeToken !== token) return;
   form.projectPathIsGit = isGit;
 
+  // (2b) Existing-linked-worktree detection. When the path is a
+  //      worktree created by `git worktree add` (not the repo's main
+  //      checkout), default the checkbox to *unchecked* so the
+  //      natural action is to attach to it. Only flip on the
+  //      detection transition so we don't fight a user who
+  //      deliberately re-checks "create a new worktree".
+  const wasLinked = form.projectPathIsLinkedWorktree;
+  if (isGit) {
+    const info = await classifyWorktree(effectivePath);
+    if (!form || form.probeToken !== token) return;
+    form.projectPathIsLinkedWorktree = info?.isLinked === true;
+  } else {
+    form.projectPathIsLinkedWorktree = false;
+  }
+  if (form.projectPathIsLinkedWorktree && wasLinked !== true) {
+    form.createWorktree = false;
+  }
+
   // (3) Default branch + session name probes only make sense on
   //     a git path. On non-git, leave both empty (the renderer
   //     surfaces a "no git — N/A" branch placeholder, and the
@@ -2861,14 +3725,28 @@ async function submitForm(): Promise<void> {
     editor.setGlobalState("orchestrator.last_cmd", cmd);
   }
 
+  // Attach-to-existing-worktree: when the user opted out of
+  // creating a worktree but pointed Project Path at an *existing
+  // linked worktree* (one created by `git worktree add`, possibly
+  // for a repo Fresh has never opened before), treat it as the
+  // dedicated worktree it is rather than a shared root. That means
+  // `shared_worktree = false` (so Archive / Delete can
+  // `git worktree move` / `remove` it) and a `project_path` of the
+  // owning repo so the session groups with its siblings. A path
+  // that's the repo's *main* worktree, or a non-git directory, stays
+  // shared — you can't `git worktree remove` either of those.
+  const attachInfo = !createWorktree ? await classifyWorktree(root) : null;
+  if (!form) return;
+  const isLinkedAttach = attachInfo?.isLinked === true;
+  const effectiveProjectPath = isLinkedAttach ? attachInfo!.mainRoot : projectPath;
+
   // Branch / cmd values used for the per-window state record —
-  // `branchName` only exists in the worktree-create flow above;
-  // for the shared-worktree / non-git case we report whatever's
-  // currently checked out (best-effort) so the new session record
-  // matches the situation on disk.
+  // `branchName` only exists in the worktree-create flow above; for
+  // an attached linked worktree we report its checked-out branch;
+  // for the shared-worktree / non-git case we leave it blank.
   const reportedBranch = createWorktree
     ? (branchInput || sessionName)
-    : "";
+    : (isLinkedAttach ? attachInfo!.branch : "");
 
   // Append the user-effective values to per-field input
   // history so ↑/↓ can recall them on the next form open.
@@ -2886,7 +3764,9 @@ async function submitForm(): Promise<void> {
   // terminal IS the new window's seed buffer, so the window is
   // born with a single tab.
   const argv = splitAgentCmd(cmd);
-  const sharedWorktree = !createWorktree;
+  // Shared only when we neither created a worktree nor attached to an
+  // existing linked one (i.e. a non-git dir or the repo's main tree).
+  const sharedWorktree = !createWorktree && !isLinkedAttach;
   try {
     const result = await editor.createWindowWithTerminal({
       root,
@@ -2898,17 +3778,26 @@ async function submitForm(): Promise<void> {
     const id = result.windowId;
     // `createWindowWithTerminal` already dove into the new window,
     // so `setWindowState` writes to it.
-    editor.setWindowState("project_path", projectPath);
+    editor.setWindowState("project_path", effectiveProjectPath);
     editor.setWindowState("shared_worktree", sharedWorktree);
+    // If we attached to a worktree that was sitting in the picker as
+    // a discovered row, drop that placeholder — this live window
+    // supersedes it.
+    const discId = discoveredIdByPath.get(root);
+    if (discId !== undefined) {
+      orchestratorSessions.delete(discId);
+      discoveredIdByPath.delete(root);
+    }
     const tracked: AgentSession = {
       id,
       label: sessionName,
       root,
-      projectPath,
+      projectPath: effectiveProjectPath,
       sharedWorktree,
       terminalId: result.terminalId,
       state: "running",
       createdAt: Date.now(),
+      branch: reportedBranch || undefined,
     };
     orchestratorSessions.set(id, tracked);
   } catch (e) {
@@ -2920,6 +3809,54 @@ async function submitForm(): Promise<void> {
   }
 }
 
+/// Open a session in an existing worktree without creating one —
+/// the dive action for a discovered row, and the building block the
+/// new-session form reuses when the user points Project Path at an
+/// existing linked worktree. Spawns a bare terminal (no agent
+/// command) rooted at the worktree, tags the window with its
+/// canonical project + `shared_worktree = false` so Archive / Delete
+/// manage it as the real worktree it is, then drops the discovered
+/// placeholder (the live window supersedes it).
+async function attachToWorktree(opts: {
+  root: string;
+  projectPath: string;
+  label: string;
+  branch?: string;
+  discoveredId?: number;
+}): Promise<void> {
+  try {
+    const result = await editor.createWindowWithTerminal({
+      root: opts.root,
+      label: opts.label,
+      cwd: opts.root,
+    });
+    const id = result.windowId;
+    editor.setWindowState("project_path", opts.projectPath);
+    editor.setWindowState("shared_worktree", false);
+    if (opts.discoveredId !== undefined) {
+      orchestratorSessions.delete(opts.discoveredId);
+      discoveredIdByPath.delete(opts.root);
+    }
+    orchestratorSessions.set(id, {
+      id,
+      label: opts.label,
+      root: opts.root,
+      projectPath: opts.projectPath,
+      sharedWorktree: false,
+      terminalId: result.terminalId,
+      state: "running",
+      createdAt: Date.now(),
+      branch: opts.branch,
+    });
+  } catch (e) {
+    editor.setStatus(
+      `Orchestrator: failed to attach session — ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    );
+  }
+}
+
 function startNewSession(): void {
   if (form) return; // already open
   openForm();
@@ -3116,39 +4053,54 @@ function enterConfirm(action: "stop" | "archive" | "delete"): void {
   if (!openDialog || !openPanel) return;
   const id = openDialog.filteredIds[openDialog.selectedIndex];
   if (typeof id !== "number" || id <= 0) return;
-  // Refuse Archive / Delete on a shared root while other
-  // sessions still live there. Both actions either move
-  // (`git worktree move`) or remove (`git worktree remove`)
-  // the on-disk path — doing that under another running
-  // session would yank the rug out from under it. Stop is
-  // fine: it only signals THIS session's process group, no
-  // disk operation.
+  // Archive moves the worktree to the graveyard, so it only applies to
+  // a session that owns one. A launch/in-place session runs inside a
+  // real checkout with no `git worktree` entry — Archive would have
+  // nothing to move (and must never rm-rf the user's actual project).
+  // Delete forgets the session and removes the worktree only when one
+  // is owned. Both refuse the last live window (the editor must keep at
+  // least one) — surface that before the confirm step.
   if (action === "archive" || action === "delete") {
     const session = orchestratorSessions.get(id);
-    if (session) {
-      const siblings = countSiblingsAtRoot(session.root);
-      if (siblings > 1) {
-        setDialogError(
-          `cannot ${action} session [${id}] ${session.label} — ${siblings - 1} other session(s) share this worktree; close them first`,
-        );
-        refreshOpenDialog();
-        return;
-      }
-      if (session.sharedWorktree) {
-        // Single-session shared-worktree mode: there's no
-        // `git worktree` entry to remove for this session.
-        // Block both lifecycle actions so we don't run
-        // `git worktree remove` against a non-worktree path
-        // and rm-rf the user's actual project directory.
-        setDialogError(
-          `cannot ${action} session [${id}] ${session.label} — session shares its working tree with the project root; close it via the editor instead`,
-        );
-        refreshOpenDialog();
-        return;
-      }
+    if (session && session.id > 0 && liveWindowCount() <= 1) {
+      setDialogError(
+        `cannot ${action} session [${id}] ${session.label} — it's the last window; open another session first`,
+      );
+      refreshOpenDialog();
+      return;
     }
   }
-  openDialog.pendingConfirm = { action, sessionId: id };
+  if (action === "archive") {
+    const session = orchestratorSessions.get(id);
+    if (session && !ownsWorktree(session)) {
+      setDialogError(
+        `cannot archive session [${id}] ${session.label} — it has no dedicated worktree; use Delete to forget it`,
+      );
+      refreshOpenDialog();
+      return;
+    }
+  }
+  openDialog.pendingConfirm = { action, ids: [id] };
+  openPanel.update(buildOpenSpec());
+  openPanel.setFocusKey("confirm-cancel");
+}
+
+// Open the confirm panel for a *bulk* action over the current
+// checkbox selection. Filters to the eligible members up front (so
+// the confirm count matches what will actually run); refuses with a
+// banner when nothing is eligible.
+function enterBulkConfirm(action: BulkAction): void {
+  if (!openDialog || !openPanel) return;
+  const targets = eligibleSelected(action);
+  if (targets.length === 0) {
+    setDialogError(`no selected session can be ${action === "stop" ? "stopped" : action + "d"}`);
+    refreshOpenDialog();
+    return;
+  }
+  // All three actions confirm — even Stop, so a bulk Stop over a
+  // large selection isn't a single mis-key away. The confirm panel
+  // lists the targets and shows the eligible count.
+  openDialog.pendingConfirm = { action, ids: targets };
   openPanel.update(buildOpenSpec());
   openPanel.setFocusKey("confirm-cancel");
 }
@@ -3290,7 +4242,16 @@ editor.on("widget_event", (e) => {
       refreshOpenDialog();
       return;
     }
-    if (e.event_type === "select" && e.widget_key === "sessions") {
+    // List selection. Keyboard nav fires this with `widget_key`
+    // "sessions" (the list's own key); a mouse click on a row fires it
+    // with `widget_key` set to the clicked item's key, carrying the
+    // list key in `payload.list_key` instead — accept both so clicking a
+    // row selects it (highlight + preview) just like arrowing to it.
+    if (
+      e.event_type === "select" &&
+      (e.widget_key === "sessions" ||
+        ((e.payload ?? {}) as Record<string, unknown>).list_key === "sessions")
+    ) {
       const payload = (e.payload ?? {}) as Record<string, unknown>;
       const idx = payload.index;
       if (typeof idx === "number") {
@@ -3307,8 +4268,11 @@ editor.on("widget_event", (e) => {
         // on the button. Snap focus back to Visit so the user can
         // press Enter to open the newly-highlighted session — the
         // dialog's whole reason for being. Idempotent when focus
-        // is already on Visit.
-        openPanel.setFocusKey("visit");
+        // is already on Visit. Skipped in bulk mode and during a
+        // confirm, where "visit" isn't in the spec.
+        if (selectedSessions().length < 2 && !openDialog.pendingConfirm) {
+          openPanel.setFocusKey("visit");
+        }
       }
       return;
     }
@@ -3317,6 +4281,20 @@ editor.on("widget_event", (e) => {
       (e.widget_key === "sessions" || e.widget_key === "visit")
     ) {
       const id = openDialog.filteredIds[openDialog.selectedIndex];
+      const sel = typeof id === "number" ? orchestratorSessions.get(id) : undefined;
+      if (sel && sel.discovered) {
+        // Discovered worktree: there's no window to switch to —
+        // open one by attaching a fresh session to the worktree.
+        closeOpenDialog();
+        void attachToWorktree({
+          root: sel.root,
+          projectPath: sel.projectPath ?? sel.root,
+          label: sel.label,
+          branch: sel.branch,
+          discoveredId: sel.id,
+        });
+        return;
+      }
       if (typeof id === "number" && id > 0 && id !== editor.activeWindow()) {
         editor.setActiveWindow(id);
       }
@@ -3337,6 +4315,18 @@ editor.on("widget_event", (e) => {
       refreshOpenDialog();
       return;
     }
+    if (e.event_type === "toggle" && e.widget_key === "worktree-show") {
+      // The toggle widget reports the new checked state; route through
+      // the shared flip so the Alt+T chord and the click stay in sync.
+      toggleShowWorktrees();
+      return;
+    }
+    if (e.event_type === "toggle" && e.widget_key === "hide-trivial") {
+      // Same pattern as the worktree toggle: route the click through the
+      // shared flip so the checkbox and the Alt+I chord stay in sync.
+      toggleHideTrivial();
+      return;
+    }
     if (e.event_type === "activate" && e.widget_key === "stop") {
       enterConfirm("stop");
       return;
@@ -3349,44 +4339,47 @@ editor.on("widget_event", (e) => {
       enterConfirm("delete");
       return;
     }
-    if (e.event_type === "activate" && e.widget_key === "confirm-cancel") {
-      openDialog.pendingConfirm = null;
-      openPanel.update(buildOpenSpec());
+    // Bulk action bar (Layout B) — Stop / Archive / Delete over the
+    // checkbox selection, plus Clear.
+    if (e.event_type === "activate" && e.widget_key === "bulk-stop") {
+      enterBulkConfirm("stop");
       return;
     }
-    if (e.event_type === "activate" && e.widget_key === "confirm-stop") {
-      openDialog.pendingConfirm = null;
-      stopSelectedSession();
-      if (openPanel) openPanel.update(buildOpenSpec());
+    if (e.event_type === "activate" && e.widget_key === "bulk-archive") {
+      enterBulkConfirm("archive");
       return;
     }
-    if (e.event_type === "activate" && e.widget_key === "confirm-archive") {
-      const id = openDialog.filteredIds[openDialog.selectedIndex];
-      openDialog.pendingConfirm = null;
-      // Mark the session in-flight so the preview swaps to
-      // "Archiving…" and its action buttons disappear until git
-      // finishes. The row stays in the list — `editor.listWindows()`
-      // is still the source of truth and will drop it on
-      // `closeWindow`, which is intentional: a slightly-laggy real
-      // state beats a synchronously faked one that can desync from
-      // git reality (e.g. when `git worktree move` fails).
-      if (typeof id === "number" && id > 0) {
-        openDialog.inFlight = { action: "archive", sessionId: id };
-      }
-      void archiveSelectedSession(id);
+    if (e.event_type === "activate" && e.widget_key === "bulk-delete") {
+      enterBulkConfirm("delete");
+      return;
+    }
+    if (e.event_type === "activate" && e.widget_key === "bulk-clear") {
+      openDialog.selectedIds.clear();
       refreshOpenDialog();
+      openPanel.setFocusKey("visit");
       return;
     }
-    if (e.event_type === "activate" && e.widget_key === "confirm-delete") {
-      const id = openDialog.pendingConfirm?.sessionId;
-      // Mark in-flight — see comment on confirm-archive above.
-      // `deleteConfirmedSession` clears `pendingConfirm` itself, so
-      // we capture the id here before it goes away.
-      if (typeof id === "number" && id > 0) {
-        openDialog.inFlight = { action: "delete", sessionId: id };
+    if (e.event_type === "activate" && e.widget_key === "confirm-cancel") {
+      openDialog.pendingConfirm = null;
+      openPanel.update(buildOpenSpec());
+      return;
+    }
+    // Confirmed Stop / Archive / Delete — single row or bulk batch.
+    // The ids were captured into `pendingConfirm` by enterConfirm /
+    // enterBulkConfirm; `runConfirmedAction` re-checks eligibility,
+    // drives the in-flight markers, and triggers sync.
+    if (
+      e.event_type === "activate" &&
+      (e.widget_key === "confirm-stop" ||
+        e.widget_key === "confirm-archive" ||
+        e.widget_key === "confirm-delete")
+    ) {
+      const confirm = openDialog.pendingConfirm;
+      openDialog.pendingConfirm = null;
+      if (confirm) {
+        void runConfirmedAction(confirm.action, confirm.ids);
       }
-      void deleteConfirmedSession();
-      refreshOpenDialog();
+      if (openPanel) openPanel.update(buildOpenSpec());
       return;
     }
     if (e.event_type === "cancel") {
@@ -3424,10 +4417,6 @@ function killSelected(): void {
     editor.setStatus("Orchestrator: select a session row first");
     return;
   }
-  if (id === 1) {
-    editor.setStatus("Orchestrator: cannot kill the base session");
-    return;
-  }
   if (id === editor.activeWindow()) {
     editor.setStatus(
       "Orchestrator: dive elsewhere first, then kill this session",