fix(orchestrator): make Open dialog cross-project

Sessions are inherently cross-project — each row can carry its
own `project_path` — so scoping the picker to the active
window's project hid exactly the rows the user came to switch
into, and visiting a session in another project silently
changed the next dialog's row count.

Drops `currentProjectOnly` / `showAllProjects`, the Alt+P
toggle, and the `(project: …)` header. Adds an e2e repro that
opens the dialog with two project-tagged sessions and asserts
both surface regardless of the active window's project.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sinelaw

crates/fresh-editor/plugins/orchestrator.ts

@@ -256,19 +256,6 @@ 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;
-  // When `false` (the default), the list shows only sessions
-  // whose `projectPath` matches `currentProject` (plus the
-  // base session). When `true`, every session is shown
-  // regardless of project, with the project path rendered
-  // alongside the label so cross-project rows are
-  // distinguishable. Toggle via Alt+P inside the dialog.
-  showAllProjects: boolean;
-  // Resolved canonical project root for the editor's cwd;
-  // probed once at openControlRoom time. Empty string for
-  // non-git launches (the path-comparison fallback in
-  // `filterSessions` then matches every session that has no
-  // recorded projectPath).
-  currentProject: string;
 }
 let openDialog: OpenDialogState | null = null;
 let openPanel: FloatingWidgetPanel | null = null;
@@ -345,38 +332,12 @@ function ageString(createdAt: number): string {
 // then ties broken by label length so shorter matches surface
 // first. Empty needle returns the full list in numeric-id order.
 //
-// With `currentProjectOnly: true` (the default — see
-// `openDialog.showAllProjects`), only sessions whose
-// `projectPath` matches the editor's resolved project survive
-// the filter. The base session (id 1) is always included even
-// if its `projectPath` is missing, so a fresh launch never
-// shows an empty list.
-function filterSessions(
-  needle: string,
-  options?: { currentProjectOnly?: boolean; currentProject?: string },
-): number[] {
+// 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.
+function filterSessions(needle: string): number[] {
   reconcileSessions();
-  const currentProjectOnly = options?.currentProjectOnly ?? true;
-  const currentProject = options?.currentProject ?? "";
-  const matchesProject = (s: AgentSession): boolean => {
-    if (!currentProjectOnly) return true;
-    if (s.id === 1) return true; // base session always visible
-    if (!currentProject) return true;
-    if (s.projectPath === currentProject) return true;
-    // Fall-back: legacy sessions without `projectPath` are
-    // shown in every project view rather than hidden — the
-    // alternative (drop them from the list entirely) would
-    // make pre-Phase 5 sessions inaccessible without an
-    // explicit toggle.
-    if (s.projectPath == null) return true;
-    return false;
-  };
-  const ids = Array.from(orchestratorSessions.keys())
-    .filter((id) => {
-      const s = orchestratorSessions.get(id);
-      return !!s && matchesProject(s);
-    })
-    .sort((a, b) => a - b);
+  const ids = Array.from(orchestratorSessions.keys()).sort((a, b) => a - b);
   if (!needle) return ids;
   const n = needle.toLowerCase();
   type Scored = { id: number; score: number; len: number };
@@ -902,14 +863,6 @@ function buildOpenSpec(): WidgetSpec {
         ],
       }
     : null;
-  // Header scope indicator: surfaces the current project filter
-  // (or "all projects") so the user knows what set the list is
-  // drawing from before they start filtering on top.
-  const scopeText = openDialog.showAllProjects
-    ? "all projects"
-    : openDialog.currentProject
-    ? `project: ${openDialog.currentProject}`
-    : "current project";
   return col(
     {
       kind: "raw",
@@ -919,10 +872,6 @@ function buildOpenSpec(): WidgetSpec {
             text: "ORCHESTRATOR :: Sessions",
             style: { fg: "ui.popup_border_fg", bold: true },
           },
-          {
-            text: `  (${scopeText})`,
-            style: { fg: "editor.whitespace_indicator_fg", italic: true },
-          },
         ]),
       ],
     },
@@ -994,10 +943,6 @@ function buildOpenSpec(): WidgetSpec {
         { keys: "↑↓", label: "nav" },
         { keys: "Enter", label: "dive" },
         { keys: "Tab", label: "focus" },
-        {
-          keys: "Alt+P",
-          label: openDialog.showAllProjects ? "this project" : "all projects",
-        },
         { keys: "Esc", label: "close" },
       ]),
       flexSpacer(),
@@ -1053,10 +998,7 @@ function clearDialogError(): void {
 
 function refreshOpenDialog(): void {
   if (!openPanel || !openDialog) return;
-  openDialog.filteredIds = filterSessions(openDialog.filter.value, {
-    currentProjectOnly: !openDialog.showAllProjects,
-    currentProject: openDialog.currentProject,
-  });
+  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
   // the end of the list.
@@ -1080,21 +1022,6 @@ function openControlRoom(): void {
   reconcileSessions();
   const activeId = editor.activeWindow();
   const listVisibleRows = openListVisibleRows();
-  // Resolve the editor's "current project" for the dialog's
-  // default scope. The right source is the ACTIVE window's
-  // `projectPath` — Window is the unit of project ownership in
-  // this editor (each Window has its own root, LSP, file
-  // explorer; switching active_window swaps all of that
-  // atomically). So when the user is currently diving in a
-  // session for project A and opens the picker, A's sessions
-  // should be the default view; if they then dive into a
-  // project-B session and reopen the picker, B becomes the
-  // default. Fall back to `root` for windows that pre-date
-  // the Project Path field, and to an empty string if even
-  // that isn't usable (the filter then matches every session
-  // with no recorded projectPath).
-  const activeSession = orchestratorSessions.get(activeId);
-  const currentProject = activeSession?.projectPath ?? activeSession?.root ?? "";
   openDialog = {
     filter: { value: "", cursor: 0 },
     filteredIds: [],
@@ -1115,14 +1042,8 @@ function openControlRoom(): void {
     showDetails: false,
     inFlight: null,
     lastError: null,
-    showAllProjects: false,
-    currentProject,
   };
-  // Apply the initial filter (current-project view by default).
-  openDialog.filteredIds = filterSessions("", {
-    currentProjectOnly: !openDialog.showAllProjects,
-    currentProject,
-  });
+  openDialog.filteredIds = filterSessions("");
   const activeIdx = openDialog.filteredIds.indexOf(activeId);
   openDialog.selectedIndex = activeIdx >= 0 ? activeIdx : 0;
   openPanel = new FloatingWidgetPanel();
@@ -1684,23 +1605,11 @@ async function deleteConfirmedSession(): Promise<void> {
 // since OPEN_MODE doesn't claim them here.
 editor.defineMode(
   OPEN_MODE,
-  [
-    ["M-n", "orchestrator_open_new_from_picker"],
-    // `Alt+P` toggles "all projects" vs "this project only".
-    // The hint footer reflects the current state so users
-    // discover the toggle without RTFM.
-    ["M-p", "orchestrator_open_toggle_all_projects"],
-  ],
+  [["M-n", "orchestrator_open_new_from_picker"]],
   true,
   true,
 );
 
-registerHandler("orchestrator_open_toggle_all_projects", () => {
-  if (!openDialog) return;
-  openDialog.showAllProjects = !openDialog.showAllProjects;
-  refreshOpenDialog();
-});
-
 registerHandler("orchestrator_open_new_from_picker", () => {
   if (!openDialog) return;
   closeOpenDialog();
@@ -3154,10 +3063,7 @@ editor.on("widget_event", (e) => {
       // when possible — if the previously selected id is still in
       // the new filtered set, keep it; otherwise reset to 0.
       const prevId = openDialog.filteredIds[openDialog.selectedIndex];
-      const next = filterSessions(value, {
-        currentProjectOnly: !openDialog.showAllProjects,
-        currentProject: openDialog.currentProject,
-      });
+      const next = filterSessions(value);
       openDialog.filteredIds = next;
       const nextIdx = prevId !== undefined ? next.indexOf(prevId) : -1;
       openDialog.selectedIndex = nextIdx >= 0 ? nextIdx : 0;

crates/fresh-editor/tests/e2e/plugins/mod.rs

@@ -40,6 +40,7 @@ pub mod live_diff;
 pub mod load_from_buffer;
 pub mod lsp_find_references;
 pub mod markdown_source;
+pub mod orchestrator_open_cross_project;
 pub mod package_manager;
 pub mod plugin;
 pub mod plugin_keybinding_execution;

crates/fresh-editor/tests/e2e/plugins/orchestrator_open_cross_project.rs

@@ -0,0 +1,92 @@
+//! The Orchestrator Open dialog must list every session, regardless of
+//! which project the active window happens to point at.
+//!
+//! Sessions are inherently cross-project — each row can have its own
+//! `project_path` — so scoping the picker to "current project" hides
+//! exactly the rows the user came to switch into. The visible symptom
+//! is that opening the dialog, visiting a session in another project,
+//! then reopening the dialog changes the visible row count, because
+//! the dialog's notion of "current project" is recomputed from the
+//! newly-active window every time it opens.
+
+use crate::common::harness::EditorTestHarness;
+use crossterm::event::{KeyCode, KeyModifiers};
+use fresh_core::api::PluginCommand;
+use fresh_core::WindowId;
+use serde_json::Value;
+use std::path::Path;
+
+const WIDTH: u16 = 160;
+const HEIGHT: u16 = 40;
+
+const LABEL_B: &str = "zebra-beta-xr";
+
+fn run_palette(harness: &mut EditorTestHarness, command_name: &str) {
+    harness
+        .send_key(KeyCode::Char('p'), KeyModifiers::CONTROL)
+        .unwrap();
+    harness.render().unwrap();
+    harness.type_text(command_name).unwrap();
+    harness.render().unwrap();
+    harness
+        .send_key(KeyCode::Enter, KeyModifiers::NONE)
+        .unwrap();
+    harness.render().unwrap();
+}
+
+fn set_orch_project_path(harness: &mut EditorTestHarness, project_path: &Path) {
+    harness
+        .editor_mut()
+        .handle_plugin_command(PluginCommand::SetWindowState {
+            plugin_name: "orchestrator".into(),
+            key: "project_path".into(),
+            value: Some(Value::String(project_path.to_string_lossy().into_owned())),
+        })
+        .unwrap();
+}
+
+#[test]
+fn open_dialog_lists_sessions_from_all_projects() {
+    let mut harness = EditorTestHarness::with_temp_project(WIDTH, HEIGHT).unwrap();
+
+    // Project A: the harness's temp project root, owned by the base
+    // window (id 1, active at boot).
+    let proj_a = harness.project_dir().unwrap().canonicalize().unwrap();
+    set_orch_project_path(&mut harness, &proj_a);
+
+    // Project B: a separate tempdir, owned by a second window we
+    // create explicitly. Per-session plugin state always writes to
+    // the *active* window, so we set B active before tagging.
+    let proj_b_dir = tempfile::TempDir::new().unwrap();
+    let proj_b = proj_b_dir.path().canonicalize().unwrap();
+    let win_b = harness
+        .editor_mut()
+        .create_window_at(proj_b.clone(), LABEL_B.into());
+    harness.editor_mut().set_active_window(win_b);
+    set_orch_project_path(&mut harness, &proj_b);
+
+    // Switch back to A so the dialog opens with currentProject = A —
+    // the case the bug repro turns on.
+    harness.editor_mut().set_active_window(WindowId(1));
+    harness.render().unwrap();
+
+    run_palette(&mut harness, "Orchestrator: Open");
+    harness
+        .wait_until(|h| h.screen_to_string().contains("Sessions ("))
+        .expect("Orchestrator Open dialog should appear");
+
+    let screen = harness.screen_to_string();
+    assert!(
+        screen.contains(LABEL_B),
+        "Project B's session must be listed in the open dialog while the \
+         active window is in Project A — the picker is cross-project by \
+         design.\nScreen:\n{}",
+        screen,
+    );
+    assert!(
+        screen.contains("Sessions (2)"),
+        "Header count must reflect every session, not the project-filtered \
+         subset.\nScreen:\n{}",
+        screen,
+    );
+}