@fresh-editor/fresh-editor 0.3.9 → 0.3.10

package/plugins/orchestrator.ts

@@ -269,6 +269,14 @@ interface OpenDialogState {
   // (worktrees hidden) — discovery is opt-in. Remembered across opens
   // via `lastShowWorktrees`.
   showWorktrees: boolean;
+  // `true` hides "trivial" sessions — those with no terminal and at
+  // most one open file/buffer (empty-unnamed-buffer and single-file
+  // shells left behind by one-off editor launches). The "Show
+  // empty/1-file sessions" checkbox (Alt+I / `orchestrator_toggle_trivial`)
+  // flips it. Defaults to true; remembered across opens via
+  // `lastHideTrivial`. The active session and discovered worktree rows
+  // are never hidden by this filter regardless of the flag.
+  hideTrivial: boolean;
   // Progress marker for an in-flight *bulk* action. While set, the
   // selection bar shows "Archiving 2/3…" and its buttons are
   // hidden so a second Enter can't re-fire mid-batch. Cleared when
@@ -333,6 +341,87 @@ let lastOpenScope: "current" | "all" = "all";
 // (worktrees hidden) — surfacing them is opt-in via "Show all
 // worktrees" (Alt+T).
 let lastShowWorktrees = false;
+// Remembered across opens: whether "trivial" sessions are hidden.
+// Defaults to true — every editor launch on a throwaway directory or a
+// single file leaves a workspace file behind, which restores as a shell
+// window and clutters the list. Hiding them by default keeps the picker
+// focused on real sessions; the "Show empty/1-file sessions" checkbox
+// (Alt+I) reveals them.
+let lastHideTrivial = true;
+
+// Per-session content summary keyed by canonical session root, built
+// from the on-disk workspace files. The restored shell windows don't
+// carry their open-tab layout (it's lazily re-warmed on first dive), so
+// the workspace file is the only place to learn how much a session
+// holds. Rebuilt each time the picker opens. A session is "trivial"
+// when it has no terminal and at most one real file/unnamed buffer —
+// the empty-unnamed-buffer and single-file cases the filter targets.
+interface SessionContent {
+  files: number;
+  hasTerminal: boolean;
+  trivial: boolean;
+}
+const sessionContentByRoot = new Map<string, SessionContent>();
+
+// Roots from the editor (`WindowInfo.root`) and from workspace files
+// (`working_dir`) are both canonical absolute paths, but normalise a
+// trailing slash so the two always key the same map entry.
+function normRoot(p: string): string {
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+
+// Scan `<dataDir>/workspaces/*.json` and summarise each session's open
+// content. Mirrors the host's own `discover_sessions` (which keys on the
+// file's `working_dir`), so a root matches regardless of how the
+// filename was percent-encoded. Best-effort: unreadable / unparseable
+// files are skipped, and a missing summary is treated as "not trivial"
+// (shown) by the filter, so we never hide a session we couldn't classify.
+function scanSessionContent(): void {
+  sessionContentByRoot.clear();
+  const dir = editor.pathJoin(editor.getDataDir(), "workspaces");
+  let entries: DirEntry[];
+  try {
+    entries = editor.readDir(dir);
+  } catch {
+    return;
+  }
+  if (!entries) return;
+  for (const e of entries) {
+    if (!e.is_file || !e.name.endsWith(".json")) continue;
+    const raw = editor.readFile(editor.pathJoin(dir, e.name));
+    if (!raw) continue;
+    let ws: Record<string, unknown>;
+    try {
+      ws = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const wd = ws["working_dir"];
+    if (typeof wd !== "string") continue;
+    let files = 0;
+    let hasTerminal = Array.isArray(ws["terminals"]) &&
+      (ws["terminals"] as unknown[]).length > 0;
+    const splits = ws["split_states"];
+    if (splits && typeof splits === "object") {
+      for (const sv of Object.values(splits as Record<string, unknown>)) {
+        const tabs = (sv as Record<string, unknown> | null)?.["open_tabs"];
+        if (!Array.isArray(tabs)) continue;
+        for (const t of tabs) {
+          if (t && typeof t === "object") {
+            if ("File" in t || "Unnamed" in t) files++;
+            else if ("Terminal" in t) hasTerminal = true;
+          }
+        }
+      }
+    }
+    sessionContentByRoot.set(normRoot(wd), {
+      files,
+      hasTerminal,
+      trivial: !hasTerminal && files <= 1,
+    });
+  }
+}
+
 const OPEN_MODE = "orchestrator-open";
 
 // =============================================================================
@@ -561,6 +650,7 @@ function filterSessions(needle: string): number[] {
   reconcileSessions();
   const scope = openDialog?.scope ?? "current";
   const showWorktrees = openDialog?.showWorktrees ?? false;
+  const hideTrivial = openDialog?.hideTrivial ?? false;
   const cur = currentProjectKey();
   let allIds = Array.from(orchestratorSessions.keys());
   // "Show all worktrees" is opt-in: by default the discovered on-disk
@@ -568,6 +658,20 @@ function filterSessions(needle: string): number[] {
   if (!showWorktrees) {
     allIds = allIds.filter((id) => !orchestratorSessions.get(id)!.discovered);
   }
+  // "Hide empty/1-file sessions": drop the restored shells that hold no
+  // real work. The active session is always kept (you must be able to
+  // see where you are), and discovered worktree rows are governed by
+  // their own toggle, not this one. A session with no summary (e.g. a
+  // freshly created agent session not yet written to disk) is kept too.
+  if (hideTrivial) {
+    const activeId = editor.activeWindow();
+    allIds = allIds.filter((id) => {
+      const s = orchestratorSessions.get(id)!;
+      if (s.discovered || id === activeId) return true;
+      const c = sessionContentByRoot.get(normRoot(s.root));
+      return !c || !c.trivial;
+    });
+  }
 
   const isDisc = (id: number): number =>
     orchestratorSessions.get(id)!.discovered ? 1 : 0;
@@ -650,7 +754,7 @@ function sessionsColumnHeader(): WidgetSpec {
 }
 
 // Build one rendered list-item row for `id`:
-//   `[ ] ` <name + BASE/⇄ badges + on-disk tag>   <project basename>
+//   `[ ] ` <name + on-disk tag>   <project basename>
 // The active session's name renders bold; discovered (on-disk,
 // unopened) worktrees render dim with a `· on-disk` tag instead of a
 // glyph. The project column is filled only for sessions that don't
@@ -661,7 +765,6 @@ function renderListItem(id: number, activeId: number): TextPropertyEntry {
     return styledRow([{ text: "(unknown)" }]);
   }
   const isActive = id === activeId;
-  const isBase = id === 1;
   const isDiscovered = !!s.discovered;
   const isChecked = openDialog?.selectedIds.has(id) ?? false;
 
@@ -686,17 +789,9 @@ function renderListItem(id: number, activeId: number): TextPropertyEntry {
         : undefined,
     },
   ];
-  // Visible width of the NAME column so far (label + badges), used
+  // Visible width of the NAME column so far (label + tags), used
   // to pad out to LIST_NAME_W before the PROJECT column.
   let nameWidth = s.label.length;
-  if (isBase) {
-    entries.push({ text: " BASE", style: { fg: "ui.help_key_fg", bold: true } });
-    nameWidth += 5;
-  }
-  if (s.sharedWorktree || countSiblingsAtRoot(s.root) > 1) {
-    entries.push({ text: " ⇄", style: { fg: "ui.menu_disabled_fg" } });
-    nameWidth += 2;
-  }
   if (isDiscovered) {
     entries.push({
       text: " · on-disk",
@@ -737,13 +832,7 @@ function buildPreviewEntries(
   }
   const activeId = editor.activeWindow();
   const isActive = s.id === activeId;
-  const isBase = s.id === 1;
   const stateText = isActive ? "ACT" : STATE_GLYPH[s.state].trim();
-  // Count siblings sharing the same `root`. The set includes
-  // `s` itself; `> 1` means at least one other session lives at
-  // the same path (shared-worktree mode, or two sessions
-  // explicitly aimed at the same directory).
-  const sharedCount = countSiblingsAtRoot(s.root);
   const headerEntries: { text: string; style?: Record<string, unknown> }[] = [
     {
       text: stateText,
@@ -754,40 +843,13 @@ function buildPreviewEntries(
     { text: "  " },
     { text: ageString(s.createdAt), style: { fg: "ui.menu_disabled_fg" } },
   ];
-  if (isBase) {
-    // BASE badge in the preview — the long-form counterpart to
-    // the list-row badge, with an inline explanation so the user
-    // doesn't have to wonder why Stop / Archive / Delete are
-    // greyed out.
+  if (!s.discovered && !ownsWorktree(s)) {
+    // In-place / launch session: runs inside a real checkout, owns no
+    // dedicated worktree. Surfaced so the user knows Archive doesn't
+    // apply (Delete just forgets it, leaving the directory untouched).
     headerEntries.push(
       { text: "  " },
-      {
-        text: "BASE",
-        style: { fg: "ui.help_key_fg", bold: true },
-      },
-      { text: " — editor session", style: { fg: "ui.menu_disabled_fg", italic: true } },
-    );
-  }
-  if (sharedCount > 1) {
-    headerEntries.push(
-      { text: "  " },
-      {
-        text: `SHARED ×${sharedCount}`,
-        style: { fg: "ui.status_error_indicator_fg", bold: true },
-      },
-    );
-  } else if (s.sharedWorktree) {
-    // Single-session shared-worktree mode (the user opted out of
-    // a dedicated worktree even though no second session is on
-    // this root yet). Still worth surfacing so the user knows
-    // why Archive / Delete refuse to run a `git worktree
-    // remove` here.
-    headerEntries.push(
-      { text: "  " },
-      {
-        text: "SHARED",
-        style: { fg: "ui.menu_disabled_fg", italic: true },
-      },
+      { text: "in-place", style: { fg: "ui.menu_disabled_fg", italic: true } },
     );
   }
   return [
@@ -798,16 +860,15 @@ function buildPreviewEntries(
   ];
 }
 
-/// Return the number of orchestrator sessions whose `root`
-/// equals `root`. Used to surface "SHARED ×N" in the preview
-/// pane and to refuse Archive / Delete on a shared root
-/// while another session still lives there.
-function countSiblingsAtRoot(root: string): number {
-  let n = 0;
-  for (const s of orchestratorSessions.values()) {
-    if (s.root === root) n += 1;
-  }
-  return n;
+// A session "owns" a removable git worktree when it was created as a
+// dedicated `git worktree add` (project path set, not a shared/in-place
+// root) or was discovered on disk via `git worktree list`. Only these
+// have a worktree to `git worktree remove`/`move`. The launch session
+// (the dir the editor was started in) and in-place sessions run inside
+// a real checkout, so Archive (which moves the worktree) doesn't apply
+// and Delete simply forgets the session without touching the directory.
+function ownsWorktree(s: AgentSession): boolean {
+  return !!s.discovered || (!!s.projectPath && !s.sharedWorktree);
 }
 
 // =============================================================================
@@ -856,11 +917,15 @@ function selectedSessions(): number[] {
 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;
+  // Stop kills the agent process group — only meaningful for a live
+  // session that actually spawned one (never the launch session, which
+  // has no agent terminal, so signalling it can't touch the editor).
+  if (action === "stop") return !s.discovered && id > 0 && !!s.terminalId;
+  // Delete forgets any session. When it owns a worktree the worktree is
+  // removed too; otherwise (launch/in-place) it's just dropped.
+  if (action === "delete") return id > 0 || !!s.discovered;
+  // Archive moves the worktree to the graveyard, so it needs one.
+  return ownsWorktree(s);
 }
 
 function eligibleSelected(action: BulkAction): number[] {
@@ -899,9 +964,9 @@ function maxListRowsForScreen(): number {
   // 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);
+  // Trivial-filter + Filter + separator + header = 7) = 14. Floor at
+  // MIN_LIST_ROWS so a tiny terminal still shows something.
+  return Math.max(MIN_LIST_ROWS, panelH - 14);
 }
 
 // Compose the right-hand preview pane. Normally it shows info
@@ -961,13 +1026,13 @@ 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 = 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;
+  // Trivial-filter (1) + Filter (1) + separator (1) + header (1) +
+  // list (listVisibleRows) = listVisibleRows + 7. Preview inside its
+  // borders = button row (1) + spacer (1) + embedRows, so embedRows
+  // must equal listVisibleRows + 5. When details ARE shown, two info
+  // rows + a spacer eat three more lines — `_DETAILS_CHROME_ROWS`
+  // accounts for that.
+  const totalEmbedBase = (openDialog?.listVisibleRows ?? MIN_LIST_ROWS) + 5;
   const detailsOn = openDialog?.showDetails ?? false;
   const _DETAILS_CHROME_ROWS = 3; // 2 info rows + 1 spacer
   const embedRows = Math.max(
@@ -1050,17 +1115,18 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
   // same conditions that `stopSelectedSession`, `enterConfirm`,
   // and the lifecycle handlers already check internally.
   //
-  //  * Stop: refused on the base session (id 1).
-  //  * Archive / Delete: also refused on the base session, plus
-  //    when this session shares its worktree with the project
-  //    root (no `git worktree` entry to remove) or shares a root
-  //    with other live sessions (would yank disk out from
-  //    under them).
-  const isBase = s.id === 1;
-  const siblings = countSiblingsAtRoot(s.root);
-  const sharesRoot = siblings > 1 || s.sharedWorktree;
-  const stopDisabled = isBase;
-  const lifecycleDisabled = isBase || sharesRoot;
+  //  * Stop: only a live session with an agent terminal can be
+  //    stopped (the launch session has none).
+  //  * Archive: needs an owned worktree to move to the graveyard.
+  //  * Delete: forgets the session, removing the worktree only when one
+  //    is owned (otherwise the directory is left untouched).
+  //  * Archive/Delete are both refused on the last live window — the
+  //    editor must always host at least one.
+  const hasWorktree = ownsWorktree(s);
+  const isLastWindow = s.id > 0 && liveWindowCount() <= 1;
+  const stopDisabled = s.discovered || !s.terminalId;
+  const archiveDisabled = !hasWorktree || isLastWindow;
+  const deleteDisabled = isLastWindow;
   const buttonRow = row(
     button("Visit", { intent: "primary", key: "visit" }),
     spacer(2),
@@ -1069,12 +1135,12 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
     spacer(2),
     button("Stop", { key: "stop", disabled: stopDisabled }),
     spacer(2),
-    button("Archive", { key: "archive", disabled: lifecycleDisabled }),
+    button("Archive", { key: "archive", disabled: archiveDisabled }),
     spacer(2),
     button("Delete", {
       intent: "danger",
       key: "delete",
-      disabled: lifecycleDisabled,
+      disabled: deleteDisabled,
     }),
   );
   const embedWidget = windowEmbed({
@@ -1091,13 +1157,12 @@ function buildPreviewPane(s: AgentSession | undefined): WidgetSpec {
         embedWidget,
       )
     : col(buttonRow, spacer(0), embedWidget);
-  // Surface BASE in the preview section label so it's always visible
-  // (the list-row badge gets truncated at 25% column width). The
-  // base session is the editor process itself — closing or moving
-  // its worktree would close the editor / break the user's current
-  // tree, so Stop / Archive / Delete refuse against it.
-  const sectionLabel = isBase
-    ? `${s.label}  —  BASE (editor session)`
+  // Surface the launch session in the preview label so it's always
+  // visible (the list-row badge gets truncated at 25% column width).
+  // It's the dir the editor was started in — informational only; it's
+  // deletable like any other session once another window exists.
+  const sectionLabel = s.id === 1
+    ? `${s.label}  —  launch session`
     : s.label;
   return labeledSection({
     label: sectionLabel,
@@ -1270,14 +1335,9 @@ function buildBulkPane(): WidgetSpec {
   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)) {
+    if (!ss.discovered && !ownsWorktree(ss)) {
       rowParts.push({
-        text: "  · shared worktree",
+        text: "  · in-place (forgotten, not removed)",
         style: { fg: "ui.menu_disabled_fg", italic: true },
       });
     } else if (ss.discovered) {
@@ -1435,6 +1495,23 @@ function buildOpenSpec(): WidgetSpec {
     }),
     flexSpacer(),
   );
+  // Content filter checkbox, beneath the worktree one. The flag is
+  // `hideTrivial`, but the checkbox reads as an opt-in "show" toggle to
+  // match the worktree row: unchecked (default) hides the empty /
+  // single-file shells, checking it reveals them. Inert during confirm.
+  const trivialKey = editor.getKeybindingLabel(
+    "orchestrator_toggle_trivial",
+    OPEN_MODE,
+  );
+  const trivialLabel = trivialKey
+    ? `Show empty/1-file sessions   (${trivialKey})`
+    : "Show empty/1-file sessions";
+  const trivialFilterRow = row(
+    toggle(!openDialog.hideTrivial, trivialLabel, {
+      key: openDialog.pendingConfirm !== null ? undefined : "hide-trivial",
+    }),
+    flexSpacer(),
+  );
 
   return col(
     {
@@ -1490,6 +1567,7 @@ function buildOpenSpec(): WidgetSpec {
           ),
           projectControlRow,
           worktreeFilterRow,
+          trivialFilterRow,
           filterInput,
           sessionsSeparator(),
           sessionsColumnHeader(),
@@ -1617,6 +1695,9 @@ function refreshOpenDialog(): void {
 function openControlRoom(): void {
   if (openPanel) return;
   reconcileSessions();
+  // Summarise on-disk session content up front so the trivial filter
+  // has data on the first render.
+  scanSessionContent();
   const activeId = editor.activeWindow();
   // Seed with the screen-max; buildOpenSpec refits to the session
   // count on the first render (and every render after).
@@ -1637,6 +1718,7 @@ function openControlRoom(): void {
     scope: lastOpenScope,
     selectedIds: new Set<number>(),
     showWorktrees: lastShowWorktrees,
+    hideTrivial: lastHideTrivial,
     bulkInFlight: null,
   };
   openDialog.filteredIds = filterSessions("");
@@ -1686,7 +1768,7 @@ function closeOpenDialog(): void {
 // live window).
 function stopOne(id: number): boolean {
   const s = orchestratorSessions.get(id);
-  if (!s || id <= 0 || id === 1 || s.discovered) return false;
+  if (!s || id <= 0 || s.discovered || !s.terminalId) return false;
   editor.signalWindow(id, "SIGTERM");
   // SIGKILL fallback for agents that ignore SIGTERM. The host's
   // signalWindow is idempotent on already-exited process groups, so
@@ -1776,7 +1858,21 @@ function pickNextActiveSession(excludeId: number): number {
   for (const sid of orchestratorSessions.keys()) {
     if (sid !== excludeId && sid > 0) return sid;
   }
-  return 1;
+  // No other live window. Callers guard against closing the last
+  // window before reaching here, so this is a safe no-op swap (id 1
+  // is no longer guaranteed to exist — it's deletable like any other).
+  return excludeId;
+}
+
+// Number of real editor windows. Discovered on-disk rows have negative
+// ids and are not windows. The editor must always host at least one
+// window, so deleting/archiving the last live window is refused.
+function liveWindowCount(): number {
+  let n = 0;
+  for (const s of orchestratorSessions.values()) {
+    if (s.id > 0) n += 1;
+  }
+  return n;
 }
 
 // Resolve the *main* repo root a session's worktree belongs to, so
@@ -1809,7 +1905,17 @@ interface LifecycleResult {
 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" };
+  // Archive moves the worktree to the graveyard — only sessions that
+  // own one can be archived. A launch/in-place session has no separate
+  // worktree, so there's nothing to move; use Delete to forget it.
+  if (!ownsWorktree(s)) {
+    return { ok: false, err: "no worktree to archive — use Delete to forget this session" };
+  }
+  // The editor must keep at least one window; closing the last one
+  // would orphan the move. Refuse before touching the worktree.
+  if (s.id > 0 && liveWindowCount() <= 1) {
+    return { ok: false, err: "cannot archive the last window — open another session first" };
+  }
   const repoRoot = await worktreeRepoRoot(s);
   if (!repoRoot) return { ok: false, err: "not a git repository" };
 
@@ -1820,7 +1926,7 @@ async function archiveOne(id: number): Promise<LifecycleResult> {
     if (id === editor.activeWindow()) {
       editor.setActiveWindow(pickNextActiveSession(id));
     }
-    editor.signalWindow(id, "SIGKILL");
+    if (s.terminalId) editor.signalWindow(id, "SIGKILL");
     editor.closeWindow(id);
     // Brief settle so the filesystem reflects the pty's exit before
     // we move the worktree out from under it.
@@ -2072,52 +2178,66 @@ async function buildSyncSnapshot(repoRoot: string): Promise<unknown> {
   };
 }
 
-// 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.
+// Delete a single session: close the editor session, then — only when
+// the session owns a worktree — `git worktree remove --force` to drop
+// it from disk (and prune any archive-manifest entry). A launch or
+// in-place session owns no worktree, so Delete just forgets it: the
+// window closes and the directory is left untouched (a fresh session
+// can always be opened there again). Handles discovered on-disk
+// worktrees (no window to close). Does NOT trigger sync — the caller
+// batches it.
 async function deleteOne(id: number): Promise<LifecycleResult> {
   const s = orchestratorSessions.get(id);
   if (!s) return { ok: false, err: "session gone" };
-  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" };
+  // The editor must keep at least one window. Refuse before any
+  // close/worktree-removal so a removable session can't `git worktree
+  // remove` the tree the live editor is still sitting in.
+  if (s.id > 0 && liveWindowCount() <= 1) {
+    return { ok: false, err: "cannot delete the last window — open another session first" };
+  }
+  const removable = ownsWorktree(s);
 
   if (!s.discovered && id > 0) {
-    // close_window refuses to close the active window, so swap away.
+    // close_window refuses to close the active (and the last) window,
+    // so swap away first. SIGKILL only when there's an agent terminal —
+    // a launch/in-place session has none, and signalling it must never
+    // touch the editor itself.
     if (id === editor.activeWindow()) {
       editor.setActiveWindow(pickNextActiveSession(id));
     }
-    editor.signalWindow(id, "SIGKILL");
+    if (s.terminalId) editor.signalWindow(id, "SIGKILL");
     editor.closeWindow(id);
-    await editor.delay(250);
+    if (removable) await editor.delay(250);
   }
 
-  // `--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", s.root],
-    repoRoot,
-  );
-  if (removeRes.exit_code !== 0) {
-    return {
-      ok: false,
-      err: lastNonEmptyLine(removeRes.stderr) || "worktree remove failed",
-      repoRoot,
-    };
-  }
+  let repoRoot: string | undefined;
+  if (removable) {
+    const rr = await worktreeRepoRoot(s);
+    if (!rr) return { ok: false, err: "not a git repository" };
+    repoRoot = rr;
+    // `--force` because the worktree may have unstaged changes the user
+    // explicitly chose to discard via the confirm step.
+    const removeRes = await spawnCollect(
+      "git",
+      ["-C", rr, "worktree", "remove", "--force", s.root],
+      rr,
+    );
+    if (removeRes.exit_code !== 0) {
+      return {
+        ok: false,
+        err: lastNonEmptyLine(removeRes.stderr) || "worktree remove failed",
+        repoRoot,
+      };
+    }
 
-  // Drop the matching manifest entry too, in case the session was
-  // already archived (delete-from-archived 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 !== s.label);
-  if (manifest.sessions.length !== before) {
-    saveArchiveManifest(repoRoot, manifest);
+    // Drop the matching manifest entry too, in case the session was
+    // already archived (delete-from-archived drops dormant sessions).
+    const manifest = loadArchiveManifest(rr);
+    const before = manifest.sessions.length;
+    manifest.sessions = manifest.sessions.filter((e) => e.label !== s.label);
+    if (manifest.sessions.length !== before) {
+      saveArchiveManifest(rr, manifest);
+    }
   }
 
   if (s.discovered) {
@@ -2237,6 +2357,11 @@ editor.defineMode(
     // surfaces discovered on-disk worktree rows. Rebindable, same as
     // the scope toggle.
     ["M-t", "orchestrator_toggle_worktrees"],
+    // Alt+I toggles "Show empty/1-file sessions" — reveals the trivial
+    // restored shells hidden by default. Rebindable, same as the others.
+    // (Alt+E is unavailable: it's the Edit menu's mnemonic, which the
+    // menu bar claims before the picker's mode keymap sees it.)
+    ["M-i", "orchestrator_toggle_trivial"],
   ],
   true,
   true,
@@ -2328,6 +2453,30 @@ function toggleShowWorktrees(): void {
 
 registerHandler("orchestrator_toggle_worktrees", toggleShowWorktrees);
 
+// Flip "Show empty/1-file sessions" — reveal/hide the trivial restored
+// shells. Preserves the highlighted row across the re-filter where
+// possible; drops now-hidden rows from the bulk selection. Shared by the
+// Alt+I chord and the checkbox click.
+function toggleHideTrivial(): void {
+  if (!openDialog) return;
+  openDialog.hideTrivial = !openDialog.hideTrivial;
+  lastHideTrivial = openDialog.hideTrivial;
+  const prevId = openDialog.filteredIds[openDialog.selectedIndex];
+  openDialog.filteredIds = filterSessions(openDialog.filter.value);
+  // Hiding trivial rows shouldn't leave them lingering in the selection.
+  if (openDialog.hideTrivial) {
+    const visible = new Set(openDialog.filteredIds);
+    for (const id of [...openDialog.selectedIds]) {
+      if (!visible.has(id)) openDialog.selectedIds.delete(id);
+    }
+  }
+  const nextIdx = prevId !== undefined ? openDialog.filteredIds.indexOf(prevId) : -1;
+  openDialog.selectedIndex = nextIdx >= 0 ? nextIdx : 0;
+  refreshOpenDialog();
+}
+
+registerHandler("orchestrator_toggle_trivial", toggleHideTrivial);
+
 // =============================================================================
 // New-session floating form
 // =============================================================================
@@ -3904,36 +4053,31 @@ function enterConfirm(action: "stop" | "archive" | "delete"): void {
   if (!openDialog || !openPanel) return;
   const id = openDialog.filteredIds[openDialog.selectedIndex];
   if (typeof id !== "number" || id <= 0) return;
-  // Refuse Archive / Delete on a shared root while other
-  // sessions still live there. Both actions either move
-  // (`git worktree move`) or remove (`git worktree remove`)
-  // the on-disk path — doing that under another running
-  // session would yank the rug out from under it. Stop is
-  // fine: it only signals THIS session's process group, no
-  // disk operation.
+  // Archive moves the worktree to the graveyard, so it only applies to
+  // a session that owns one. A launch/in-place session runs inside a
+  // real checkout with no `git worktree` entry — Archive would have
+  // nothing to move (and must never rm-rf the user's actual project).
+  // Delete forgets the session and removes the worktree only when one
+  // is owned. Both refuse the last live window (the editor must keep at
+  // least one) — surface that before the confirm step.
   if (action === "archive" || action === "delete") {
     const session = orchestratorSessions.get(id);
-    if (session) {
-      const siblings = countSiblingsAtRoot(session.root);
-      if (siblings > 1) {
-        setDialogError(
-          `cannot ${action} session [${id}] ${session.label} — ${siblings - 1} other session(s) share this worktree; close them first`,
-        );
-        refreshOpenDialog();
-        return;
-      }
-      if (session.sharedWorktree) {
-        // Single-session shared-worktree mode: there's no
-        // `git worktree` entry to remove for this session.
-        // Block both lifecycle actions so we don't run
-        // `git worktree remove` against a non-worktree path
-        // and rm-rf the user's actual project directory.
-        setDialogError(
-          `cannot ${action} session [${id}] ${session.label} — session shares its working tree with the project root; close it via the editor instead`,
-        );
-        refreshOpenDialog();
-        return;
-      }
+    if (session && session.id > 0 && liveWindowCount() <= 1) {
+      setDialogError(
+        `cannot ${action} session [${id}] ${session.label} — it's the last window; open another session first`,
+      );
+      refreshOpenDialog();
+      return;
+    }
+  }
+  if (action === "archive") {
+    const session = orchestratorSessions.get(id);
+    if (session && !ownsWorktree(session)) {
+      setDialogError(
+        `cannot archive session [${id}] ${session.label} — it has no dedicated worktree; use Delete to forget it`,
+      );
+      refreshOpenDialog();
+      return;
     }
   }
   openDialog.pendingConfirm = { action, ids: [id] };
@@ -4098,7 +4242,16 @@ editor.on("widget_event", (e) => {
       refreshOpenDialog();
       return;
     }
-    if (e.event_type === "select" && e.widget_key === "sessions") {
+    // List selection. Keyboard nav fires this with `widget_key`
+    // "sessions" (the list's own key); a mouse click on a row fires it
+    // with `widget_key` set to the clicked item's key, carrying the
+    // list key in `payload.list_key` instead — accept both so clicking a
+    // row selects it (highlight + preview) just like arrowing to it.
+    if (
+      e.event_type === "select" &&
+      (e.widget_key === "sessions" ||
+        ((e.payload ?? {}) as Record<string, unknown>).list_key === "sessions")
+    ) {
       const payload = (e.payload ?? {}) as Record<string, unknown>;
       const idx = payload.index;
       if (typeof idx === "number") {
@@ -4168,6 +4321,12 @@ editor.on("widget_event", (e) => {
       toggleShowWorktrees();
       return;
     }
+    if (e.event_type === "toggle" && e.widget_key === "hide-trivial") {
+      // Same pattern as the worktree toggle: route the click through the
+      // shared flip so the checkbox and the Alt+I chord stay in sync.
+      toggleHideTrivial();
+      return;
+    }
     if (e.event_type === "activate" && e.widget_key === "stop") {
       enterConfirm("stop");
       return;
@@ -4258,10 +4417,6 @@ function killSelected(): void {
     editor.setStatus("Orchestrator: select a session row first");
     return;
   }
-  if (id === 1) {
-    editor.setStatus("Orchestrator: cannot kill the base session");
-    return;
-  }
   if (id === editor.activeWindow()) {
     editor.setStatus(
       "Orchestrator: dive elsewhere first, then kill this session",