@fresh-editor/fresh-editor 0.3.7 → 0.3.9

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,26 +96,24 @@ interface AgentSession {
 
 const orchestratorSessions = new Map<number, AgentSession>();
 
-// Pending session-creation intent. Stashed across the
-// async `createWindow → window_created hook` handoff so the
-// hook handler can attach the spawned terminal. (Internally
-// the editor calls these "windows"; Orchestrator still presents
-// them as "sessions" in its UX.)
-let pendingNewSession:
-  | {
-      label: string;
-      branch: string;
-      cmd: string;
-      root: string;
-      // Recorded for `setWindowState` after `window_created`.
-      // `projectPath` is the canonical project root the user
-      // pointed the form at; `sharedWorktree` is `true` when the
-      // session shares its working tree (no dedicated `git
-      // worktree add`).
-      projectPath: string;
-      sharedWorktree: boolean;
-    }
-  | null = null;
+// 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
@@ -139,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
@@ -229,10 +247,34 @@ 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;
+  // 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
@@ -267,9 +309,30 @@ interface OpenDialogState {
   // too easy to skip over when the user's eyes are on the dialog.
   // Cleared on the next nav / filter change.
   lastError: string | null;
+  // Which sessions the list foregrounds:
+  //   - "current": only sessions belonging to the active window's
+  //     project (the default — launching in project B shouldn't
+  //     bury you under project A's sessions). A trailing affordance
+  //     row advertises how many sessions live in other projects.
+  //   - "all": every session, across every project, each row
+  //     labeled with its project so cross-project rows are obvious.
+  // Toggled with the scope key (⌥P by default). The filter input
+  // always searches globally regardless of scope, so typing a name
+  // from another project still surfaces it.
+  scope: "current" | "all";
 }
 let openDialog: OpenDialogState | null = null;
 let openPanel: FloatingWidgetPanel | null = null;
+// Scope is remembered across opens of the picker (module state
+// survives dialog close). Defaults to "all" so the picker opens
+// 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;
 const OPEN_MODE = "orchestrator-open";
 
 // =============================================================================
@@ -303,9 +366,120 @@ 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();
 }
 
 // =============================================================================
@@ -346,14 +520,90 @@ function ageString(createdAt: number): string {
 // The picker is cross-project by design — every session is a
 // candidate regardless of which project the active window
 // points at — so there is no project-scope filter here.
+// Project a session belongs to, as a comparison key. Prefer the
+// canonical `projectPath` recorded at create time; fall back to
+// the session root for sessions that predate the field (the base
+// session, externally-created windows).
+function projectKeyOf(s: AgentSession): string {
+  return s.projectPath ?? s.root;
+}
+
+// The project the user is currently "in" — the active window's
+// project. Falls back to the editor cwd when the active window
+// isn't a tracked session (shouldn't normally happen, but keeps
+// scoping well-defined).
+function currentProjectKey(): string {
+  const s = orchestratorSessions.get(editor.activeWindow());
+  return s ? projectKeyOf(s) : editor.getCwd();
+}
+
+// Short, human-readable label for a project key — the trailing
+// `parent/base` of the path, matching the new-session form's
+// `deriveProjectLabel` style.
+function projectLabel(key: string): string {
+  const base = editor.pathBasename(key);
+  const parent = editor.pathBasename(editor.pathDirname(key));
+  if (parent && parent !== base) return `${parent}/${base}`;
+  return base || key;
+}
+
+// Resolve the id list for the current filter + scope.
+//
+// Scope only constrains the *empty-filter* view: with no needle
+// and `scope === "current"`, the list shows just the active
+// project's sessions (current project first, by id). As soon as
+// the user types, the search goes global regardless of scope —
+// hiding a session the user is explicitly searching for would be
+// the worse surprise. `scope === "all"` always shows everything,
+// sorted by project (current project first) so rows are grouped
+// rather than interleaved.
 function filterSessions(needle: string): number[] {
   reconcileSessions();
-  const ids = Array.from(orchestratorSessions.keys()).sort((a, b) => a - b);
-  if (!needle) return ids;
+  const scope = openDialog?.scope ?? "current";
+  const showWorktrees = openDialog?.showWorktrees ?? false;
+  const cur = currentProjectKey();
+  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);
+  }
+
+  const isDisc = (id: number): number =>
+    orchestratorSessions.get(id)!.discovered ? 1 : 0;
+
+  // 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)!;
+    const aCur = projectKeyOf(sa) === cur ? 0 : 1;
+    const bCur = projectKeyOf(sb) === cur ? 0 : 1;
+    if (aCur !== bCur) return aCur - bCur;
+    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;
+  };
+
+  if (!needle) {
+    const ids = allIds.slice().sort(byProjectThenId);
+    if (scope === "current") {
+      return ids.filter((id) => projectKeyOf(orchestratorSessions.get(id)!) === cur);
+    }
+    return ids;
+  }
+
   const n = needle.toLowerCase();
   type Scored = { id: number; score: number; len: number };
   const matches: Scored[] = [];
-  for (const id of ids) {
+  for (const id of allIds) {
     const s = orchestratorSessions.get(id)!;
     const label = s.label.toLowerCase();
     const root = s.root.toLowerCase();
@@ -365,53 +615,105 @@ 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);
 }
 
-// Build one rendered list-item row for `id`. Style cues:
-//   * `[id]` in `ui.help_key_fg`
-//   * `ACT` (active session) in `ui.tab_active_fg` + bold
-//   * other states use the default fg
-//   * label in default fg
+// 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: `NAME …   PROJECT`.
+function sessionsColumnHeader(): WidgetSpec {
+  return {
+    kind: "raw",
+    entries: [
+      styledRow([
+        {
+          // 4-space lead aligns under the per-row `[ ] ` checkbox.
+          text: "    " + "NAME".padEnd(LIST_NAME_W) + "PROJECT",
+          style: { fg: "ui.menu_disabled_fg" },
+        },
+      ]),
+    ],
+  };
+}
+
+// Build one rendered list-item row for `id`:
+//   `[ ] ` <name + BASE/⇄ badges + 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 stateText = isActive ? "ACT " : STATE_GLYPH[s.state];
+  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 entries: { text: string; style?: Record<string, unknown> }[] = [
-    { text: `[${id}] `, style: { fg: "ui.help_key_fg" } },
+    checkbox,
     {
-      text: stateText,
+      text: s.label,
       style: isActive
-        ? { fg: "ui.tab_active_fg", bold: true }
-        : { fg: "ui.menu_disabled_fg" },
+        ? { fg: "ui.help_key_fg", bold: true }
+        : isDiscovered
+        ? { fg: "ui.menu_disabled_fg" }
+        : undefined,
     },
-    { text: `  ${s.label}` },
   ];
-  // BASE badge: the base session is the editor process itself —
-  // archive / delete would close the editor (and possibly destroy
-  // the user's current worktree), so the host refuses both. The
-  // badge makes that special status visible up-front instead of
-  // surfacing as "Archive disabled, why?" after a Tab.
+  // Visible width of the NAME column so far (label + badges), 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: " BASE",
-      style: { fg: "ui.help_key_fg", bold: true },
+      text: " · on-disk",
+      style: { fg: "ui.menu_disabled_fg", italic: true },
     });
+    nameWidth += 10;
   }
-  // SHARED badge for the row when this session shares its
-  // worktree (with another session or with the project root
-  // directly). Mirrors the preview pane's badge so the
-  // shared-worktree status is visible at-a-glance from the
-  // list too.
-  if (s.sharedWorktree || countSiblingsAtRoot(s.root) > 1) {
+  // PROJECT column: basename for cross-project rows only; current-
+  // project rows leave it blank (the whole list is one project when
+  // scoped, so this column is empty then).
+  const proj = projectKeyOf(s);
+  if (proj !== currentProjectKey()) {
+    const pad = Math.max(1, LIST_NAME_W - nameWidth);
+    entries.push({ text: " ".repeat(pad) });
     entries.push({
-      text: " ⇄",
-      style: { fg: "ui.menu_disabled_fg" },
+      text: editor.pathBasename(proj),
+      style: { fg: "ui.menu_disabled_fg", italic: true },
     });
   }
   return styledRow(entries as Parameters<typeof styledRow>[0]);
@@ -446,7 +748,7 @@ function buildPreviewEntries(
     {
       text: stateText,
       style: isActive
-        ? { fg: "ui.tab_active_fg", bold: true }
+        ? { fg: "ui.help_key_fg", bold: true }
         : { fg: "ui.menu_disabled_fg" },
     },
     { text: "  " },
@@ -508,26 +810,98 @@ function countSiblingsAtRoot(root: string): number {
   return n;
 }
 
+// =============================================================================
+// 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;
+  if (id === 1) return false;
+  if (action === "stop") return !s.discovered && id > 0;
+  if (s.discovered) return true;
+  const sharesRoot = countSiblingsAtRoot(s.root) > 1 || s.sharedWorktree;
+  return !sharesRoot;
+}
+
+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);
+  }
+}
+
 // Blank-row separator used inside the Sessions column between
 // the filter, the new-session button, and the list.
 function sessionsSeparator(): WidgetSpec {
   return spacer(0);
 }
 
-// Approximate number of session rows the picker's list pane
-// should show. Sized off the full terminal (not the active
-// buffer's viewport — that shrinks with vertical splits and made
-// the picker collapse to ~half its `heightPct: 90` budget).
-function openListVisibleRows(): number {
+// Smallest list height we'll show even when there are only a
+// couple of sessions — keeps the preview pane (which matches the
+// list height) usable rather than collapsing to a sliver.
+const MIN_LIST_ROWS = 6;
+
+// Upper bound on session rows for this terminal — the list height
+// when the panel is at its full `heightPct: 90` budget. Sized off
+// the full terminal (not the active buffer's viewport — that
+// shrinks with vertical splits and made the picker collapse to
+// ~half its budget).
+function maxListRowsForScreen(): number {
   const screen = editor.getScreenSize();
   const h = screen.height > 0 ? screen.height : 30;
   const panelH = Math.floor(h * 0.9);
-  // panel borders (2) + header (1) + spacer (1) + sessions
-  // section borders (2) + filter row (1) + separator (1) +
-  // new-session button row (1) + separator (1) + footer (1) =
-  // 11 rows of chrome. Floor at 4 so a tiny terminal still
-  // shows something.
-  return Math.max(4, panelH - 11);
+  // 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 + Worktree-filter +
+  // Filter + separator + header = 6) = 13. Floor at MIN_LIST_ROWS so
+  // a tiny terminal still shows something.
+  return Math.max(MIN_LIST_ROWS, panelH - 13);
 }
 
 // Compose the right-hand preview pane. Normally it shows info
@@ -572,130 +946,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 = filter (1) + separator (1) + new-session button
-  // (1) + separator (1) + list (listVisibleRows) = listVisibleRows
-  // + 4. Preview inside its borders = button row (1) + spacer (1)
-  // + embedRows, so embedRows must equal listVisibleRows + 2.
-  // When details ARE shown, two info rows + a spacer eat three
-  // more lines — `_DETAILS_CHROME_ROWS` accounts for that.
-  const totalEmbedBase = (openDialog?.listVisibleRows ?? 6) + 2;
+  // bottom borders land on the same row. Sessions column inside its
+  // borders = New (1) + Project (1) + Worktree-filter (1) +
+  // Filter (1) + separator (1) + header (1) + list (listVisibleRows)
+  // = listVisibleRows + 6. Preview inside its borders = button
+  // row (1) + spacer (1) + embedRows, so embedRows must equal
+  // listVisibleRows + 4. 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) + 4;
   const detailsOn = openDialog?.showDetails ?? false;
   const _DETAILS_CHROME_ROWS = 3; // 2 info rows + 1 spacer
   const embedRows = Math.max(
@@ -728,6 +1000,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
@@ -783,43 +1097,243 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
   // 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}`;
+    ? `${s.label}  —  BASE (editor 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 (id === 1) {
+      rowParts.push({
+        text: "  · base (protected)",
+        style: { fg: "ui.menu_disabled_fg", italic: true },
+      });
+    } else if (!ss.discovered && (countSiblingsAtRoot(ss.root) > 1 || ss.sharedWorktree)) {
+      rowParts.push({
+        text: "  · shared worktree",
+        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();
-  // Re-derive row counts on every spec build as a fallback for the
-  // resize hook not always firing reliably through tmux's SIGWINCH
-  // propagation (Finding I). **One-way ratchet**: only adopt the
-  // new value when it's *larger* than the current one. The
-  // `editor.getViewport()` height shrinks while the picker is
-  // mounted (the floating panel covers part of the buffer area),
-  // and naively re-reading it on every refresh fed that shrink
-  // back into the dialog size — pressing Up/Down caused the
-  // picker to oscillate smaller on every keystroke. A real
-  // terminal-grow event still flows through because the new
-  // viewport height exceeds the cached value; a spurious shrink
-  // (because the panel itself is up) is ignored.
-  const liveListVisibleRows = openListVisibleRows();
-  if (liveListVisibleRows > openDialog.listVisibleRows) {
-    openDialog.listVisibleRows = liveListVisibleRows;
-    openDialog.embedRows = Math.max(3, liveListVisibleRows - 5);
-  }
   const filtered = openDialog.filteredIds;
+  // Fill the panel's full height budget (the list pads with blank
+  // rows when there are few sessions) so the dialog stays
+  // vertically full rather than collapsing to a short floating box.
+  openDialog.listVisibleRows = maxListRowsForScreen();
   const activeId = editor.activeWindow();
   const items = filtered.map((id) => renderListItem(id, activeId));
   const itemKeys = filtered.map(String);
   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
@@ -838,9 +1352,7 @@ function buildOpenSpec(): WidgetSpec {
     "orchestrator_open_new_from_picker",
     OPEN_MODE,
   );
-  const newLabel = newKey
-    ? `+ New Session  ${newKey}`
-    : "+ New Session";
+  const newLabel = newKey ? `+ New  ${newKey}` : "+ New";
   const inConfirm = openDialog.pendingConfirm !== null;
   // While a confirmation prompt is up the filter is rendered
   // without a `key`. The host's `collect_tabbable` only adds
@@ -853,7 +1365,8 @@ function buildOpenSpec(): WidgetSpec {
   const filterInput = text({
     value: openDialog.filter.value,
     cursorByte: openDialog.filter.cursor,
-    placeholder: "type to filter…",
+    label: "Filter",
+    placeholder: "type to search… ( / )",
     fullWidth: true,
     key: inConfirm ? undefined : "filter",
   });
@@ -874,6 +1387,55 @@ function buildOpenSpec(): WidgetSpec {
         ],
       }
     : null;
+
+  // Scope chrome. The title keeps the active project visible; the
+  // `Project:` control below is the clickable scope switch.
+  const scope = openDialog.scope;
+  const curKey = currentProjectKey();
+  const curName = projectLabel(curKey);
+  const scopeKey = editor.getKeybindingLabel("orchestrator_toggle_scope", OPEN_MODE);
+  const titleSuffix = scope === "current" ? `  —  ${curName}` : "  —  all projects";
+  const sectionLabel = "Sessions";
+  // `Project:` control — a visible, clickable scope switch with the
+  // Alt+P hint baked into the button label. Shows the current
+  // project's name when scoped, "All" when showing every project.
+  // Inert while a confirm prompt is up so it can't steal focus.
+  const scopeWord = scope === "current" ? editor.pathBasename(curKey) : "All";
+  const scopeButtonLabel = scopeKey ? `${scopeWord} ▾   (${scopeKey})` : `${scopeWord} ▾`;
+  const scopeButton = button(scopeButtonLabel, {
+    key: openDialog.pendingConfirm !== null ? undefined : "scope-toggle",
+  });
+  const projectControlRow = row(
+    {
+      kind: "raw",
+      entries: [
+        styledRow([{ text: "Project: ", style: { fg: "ui.menu_disabled_fg" } }]),
+      ],
+    },
+    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(),
+  );
+
   return col(
     {
       kind: "raw",
@@ -883,6 +1445,10 @@ function buildOpenSpec(): WidgetSpec {
             text: "ORCHESTRATOR :: Sessions",
             style: { fg: "ui.popup_border_fg", bold: true },
           },
+          {
+            text: titleSuffix,
+            style: { fg: "ui.menu_disabled_fg" },
+          },
         ]),
       ],
     },
@@ -896,14 +1462,18 @@ function buildOpenSpec(): WidgetSpec {
     // the dialog.
     row(
       labeledSection({
-        label: `Sessions (${filtered.length})`,
-        widthPct: 25,
-        // Sessions column: new-session button, separator,
-        // filter, separator, list. The button is first so it
-        // gets initial focus (Enter immediately opens the new
-        // session form). Separators are long `─` strings that
-        // the renderer truncates to the column's inner width —
-        // no need to measure cells from the plugin side.
+        label: sectionLabel,
+        // 34% (was 25%): wide enough that the per-row project tag in
+        // the all-projects view (`· <project>`) and longer session
+        // labels render without truncating to `· tmp_o…`. The preview
+        // pane still keeps the majority for the live window embed.
+        widthPct: 34,
+        // Sessions column: New button, Project (scope) control,
+        // Filter, separator, column header, list. The button is
+        // first so it gets initial focus (Enter immediately opens the
+        // new session form). Separators are long `─` strings that the
+        // renderer truncates to the column's inner width — no need to
+        // measure cells from the plugin side.
         child: col(
           row(
             button(newLabel, {
@@ -918,13 +1488,20 @@ function buildOpenSpec(): WidgetSpec {
             }),
             flexSpacer(),
           ),
-          sessionsSeparator(),
+          projectControlRow,
+          worktreeFilterRow,
           filterInput,
           sessionsSeparator(),
+          sessionsColumnHeader(),
           list({
             items,
             itemKeys,
             selectedIndex: selIdx,
+            // `listVisibleRows` is the fitted list height; the 5 rows
+            // of column chrome above it (New / Project / Filter /
+            // separator / header) and the matching preview embed are
+            // accounted for separately so both panes stay the same
+            // height and the footer hint stays on-screen.
             visibleRows: openDialog.listVisibleRows,
             // Excluded from the Tab cycle — Up/Down on the
             // filter input forwards to this list via host
@@ -944,8 +1521,7 @@ function buildOpenSpec(): WidgetSpec {
         ),
       }),
       // Preview pane has no explicit width — picks up the
-      // remaining 75% by default since the sessions list took
-      // 25%.
+      // remaining width by default since the sessions list took 34%.
       buildPreviewPane(selectedSession),
     ),
     row(
@@ -953,6 +1529,15 @@ 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",
+        },
         { keys: "Tab", label: "focus" },
         { keys: "Esc", label: "close" },
       ]),
@@ -1009,6 +1594,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
@@ -1032,7 +1618,9 @@ function openControlRoom(): void {
   if (openPanel) return;
   reconcileSessions();
   const activeId = editor.activeWindow();
-  const listVisibleRows = openListVisibleRows();
+  // Seed with the screen-max; buildOpenSpec refits to the session
+  // count on the first render (and every render after).
+  const listVisibleRows = maxListRowsForScreen();
   openDialog = {
     filter: { value: "", cursor: 0 },
     filteredIds: [],
@@ -1040,19 +1628,16 @@ function openControlRoom(): void {
     originalActiveSession: activeId,
     pendingConfirm: null,
     listVisibleRows,
-    // Mirror buildPreviewPane's chrome: 1 button row + 1 spacer
-    // + 2 info rows + 1 spacer = 4 rows reserved above the embed.
-    // Preview chrome above the embed: 1 button row + 1 spacer + 2
-    // info rows + 1 spacer = 5 rows. The labeledSection's top/bottom
-    // borders match the sessions list's, so subtracting just the
-    // chrome makes the preview pane's apparent height match the
-    // list pane's (`visible_rows + 2 borders`) exactly. Floored at
-    // 3 so a tiny terminal still leaves enough rows for the embed
-    // to paint something meaningful.
-    embedRows: Math.max(3, listVisibleRows - 5),
+    embedRows: Math.max(3, listVisibleRows + 3),
     showDetails: false,
     inFlight: null,
     lastError: null,
+    // 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,
+    bulkInFlight: null,
   };
   openDialog.filteredIds = filterSessions("");
   const activeIdx = openDialog.filteredIds.indexOf(activeId);
@@ -1074,6 +1659,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 {
@@ -1085,33 +1676,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 || id === 1 || s.discovered) 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;
 }
 
 // ---------------------------------------------------------------------
@@ -1194,136 +1779,97 @@ function pickNextActiveSession(excludeId: number): number {
   return 1;
 }
 
-// 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;
-  }
-
-  // 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" };
+  if (id === 1) return { ok: false, err: "cannot archive the base session" };
+  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));
+    }
+    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 };
 }
 
 // ---------------------------------------------------------------------
@@ -1526,86 +2072,135 @@ 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: 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. Handles discovered
+// on-disk worktrees (no window to close). No recovery after this
+// point. 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" };
+  if (id === 1) return { ok: false, err: "cannot delete the base session" };
+  const repoRoot = await worktreeRepoRoot(s);
+  if (!repoRoot) return { ok: false, err: "not a git repository" };
+
+  if (!s.discovered && id > 0) {
+    // close_window refuses to close the active window, so swap away.
+    if (id === editor.activeWindow()) {
+      editor.setActiveWindow(pickNextActiveSession(id));
     }
-  };
-  const session = orchestratorSessions.get(id);
-  if (!session) {
-    clearInFlight();
-    return;
-  }
-  // 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));
-  }
-
-  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;
+    editor.signalWindow(id, "SIGKILL");
+    editor.closeWindow(id);
+    await editor.delay(250);
   }
-  const repoRoot = (top.stdout || "").trim();
-
-  editor.signalWindow(id, "SIGKILL");
-  editor.closeWindow(id);
-  await editor.delay(250);
 
-  // `--force` because the worktree may have unstaged changes
-  // the user explicitly chose to discard via the confirm step.
+  // `--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],
+    ["-C", repoRoot, "worktree", "remove", "--force", s.root],
     repoRoot,
   );
   if (removeRes.exit_code !== 0) {
-    editor.setStatus(
-      `Orchestrator: worktree remove failed: ${
-        lastNonEmptyLine(removeRes.stderr) || "unknown error"
-      }`,
-    );
-    clearInFlight();
-    return;
+    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 is the natural
-  // way to drop dormant sessions).
+  // 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,
-  );
+  manifest.sessions = manifest.sessions.filter((e) => e.label !== s.label);
   if (manifest.sessions.length !== before) {
     saveArchiveManifest(repoRoot, manifest);
   }
 
-  editor.setStatus(`Orchestrator: deleted [${id}] ${session.label}`);
-  clearInFlight();
-  triggerSyncAsync(repoRoot);
+  if (s.discovered) {
+    orchestratorSessions.delete(id);
+    discoveredIdByPath.delete(s.root);
+  }
+  return { ok: true, repoRoot };
+}
+
+// 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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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
@@ -1616,7 +2211,33 @@ async function deleteConfirmedSession(): Promise<void> {
 // since OPEN_MODE doesn't claim them here.
 editor.defineMode(
   OPEN_MODE,
-  [["M-n", "orchestrator_open_new_from_picker"]],
+  [
+    ["M-n", "orchestrator_open_new_from_picker"],
+    // Scope toggle: flip the list between "current project only"
+    // and "all projects". Registered as a mode chord so it's
+    // user-rebindable and renders cross-platform (⌥P / Alt+P).
+    ["M-p", "orchestrator_toggle_scope"],
+    // `/` jumps focus to the filter input — the familiar
+    // search-focus shortcut. (As a mode chord it's intercepted even
+    // while the filter has focus, so `/` can't be typed as filter
+    // 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"],
+  ],
   true,
   true,
 );
@@ -1627,6 +2248,86 @@ registerHandler("orchestrator_open_new_from_picker", () => {
   openForm({ fromPicker: true });
 });
 
+registerHandler("orchestrator_focus_filter", () => {
+  if (!openDialog || !openPanel) return;
+  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";
+  // Remember the choice for the next time the picker opens.
+  lastOpenScope = openDialog.scope;
+  // Keep the highlighted session selected across the scope flip
+  // when it survives into the new list; otherwise fall back to the
+  // top. The filter value is untouched — toggling scope with an
+  // active filter just widens/narrows the global-search base.
+  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_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);
+
 // =============================================================================
 // New-session floating form
 // =============================================================================
@@ -1929,6 +2630,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 },
@@ -2015,9 +2840,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) {
@@ -2092,6 +2919,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
@@ -2210,7 +3055,6 @@ function renderForm(): void {
 }
 
 function openForm(options?: { fromPicker?: boolean }): void {
-  pendingNewSession = null;
   const lastCmd =
     (editor.getGlobalState("orchestrator.last_cmd") as string | undefined) ?? "";
   form = {
@@ -2232,6 +3076,7 @@ function openForm(options?: { fromPicker?: boolean }): void {
     lastError: null,
     defaultProjectPath: "",
     projectPathIsGit: null,
+    projectPathIsLinkedWorktree: null,
     defaultSessionName: "",
     defaultBranch: "",
     defaultBranchIsHeadFallback: false,
@@ -2294,6 +3139,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
@@ -2713,14 +3576,28 @@ async function submitForm(): Promise<void> {
     editor.setGlobalState("orchestrator.last_cmd", cmd);
   }
 
-  // Branch / cmd values used for `pendingNewSession` — `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.
+  // 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
+  // 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.
@@ -2729,16 +3606,106 @@ async function submitForm(): Promise<void> {
   if (cmd) appendHistory("cmd", cmd);
   if (createWorktree) appendHistory("branch", reportedBranch);
 
-  pendingNewSession = {
-    label: sessionName,
-    branch: reportedBranch,
-    cmd,
-    root,
-    projectPath,
-    sharedWorktree: !createWorktree,
-  };
   closeForm();
-  editor.createWindow(root, sessionName);
+
+  // Spawn the new window + agent terminal atomically. Compared to
+  // the legacy `createWindow → window_created hook → createTerminal`
+  // chain this avoids the transient `[No Name]` tab the host's
+  // eager seed used to leave alongside the agent terminal: the
+  // terminal IS the new window's seed buffer, so the window is
+  // born with a single tab.
+  const argv = splitAgentCmd(cmd);
+  // 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,
+      label: sessionName,
+      cwd: root,
+      command: argv.length > 0 ? argv : undefined,
+      title: argv.length > 0 ? argv[0] : undefined,
+    });
+    const id = result.windowId;
+    // `createWindowWithTerminal` already dove into the new window,
+    // so `setWindowState` writes to it.
+    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: effectiveProjectPath,
+      sharedWorktree,
+      terminalId: result.terminalId,
+      state: "running",
+      createdAt: Date.now(),
+      branch: reportedBranch || undefined,
+    };
+    orchestratorSessions.set(id, tracked);
+  } catch (e) {
+    editor.setStatus(
+      `Orchestrator: failed to start session — ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    );
+  }
+}
+
+/// 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 {
@@ -2969,7 +3936,27 @@ function enterConfirm(action: "stop" | "archive" | "delete"): void {
       }
     }
   }
-  openDialog.pendingConfirm = { action, sessionId: id };
+  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");
 }
@@ -3128,8 +4115,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;
     }
@@ -3138,6 +4128,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);
       }
@@ -3149,11 +4153,21 @@ editor.on("widget_event", (e) => {
       openForm({ fromPicker: true });
       return;
     }
+    if (e.event_type === "activate" && e.widget_key === "scope-toggle") {
+      toggleScope();
+      return;
+    }
     if (e.event_type === "activate" && e.widget_key === "toggle-details") {
       openDialog.showDetails = !openDialog.showDetails;
       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 === "activate" && e.widget_key === "stop") {
       enterConfirm("stop");
       return;
@@ -3166,44 +4180,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") {
@@ -3262,57 +4279,13 @@ function killSelected(): void {
 // Lifecycle hook handlers
 // =============================================================================
 
-editor.on("window_created", async (payload) => {
-  const id = payload.id;
-  if (
-    pendingNewSession &&
-    payload.label === pendingNewSession.label
-  ) {
-    const intent = pendingNewSession;
-    pendingNewSession = null;
-    // Dive into the new session FIRST so its terminal_manager is
-    // the editor-active one. Subsequent `createTerminal` /
-    // `sendTerminalInput` calls then resolve against the new
-    // session's window without needing a cross-window terminal
-    // lookup. Creating a session is a visit-now action anyway —
-    // the dive isn't user-visible flicker, it's the desired
-    // landing state.
-    editor.setActiveWindow(id);
-    // Record the new session's project_path / shared_worktree
-    // into per-window plugin state — these survive editor
-    // restarts via `orchestrator_persistence.rs`, and feed the
-    // Open dialog's "this project" filter on the next launch.
-    // `setWindowState` writes to the active window, which we
-    // just set above.
-    editor.setWindowState("project_path", intent.projectPath);
-    editor.setWindowState("shared_worktree", intent.sharedWorktree);
-    // When the user provided a non-empty agent command, spawn it as
-    // the PTY child directly (no shell middleman). Tab title reads
-    // the command name ("python3", "claude", ...) instead of the
-    // generic "*Terminal N*". When `cmd` is empty the host picks
-    // the user's shell as before.
-    const argv = splitAgentCmd(intent.cmd);
-    const term = await editor.createTerminal({
-      cwd: intent.root,
-      focus: false,
-      command: argv.length > 0 ? argv : undefined,
-      title: argv.length > 0 ? argv[0] : undefined,
-    });
-    const tracked: AgentSession = {
-      id,
-      label: intent.label,
-      root: intent.root,
-      terminalId: term.terminalId,
-      state: "running",
-      createdAt: Date.now(),
-    };
-    orchestratorSessions.set(id, tracked);
-    // Legacy `sendTerminalInput` path is no longer needed when the
-    // command is spawned directly. Kept for the shell-only case
-    // would be `editor.sendTerminalInput(term.terminalId, "\n")` to
-    // wake up the prompt, but that's unnecessary — the shell prints
-    // its own prompt on startup.
-  }
+editor.on("window_created", () => {
+  // The orchestrator's own new-session flow uses
+  // `createWindowWithTerminal` (atomic — populates the window
+  // before returning), so by the time this hook fires for one of
+  // our spawns the session is already tracked. Other plugins or
+  // host actions creating windows just need the picker to
+  // refresh.
   refreshOpenDialog();
 });
 
@@ -3336,9 +4309,8 @@ editor.on("active_window_changed", () => {
 // viewport at the same time.
 editor.on("resize", () => {
   if (openDialog && openPanel) {
-    const listVisibleRows = openListVisibleRows();
-    openDialog.listVisibleRows = listVisibleRows;
-    openDialog.embedRows = Math.max(3, listVisibleRows - 5);
+    // buildOpenSpec refits `listVisibleRows` to the session count
+    // (bounded by the new screen budget) on the refresh below.
     refreshOpenDialog();
   }
 });