@fresh-editor/fresh-editor 0.3.7 → 0.3.8

package/plugins/orchestrator.ts

@@ -84,27 +84,6 @@ 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;
-
 // New-session form state. `null` ⇒ the floating form isn't
 // open. Each field's `value` + `cursor` mirrors what the host
 // renders inside the panel's TextInput widgets; the `submitting`
@@ -267,9 +246,25 @@ 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";
 const OPEN_MODE = "orchestrator-open";
 
 // =============================================================================
@@ -346,14 +341,76 @@ 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 cur = currentProjectKey();
+  const allIds = Array.from(orchestratorSessions.keys());
+
+  // Sort by (current-project-first, then id) so an "all" view
+  // groups the current project's sessions at the top and other
+  // projects' sessions below in a stable order.
+  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;
+    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();
@@ -369,11 +426,33 @@ function filterSessions(needle: string): number[] {
   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
+// Column widths for the tabular session list. ID holds `[NN] `;
+// NAME holds the label plus the BASE / ⇄ badges; PROJECT (filled
+// only for cross-project rows) trails. Kept in sync with
+// `sessionsColumnHeader`.
+const LIST_ID_W = 5;
+const LIST_NAME_W = 20;
+
+// Header row above the session list: `ID   NAME …   PROJECT`.
+function sessionsColumnHeader(): WidgetSpec {
+  return {
+    kind: "raw",
+    entries: [
+      styledRow([
+        {
+          text: "ID".padEnd(LIST_ID_W) + "NAME".padEnd(LIST_NAME_W) + "PROJECT",
+          style: { fg: "ui.menu_disabled_fg" },
+        },
+      ]),
+    ],
+  };
+}
+
+// Build one rendered list-item row for `id`, laid out in columns:
+//   `[id]`  <name + BASE/⇄ badges>   <project basename>
+// The active session's id renders in the active-tab colour (the
+// list has no separate state column); the project column is filled
+// only for sessions that don't belong to the current project.
 function renderListItem(id: number, activeId: number): TextPropertyEntry {
   const s = orchestratorSessions.get(id);
   if (!s) {
@@ -381,37 +460,38 @@ function renderListItem(id: number, activeId: number): TextPropertyEntry {
   }
   const isActive = id === activeId;
   const isBase = id === 1;
-  const stateText = isActive ? "ACT " : STATE_GLYPH[s.state];
+
+  const idText = `[${id}]`.padEnd(LIST_ID_W);
   const entries: { text: string; style?: Record<string, unknown> }[] = [
-    { text: `[${id}] `, style: { fg: "ui.help_key_fg" } },
     {
-      text: stateText,
+      text: idText,
       style: isActive
         ? { fg: "ui.tab_active_fg", bold: true }
-        : { fg: "ui.menu_disabled_fg" },
+        : { fg: "ui.help_key_fg" },
     },
-    { text: `  ${s.label}` },
+    { text: s.label, style: isActive ? { bold: true } : undefined },
   ];
-  // 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 },
-    });
+    entries.push({ text: " BASE", style: { fg: "ui.help_key_fg", bold: true } });
+    nameWidth += 5;
   }
-  // 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) {
+    entries.push({ text: " ⇄", style: { fg: "ui.menu_disabled_fg" } });
+    nameWidth += 2;
+  }
+  // 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]);
@@ -514,20 +594,26 @@ 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 + Filter +
+  // separator + header = 5) = 12. Floor at MIN_LIST_ROWS so a tiny
+  // terminal still shows something.
+  return Math.max(MIN_LIST_ROWS, panelH - 12);
 }
 
 // Compose the right-hand preview pane. Normally it shows info
@@ -688,14 +774,14 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
     }
   }
   // 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) + Filter (1) + separator (1) +
+  // header (1) + list (listVisibleRows) = listVisibleRows + 5.
+  // Preview inside its borders = button row (1) + spacer (1) +
+  // embedRows, so embedRows must equal listVisibleRows + 3. When
+  // details ARE shown, two info rows + a spacer eat three more
+  // lines — `_DETAILS_CHROME_ROWS` accounts for that.
+  const totalEmbedBase = (openDialog?.listVisibleRows ?? MIN_LIST_ROWS) + 3;
   const detailsOn = openDialog?.showDetails ?? false;
   const _DETAILS_CHROME_ROWS = 3; // 2 info rows + 1 spacer
   const embedRows = Math.max(
@@ -793,24 +879,11 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
 
 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);
@@ -838,9 +911,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 +924,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 +946,35 @@ 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(),
+  );
+
   return col(
     {
       kind: "raw",
@@ -883,6 +984,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 +1001,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 +1027,19 @@ function buildOpenSpec(): WidgetSpec {
             }),
             flexSpacer(),
           ),
-          sessionsSeparator(),
+          projectControlRow,
           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 +1059,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 +1067,10 @@ function buildOpenSpec(): WidgetSpec {
       hintBar([
         { keys: "↑↓", label: "nav" },
         { keys: "Enter", label: "dive" },
+        {
+          keys: scopeKey || "⌥P",
+          label: scope === "current" ? "all projects" : "current only",
+        },
         { keys: "Tab", label: "focus" },
         { keys: "Esc", label: "close" },
       ]),
@@ -1032,7 +1150,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 +1160,13 @@ 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,
   };
   openDialog.filteredIds = filterSessions("");
   const activeIdx = openDialog.filteredIds.indexOf(activeId);
@@ -1616,7 +1730,19 @@ 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"],
+  ],
   true,
   true,
 );
@@ -1627,6 +1753,29 @@ registerHandler("orchestrator_open_new_from_picker", () => {
   openForm({ fromPicker: true });
 });
 
+registerHandler("orchestrator_focus_filter", () => {
+  if (!openDialog || !openPanel) return;
+  openPanel.setFocusKey("filter");
+});
+
+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);
+
 // =============================================================================
 // New-session floating form
 // =============================================================================
@@ -2210,7 +2359,6 @@ function renderForm(): void {
 }
 
 function openForm(options?: { fromPicker?: boolean }): void {
-  pendingNewSession = null;
   const lastCmd =
     (editor.getGlobalState("orchestrator.last_cmd") as string | undefined) ?? "";
   form = {
@@ -2713,11 +2861,11 @@ 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.
+  // Branch / cmd values used for the per-window state record —
+  // `branchName` only exists in the worktree-create flow above;
+  // for the shared-worktree / non-git case we report whatever's
+  // currently checked out (best-effort) so the new session record
+  // matches the situation on disk.
   const reportedBranch = createWorktree
     ? (branchInput || sessionName)
     : "";
@@ -2729,16 +2877,47 @@ 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);
+  const sharedWorktree = !createWorktree;
+  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", projectPath);
+    editor.setWindowState("shared_worktree", sharedWorktree);
+    const tracked: AgentSession = {
+      id,
+      label: sessionName,
+      root,
+      projectPath,
+      sharedWorktree,
+      terminalId: result.terminalId,
+      state: "running",
+      createdAt: Date.now(),
+    };
+    orchestratorSessions.set(id, tracked);
+  } catch (e) {
+    editor.setStatus(
+      `Orchestrator: failed to start session — ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    );
+  }
 }
 
 function startNewSession(): void {
@@ -3149,6 +3328,10 @@ 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();
@@ -3262,57 +3445,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 +3475,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();
   }
 });