Keep the dock's search filter when you pick a workspace out of it

Filtering the orchestrator dock to a handful of workspaces and then
clicking one wiped the search: the list sprang back to every workspace
and the box reset to its placeholder, so working through a filtered set
meant retyping the needle for every workspace opened.

The dock clears its filter on blur so a stale needle can't silently hide
sessions on the next focus (F5). But a click — or Enter — on a row blurs
the dock only to hand the keyboard to the chosen session: it is acting
on the filtered list, not leaving it. Mark those dive paths so the blur
handler keeps the filter, and leave every other blur (Esc, an editor
click) clearing it as before, which keeps the one-key escape from a
stale filter intact.

Also adds an interactive tmux reproducer covering both gestures.

Author: claude

crates/fresh-editor/plugins/orchestrator.ts

@@ -820,6 +820,16 @@ function dockContentCols(dockWidth: number): number {
 // (dispatch_floating_widget_key) reads the panel focus directly to route
 // Enter/Esc/Space//'; this mirror is informational for the plugin.
 let dockFocus: "list" | "filter" = "list";
+// Set just before the dock blurs *because the user picked a workspace*
+// (a row click, Enter on the list, or attaching a discovered worktree
+// with `dive`). The `blur` handler clears the search filter so a stale
+// needle can't silently hide sessions on the next focus (F5) — but a
+// dive isn't "leaving the dock", it's acting on the very list the
+// filter produced. Wiping the needle there forces a retype for every
+// workspace picked out of a search. Consumed (and reset) by the next
+// `blur`; also reset on `focus` so an unconsumed flag can't leak into a
+// later, unrelated blur.
+let dockDiveBlur = false;
 // Full focused-widget mirror for the open dialog (both dock and
 // centered-picker modes). Updated from every `focus` widget_event.
 // Used by `toggleSelectCurrent` so a Space keypress while focus is
@@ -5051,6 +5061,9 @@ function diveDockSelectionFromClick(fromEdge: "top" | "bottom" | null): void {
     else editor.setActiveWindow(id);
   }
   // Hand keyboard focus to the activated window (mirror `dock_activate`).
+  // Picking a row is not "leaving the dock", so the search filter that
+  // produced this row survives the blur (see `dockDiveBlur`).
+  dockDiveBlur = true;
   dockBlurred = true;
   editor.floatingPanelControl(openPanel.id(), "blur", 0);
   editor.setEditorMode(null);
@@ -8978,6 +8991,8 @@ async function attachToWorktree(opts: {
     // (arrow-nav, row click) deliberately keep the dock focused, exactly
     // like switching to a live session does.
     if (opts.dive && dockMode && openPanel) {
+      // A dive out of the dock keeps the search filter (see `dockDiveBlur`).
+      dockDiveBlur = true;
       dockBlurred = true;
       editor.floatingPanelControl(openPanel.id(), "blur", 0);
       editor.setEditorMode(null);
@@ -9807,6 +9822,8 @@ editor.on("widget_event", (e) => {
       // leave, editor click, or an unhandled chord like Ctrl+P). The
       // dock stays visible; the host stops routing keys to it.
       if (dockMode) {
+        const wasDive = dockDiveBlur;
+        dockDiveBlur = false;
         dockBlurred = true;
         // Leaving the dock also closes the project dropdown so it
         // doesn't linger over the blurred dock.
@@ -9816,7 +9833,13 @@ editor.on("widget_event", (e) => {
         // "/gamma") otherwise silently hides sessions on the next
         // focus, with only the filter box as a clue — and there is no
         // one-key clear from the list. (See F5.)
-        if (openDialog.filter.value !== "") {
+        //
+        // A *dive* is the exception: clicking a row (or Enter on it) is
+        // acting on the filtered list, not abandoning it, so the needle
+        // stays put and the next workspace can be picked out of the same
+        // search without retyping it. Esc/editor-click still clear, so
+        // the one-key escape from a stale filter is unchanged.
+        if (!wasDive && openDialog.filter.value !== "") {
           openDialog.filter.value = "";
           openDialog.filter.cursor = 0;
           dockFocus = "list";
@@ -9849,6 +9872,9 @@ editor.on("widget_event", (e) => {
         pickerFocusKey = e.widget_key;
       }
       if (dockMode) {
+        // A dive that never produced a `blur` (already blurred, say)
+        // must not leave the flag armed for the next, unrelated one.
+        dockDiveBlur = false;
         const wasBlurred = dockBlurred;
         dockBlurred = false;
         dockFocus = e.widget_key === "filter" ? "filter" : "list";
@@ -9916,6 +9942,9 @@ editor.on("widget_event", (e) => {
       if (typeof id === "number" && id > 0 && id !== editor.activeWindow()) {
         editor.setActiveWindow(id);
       }
+      // Same as the row click: the filter that surfaced this row is kept
+      // across the dive (see `dockDiveBlur`).
+      dockDiveBlur = true;
       dockBlurred = true;
       editor.floatingPanelControl(openPanel.id(), "blur", 0);
       editor.setEditorMode(null);

crates/fresh-editor/tests/e2e/orchestrator_dock.rs

@@ -1767,6 +1767,88 @@ fn dock_filter_clears_when_focus_leaves_so_reentry_shows_all() {
     h.assert_screen_contains("Search Tasks");
 }
 
+/// The F5 clear-on-leave must NOT fire when the user *picks* a workspace
+/// out of the filtered list. Enter on a row (and a click on one) blurs the
+/// dock to hand the keyboard to the chosen session — a dive, not a
+/// departure — so the search that produced the row has to survive it.
+/// Wiping it there meant retyping the needle for every workspace opened
+/// out of one search, which is the common case with a long list.
+#[test]
+fn dock_filter_survives_diving_into_a_filtered_workspace() {
+    let (_tmp, root) = setup_project("alphaproj");
+    let mut h =
+        EditorTestHarness::with_config_and_working_dir(120, 32, Default::default(), root.clone())
+            .unwrap();
+    h.editor_mut()
+        .create_window_at(root.join("wt-beta"), "beta".to_string());
+    h.editor_mut()
+        .create_window_at(root.join("wt-gamma"), "gamma".to_string());
+    h.render().unwrap();
+    open_dock(&mut h);
+    h.wait_until(|h| {
+        let s = h.screen_to_string();
+        s.contains("beta") && s.contains("gamma")
+    })
+    .unwrap();
+
+    // Filter to "gamma"; "beta" drops out of the list.
+    h.send_key(KeyCode::Char('/'), KeyModifiers::NONE).unwrap();
+    h.type_text("gamma").unwrap();
+    h.wait_until(|h| !h.screen_to_string().contains("beta"))
+        .unwrap();
+
+    // Enter returns to the list, a second Enter dives into the highlighted
+    // "gamma" row — the dock blurs, handing the keyboard to that session.
+    h.send_key(KeyCode::Enter, KeyModifiers::NONE).unwrap();
+    h.send_key(KeyCode::Enter, KeyModifiers::NONE).unwrap();
+    h.wait_until(|h| !h.editor().is_dock_focused()).unwrap();
+
+    // The dive must leave the filter alone: "beta" stays hidden and the
+    // box still reads "gamma" (an emptied box shows the "Search Tasks"
+    // placeholder instead).
+    let after_dive = h.screen_to_string();
+    assert!(
+        !after_dive.contains("beta"),
+        "diving into a filtered workspace must keep the filter applied, but the \
+         filtered-out 'beta' row came back:\n{after_dive}"
+    );
+    assert!(
+        !after_dive.contains("Search Tasks"),
+        "diving into a filtered workspace must keep the search text, but the box \
+         fell back to its placeholder:\n{after_dive}"
+    );
+
+    // Re-focusing the dock finds the same filtered list, so the next
+    // workspace can be picked out of the search without retyping it.
+    h.send_key(KeyCode::Char('o'), KeyModifiers::ALT).unwrap();
+    h.wait_until(|h| h.editor().is_dock_focused()).unwrap();
+    let refocused = h.screen_to_string();
+    assert!(
+        !refocused.contains("beta"),
+        "re-entering the dock after a dive must show the still-filtered list:\n{refocused}"
+    );
+
+    // A click on a row is the same gesture as Enter, and keeps the filter
+    // for the same reason. (The row's own line, not the filter box, which
+    // also spells the needle — that one shares its row with "New Task".)
+    let gamma_row =
+        h.screen_to_string()
+            .lines()
+            .position(|l| l.contains("gamma") && !l.contains("New Task"))
+            .unwrap_or_else(|| panic!("no 'gamma' row:\n{}", h.screen_to_string())) as u16;
+    h.mouse_click(3, gamma_row).unwrap();
+    h.wait_until(|h| !h.editor().is_dock_focused()).unwrap();
+    let after_click = h.screen_to_string();
+    assert!(
+        !after_click.contains("beta"),
+        "clicking a filtered workspace must keep the filter applied:\n{after_click}"
+    );
+    assert!(
+        !after_click.contains("Search Tasks"),
+        "clicking a filtered workspace must keep the search text:\n{after_click}"
+    );
+}
+
 /// F6: the auto-generated session name is rooted in the project
 /// (`<project>-N`) rather than a bare `session-N`, so a dock row tells
 /// you which project a session belongs to.

scripts/interactive/dock_filter_select_tmux_repro.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+#
+# Interactive tmux repro — Orchestrator dock: does selecting a workspace from
+# a filtered list wipe the filter?
+#
+# Lays out a project with a handful of workspaces (created from an isolated
+# init.ts so the dock has enough rows for a filter to matter), opens the dock,
+# types a search needle, then activates a matching row two ways:
+#
+#   1. Enter on the highlighted row  ("dive in")
+#   2. A real mouse click on a row    (SGR mouse report)
+#
+# After each, it re-focuses the dock and reports whether the needle survived.
+# Expected after the fix: the filter is still applied and the search box still
+# reads the needle — selecting a workspace is not "leaving the dock".
+#
+# Usage:   scripts/interactive/dock_filter_select_tmux_repro.sh
+# Requires: tmux. Run from the repo root.
+
+set -uo pipefail
+
+REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+SESSION="fresh-dock-filter"
+BIN="$REPO/target/debug/fresh"
+OUT="$(mktemp -d /tmp/fresh-dock-filter-out.XXXX)"
+WORK="$(mktemp -d /tmp/fresh-dock-filter-work.XXXX)"
+PASS=0
+FAIL=0
+
+cleanup() { tmux kill-session -t "$SESSION" 2>/dev/null || true; }
+trap cleanup EXIT
+
+note() { printf '\033[36m• %s\033[0m\n' "$*"; }
+pass() { printf '\033[32m  PASS\033[0m %s\n' "$*"; PASS=$((PASS + 1)); }
+fail() { printf '\033[31m  FAIL\033[0m %s\n' "$*"; FAIL=$((FAIL + 1)); }
+
+S() { tmux send-keys -t "$SESSION" "$@"; }
+typ() { tmux send-keys -t "$SESSION" -l "$1"; }
+cap() { tmux capture-pane -t "$SESSION" -p; }
+shot() { cap > "$OUT/$1.txt"; }
+
+wait_for() { # pattern timeout_iters
+  local pat="$1" n="${2:-30}" i=0
+  while [ "$i" -lt "$n" ]; do
+    cap | grep -qE "$pat" && return 0
+    sleep 0.5
+    i=$((i + 1))
+  done
+  return 1
+}
+
+# Click cell (1-based col,row) with an SGR mouse press+release.
+click() { # col row
+  tmux send-keys -t "$SESSION" -l $'\033[<0;'"$1"';'"$2"'M'
+  tmux send-keys -t "$SESSION" -l $'\033[<0;'"$1"';'"$2"'m'
+}
+
+# 1-based pane row of the first line matching $1 (empty if absent).
+row_of() { cap | grep -nE "$1" | head -1 | cut -d: -f1; }
+
+# --- 0. build + workspace ----------------------------------------------------
+[ -x "$BIN" ] || { note "building fresh (debug)…"; (cd "$REPO" && cargo build --bin fresh) || exit 2; }
+
+note "workspace: $WORK"
+export HOME="$WORK/home"
+mkdir -p "$HOME/.config/fresh"
+mkdir -p "$WORK/proj" && (cd "$WORK/proj" && git init -q && git config user.email t@t && git config user.name t && printf 'root\n' > README.md && git add -A && git commit -qm init)
+for w in alpha beta gamma delta epsilon zeta eta theta; do
+  mkdir -p "$WORK/proj/$w" && printf '%s\n' "$w" > "$WORK/proj/$w/notes.md"
+done
+
+# Enough workspaces that the filter has something to hide.
+cat > "$HOME/.config/fresh/init.ts" <<TS
+for (const w of ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta"]) {
+  editor.createWindow("$WORK/proj/" + w, w);
+}
+TS
+
+# --- 1. launch ---------------------------------------------------------------
+cleanup
+tmux new-session -d -s "$SESSION" -x 200 -y 50
+S "cd '$WORK/proj' && HOME='$HOME' TERM=xterm-256color '$BIN' --no-restore README.md" Enter
+wait_for "Palette: Ctrl\+P" 60 || { note "editor did not start"; cap; exit 2; }
+sleep 1
+shot "00-boot"
+
+# --- 2. open + focus the dock ------------------------------------------------
+note "opening the orchestrator dock (Alt+O)"
+S M-o
+wait_for "gamma" 30 || { note "dock did not show the workspaces"; cap; exit 2; }
+sleep 0.5
+shot "01-dock-open"
+
+if cap | grep -q "epsilon" && cap | grep -q "gamma"; then
+  pass "dock lists the workspaces"
+else
+  fail "dock is missing workspaces"
+fi
+
+# --- 3. filter ---------------------------------------------------------------
+filter_to() { # needle
+  note "filtering to '$1'"
+  S "/"
+  sleep 0.4
+  typ "$1"
+  sleep 1
+}
+
+filter_to "gamma"
+shot "02-filtered"
+if cap | grep -q "gamma" && ! cap | grep -q "epsilon"; then
+  pass "filter narrows the list to 'gamma'"
+else
+  fail "filter did not narrow the list"
+fi
+
+# Enter in the filter box returns to the list (filter still applied).
+S Enter
+sleep 0.6
+shot "03-filter-enter-back-to-list"
+
+# --- 4a. select with Enter ---------------------------------------------------
+note "selecting the highlighted workspace with Enter (dive in)"
+S Enter
+sleep 1.2
+shot "04-after-enter-dive"
+note "re-focusing the dock (Alt+O)"
+S M-o
+sleep 1
+shot "05-dock-refocused-after-enter"
+if cap | grep -q "epsilon"; then
+  fail "Enter-select wiped the filter (non-matching 'epsilon' is back)"
+else
+  pass "Enter-select kept the filter (non-matching rows still hidden)"
+fi
+if cap | grep -q "Search Tasks"; then
+  fail "Enter-select cleared the search box (placeholder is showing)"
+else
+  pass "Enter-select kept the search box text"
+fi
+
+# --- 4b. select with a mouse click ------------------------------------------
+# Reset: leave the dock (Esc) so we start from a clean, unfiltered list.
+S Escape
+sleep 0.8
+S M-o
+sleep 0.8
+filter_to "delta"
+S Enter
+sleep 0.6
+shot "06-filtered-delta"
+
+DROW="$(row_of '  *delta')"
+if [ -n "$DROW" ]; then
+  note "clicking the 'delta' row at pane row $DROW"
+  click 8 "$DROW"
+  sleep 1.2
+  shot "07-after-click"
+  note "re-focusing the dock (Alt+O)"
+  S M-o
+  sleep 1
+  shot "08-dock-refocused-after-click"
+  if cap | grep -q "epsilon"; then
+    fail "click-select wiped the filter (non-matching 'epsilon' is back)"
+  else
+    pass "click-select kept the filter (non-matching rows still hidden)"
+  fi
+  if cap | grep -q "Search Tasks"; then
+    fail "click-select cleared the search box (placeholder is showing)"
+  else
+    pass "click-select kept the search box text"
+  fi
+else
+  fail "could not locate the 'delta' row to click"
+fi
+
+# --- 4c. Esc still clears ----------------------------------------------------
+note "leaving the dock with Esc must still clear the filter"
+S Escape
+sleep 0.8
+S M-o
+sleep 1
+shot "09-dock-after-esc"
+if cap | grep -q "epsilon"; then
+  pass "Esc out of the dock clears the filter (full list is back)"
+else
+  fail "Esc out of the dock did not clear the filter"
+fi
+
+# --- 5. summary --------------------------------------------------------------
+echo
+note "pane snapshots saved under: $OUT"
+printf '\033[1mRESULT: %d passed, %d failed\033[0m\n' "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]