feat(orchestrator): make the dock's start-up state configurable

The dock always opened in card density with "all worktrees" off and
"show empty" on, and never opened by itself. Those defaults were module
constants only a source-reader could find, and the in-dock controls only
remembered a change for the current session.

Declare four fields through the plugin config API, so they render in the
Settings UI under "Plugin: orchestrator" and layer/persist like any other
setting:

  autoOpenDock        (false)   open the dock on `ready`, unfocused
  defaultView         ("card")  density the dock opens at
  showAllWorktrees    (false)   initial "all worktrees" checkbox state
  showEmptyWorkspaces (true)    initial "show empty" checkbox state

Plugin config rather than core config: these mean nothing without the
plugin loaded, and the plugin API already supplies schema validation, the
User/Project/Session merge, and the rendered widgets.

Each is only where the dock *starts*. The "view" button and the two
Filters checkboxes still win for the rest of the session — the session
state they write is now `null` until touched, and the settings fill in
underneath. Settings are re-read on every dock open, so an edit lands on
the next toggle without a plugin reload or restart.

`showDockForPending` becomes `showDockUnfocused`: the auto-open path
wants exactly its behaviour (mount the dock, leave the keyboard with the
editor), and the name no longer fits only the placeholder case.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CstcifC5JjgznkUK8L8dm2

Author: claude

CHANGELOG.md

@@ -18,6 +18,7 @@ Keyboard and mouse input is now parsed by our own `fresh-input-parser` crate ins
 * **Orchestrator: agents & workspaces**
   * **`Run Agent…` command** launches a terminal or a coding agent (`claude`, `codex`, `opencode`, `aider`) in your current workspace or a new one, without the full New Workspace dialog.
   * **Non-blocking workspace creation** - creating a workspace no longer freezes the editor; choose **Create & Visit** or **Create in Background** and keep working while it comes up.
+  * **The dock's start-up state is now configurable** - Settings → **Plugin: orchestrator** has four new options: open the dock automatically on startup (off by default, and it opens unfocused so typing still goes to the editor), the layout it opens with (**card** or **compact**), and the starting state of the **all worktrees** and **show empty** checkboxes. They're defaults, not locks: the dock's own view button and checkboxes still win for the rest of the session, and an edit applies the next time you open the dock — no restart.
 * **Restart an exited terminal in place** - when a terminal's process quits, the status bar offers a clickable `⟳ Restart terminal` (or `⟳ Resume claude`, named after whatever was running, with the exit code when it's non-zero). Click it, run **Restart Terminal Process** from the command palette, or use **View → Terminal → Restart Terminal Process**, and the process comes back in the *same* buffer below the existing scrollback — no new terminal, no lost place. A coding agent with a resume spec rejoins its conversation rather than starting over, exactly as it does when you reopen the editor. Works for plain shells and commands too; a *running* terminal is never restarted. The offer survives quitting the editor — the pane comes back with its transcript and the indicator, deliberately still stopped rather than silently re-running.
   * A terminal's exit is **no longer written into the output** as a `[Terminal process exited]` line, which cost a row and scrolled the top of the final screen out of view — often the first, most important line of an agent's last answer. The tab reads `claude (exited)` instead, and the dead terminal is left exactly on its last frame.
   * **Terminal tab names now survive an editor restart** — a restored agent tab stays named `claude` instead of falling back to `bash` / `*Terminal 1*`.

crates/fresh-editor/plugins/orchestrator.ts

@@ -845,25 +845,102 @@ let pickerFocusKey: string = "sessions";
 // 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;
+// discovered on-disk worktree rows are shown. `null` means "not touched
+// this session" — the dock then seeds it from the `showAllWorktrees`
+// plugin setting (default false: worktrees hidden, surfacing them is
+// opt-in via "Show all worktrees" / Alt+T). Flipping the checkbox pins a
+// concrete value that wins for the rest of the session.
+let lastShowWorktrees: boolean | null = null;
 // Remembered across opens: whether "trivial" sessions are hidden.
-// Defaults to false — showing every workspace. A freshly created
-// workspace starts empty, so hiding trivial sessions made it vanish the
-// instant it lost the "active" exemption (issue: "new workspace
-// immediately disappears"). Showing all by default keeps new workspaces
-// visible; the "show empty" checkbox (Alt+I) opts back into hiding the
-// throwaway single-file / restored-shell rows.
-let lastHideTrivial = false;
-// Dock card density, remembered across opens. "card" (default) shows
-// the three-line rounded pill; "compact" shows one line per session.
-// Toggled by the dock toolbar's "view" button.
+// `null` ⇒ seeded from the `showEmptyWorkspaces` setting, which defaults
+// to true (nothing hidden). A freshly created workspace starts empty, so
+// hiding trivial sessions made it vanish the instant it lost the
+// "active" exemption (issue: "new workspace immediately disappears").
+// Showing all by default keeps new workspaces visible; the "show empty"
+// checkbox (Alt+I) opts back into hiding the throwaway single-file /
+// restored-shell rows.
+let lastHideTrivial: boolean | null = null;
+// Dock card density. "card" (default) shows the three-line rounded pill;
+// "compact" shows one line per session. Read all over the render path,
+// so it stays a plain value rather than a config lookup; the dock
+// re-seeds it from the `defaultView` setting on open unless the user has
+// hit the toolbar's "view" button this session (`dockViewOverride`).
 let dockView: "card" | "compact" = "card";
+let dockViewOverride: "card" | "compact" | null = null;
 // Remembered dock project filter (see `OpenDialogState.projectFilter`).
 let lastDockProjectFilter: string | null = null;
 
+// =============================================================================
+// Dock settings (Settings → Plugin: orchestrator)
+//
+// The dock's start-up defaults are *plugin* config, not core editor
+// config: they only mean anything while this plugin is loaded, and the
+// plugin-config API already gives us schema validation, the layered
+// User/Project/Session merge, and a rendered Settings sub-category for
+// free. Declaring them here is what makes them discoverable — before
+// this, the dock's defaults were module constants only a source-reader
+// could find, and the checkbox/density state was session-only.
+//
+// Each field is the *default* the dock opens with. The in-dock controls
+// (the "view" button, the two Filters checkboxes) still win for the rest
+// of the session — they set the `*Override` / `last*` values above —
+// they just no longer decide where the dock starts.
+editor.defineConfigBoolean("autoOpenDock", {
+  default: false,
+  description:
+    "Open the workspace dock automatically when Fresh starts. The dock opens unfocused, so typing still goes to the editor.",
+});
+editor.defineConfigEnum("defaultView", {
+  values: ["card", "compact"] as const,
+  default: "card",
+  description:
+    "Dock layout the panel opens with: 'card' (multi-line pill per workspace) or 'compact' (one line per workspace). The dock's 'view' button flips it for the current session.",
+});
+editor.defineConfigBoolean("showAllWorktrees", {
+  default: false,
+  description:
+    "Start the dock (and the Open picker) with 'all worktrees' checked, listing on-disk worktrees that have no open workspace.",
+});
+editor.defineConfigBoolean("showEmptyWorkspaces", {
+  default: true,
+  description:
+    "Start the dock (and the Open picker) with 'show empty' checked, listing workspaces with no edited files (freshly created ones included).",
+});
+
+interface DockSettings {
+  autoOpenDock?: boolean;
+  defaultView?: "card" | "compact";
+  showAllWorktrees?: boolean;
+  showEmptyWorkspaces?: boolean;
+}
+
+// Re-read on demand rather than caching the values `defineConfigX`
+// returned at load time: a Settings-UI edit lands in the config snapshot
+// straight away, so the next dock open honours it without a plugin
+// reload or an editor restart.
+function dockSettings(): DockSettings {
+  return (editor.getPluginConfig() ?? {}) as DockSettings;
+}
+
+// Density the dock should open at: the session's own "view" toggle if
+// the user has hit it, otherwise the configured default.
+function configuredDockView(): "card" | "compact" {
+  if (dockViewOverride !== null) return dockViewOverride;
+  return dockSettings().defaultView === "compact" ? "compact" : "card";
+}
+
+// The two Filters checkboxes, same precedence. `hideTrivial` is the
+// inverse of the user-facing "show empty" checkbox.
+function configuredShowWorktrees(): boolean {
+  if (lastShowWorktrees !== null) return lastShowWorktrees;
+  return dockSettings().showAllWorktrees === true;
+}
+
+function configuredHideTrivial(): boolean {
+  if (lastHideTrivial !== null) return lastHideTrivial;
+  return dockSettings().showEmptyWorkspaces === false;
+}
+
 // =============================================================================
 // Dock folder tree
 //
@@ -3819,8 +3896,8 @@ function openControlRoom(opts: { dock?: boolean } = {}): void {
     // control / Alt+P updates it for next time.
     scope: lastOpenScope,
     selectedIds: new Set<number>(),
-    showWorktrees: lastShowWorktrees,
-    hideTrivial: lastHideTrivial,
+    showWorktrees: configuredShowWorktrees(),
+    hideTrivial: configuredHideTrivial(),
     bulkInFlight: null,
     projectFilter: asDock ? lastDockProjectFilter : null,
     projectMenuOpen: false,
@@ -3844,6 +3921,10 @@ function openControlRoom(opts: { dock?: boolean } = {}): void {
   if (asDock) {
     dockMode = true;
     dockBlurred = false;
+    // Adopt the configured density on every open (unless the "view"
+    // button already picked one this session), so editing the setting
+    // and reopening the dock is enough to see the change.
+    dockView = configuredDockView();
   } else {
     dockMode = false;
   }
@@ -8424,15 +8505,16 @@ function startPendingWorkspace(
   savePendingSpecs();
   if (!restored) {
     closeForm();
-    showDockForPending();
+    showDockUnfocused();
     launchPendingCreate(id);
   }
   return id;
 }
 
-// Ensure the dock is visible so a just-created placeholder is seen, without
-// stealing keyboard focus — the user asked to keep working ("stay put").
-function showDockForPending(): void {
+// Ensure the dock is visible without stealing keyboard focus — the user
+// asked to keep working ("stay put"). Used for a just-created placeholder
+// (so it's seen), and for the `autoOpenDock` setting at startup.
+function showDockUnfocused(): void {
   // Open the dock if nothing is up yet. (Structured so the module-level
   // `openPanel`'s narrowing survives the `openControlRoom` reassignment —
   // mirrors `openMoveToFolderForCurrent`.)
@@ -8977,7 +9059,7 @@ function recoverPendingWorkspaces(): void {
     startPendingWorkspace(spec, { restored: true, label });
     restored++;
   }
-  if (restored > 0) showDockForPending();
+  if (restored > 0) showDockUnfocused();
 }
 
 // `visit`: "Create & Visit" — focus follows into the workspace once it's real.
@@ -10322,6 +10404,9 @@ editor.on("widget_event", (e) => {
     // Dock "view" button → flip card ⇄ compact density and re-render.
     if (e.event_type === "activate" && e.widget_key === "view-toggle") {
       dockView = dockView === "card" ? "compact" : "card";
+      // Pin it for the rest of the session — the configured default only
+      // decides where the dock *starts*.
+      dockViewOverride = dockView;
       if (openPanel) openPanel.update(buildDockSpec());
       return;
     }
@@ -10501,6 +10586,14 @@ editor.on("window_closed", (e) => {
 // resumes (Enter) or dismisses — nothing auto-runs (§ recoverPendingWorkspaces).
 editor.on("ready", () => {
   recoverPendingWorkspaces();
+  // Auto-open the dock when the user asked for it in Settings (Plugin:
+  // orchestrator → autoOpenDock). Runs after the recovery pass, which
+  // may already have shown the dock for a restored placeholder —
+  // `showDockUnfocused` is a no-op on an open panel, so the two can't
+  // fight. Like the pending-workspace case, the dock comes up *blurred*:
+  // it's a switcher, not something to type into, so the keyboard stays
+  // with whatever the editor restored.
+  if (dockSettings().autoOpenDock === true) showDockUnfocused();
 });
 
 // Grace window after a session becomes active during which terminal

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

@@ -170,6 +170,7 @@ pub mod on_save_actions;
 pub mod open_folder;
 pub mod orchestrator_dialog_trust_repro;
 pub mod orchestrator_dock;
+pub mod orchestrator_dock_settings;
 pub mod orchestrator_window_lsp;
 pub mod overlay_extend_to_line_end;
 pub mod pane_navigation;

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

@@ -0,0 +1,168 @@
+//! E2E coverage for the orchestrator dock's user-facing settings
+//! (`plugins.orchestrator.settings.*`, rendered by the Settings UI under
+//! "Plugin: orchestrator"):
+//!
+//! * `autoOpenDock` — open the dock on the `ready` hook, unfocused;
+//! * `defaultView` — the density (`card` / `compact`) the dock opens at;
+//! * `showAllWorktrees` / `showEmptyWorkspaces` — the initial state of the
+//!   two Filters checkboxes.
+//!
+//! Each is only a *default*: the dock's own controls still win once the
+//! user touches them. These tests pin the "where does it start" half,
+//! which is what the settings buy; `orchestrator_dock.rs` already covers
+//! the toggles themselves.
+
+use crate::common::harness::{copy_plugin, copy_plugin_lib, EditorTestHarness};
+use crate::common::tracing::init_tracing_from_env;
+use crossterm::event::{KeyCode, KeyModifiers};
+use fresh::config::{Config, PluginConfig};
+use std::fs;
+use std::path::PathBuf;
+
+/// A git project with the orchestrator plugin (+ shared lib) installed,
+/// and `settings` preset in the plugin's config slot so the plugin's
+/// `defineConfigX` calls see the user values the first time it runs.
+fn setup(settings: serde_json::Value) -> (tempfile::TempDir, PathBuf, Config) {
+    init_tracing_from_env();
+    let temp_dir = tempfile::TempDir::new().unwrap();
+    let root = temp_dir.path().join("alphaproj");
+    fs::create_dir(&root).unwrap();
+    let plugins_dir = root.join("plugins");
+    fs::create_dir(&plugins_dir).unwrap();
+    copy_plugin_lib(&plugins_dir);
+    copy_plugin(&plugins_dir, "orchestrator");
+    fs::write(root.join("readme.txt"), "hello\n").unwrap();
+    let ok = std::process::Command::new("git")
+        .args(["init", "-q"])
+        .current_dir(&root)
+        .status()
+        .unwrap()
+        .success();
+    assert!(ok);
+
+    let mut config = Config::default();
+    config.plugins.insert(
+        "orchestrator".to_string(),
+        PluginConfig {
+            enabled: true,
+            path: None,
+            settings,
+        },
+    );
+    (temp_dir, root, config)
+}
+
+/// Toggle the dock open via the command palette and wait for it to render
+/// *and* take keyboard focus (mirrors `orchestrator_dock::open_dock`).
+fn open_dock(h: &mut EditorTestHarness) {
+    h.send_key(KeyCode::Char('p'), KeyModifiers::CONTROL)
+        .unwrap();
+    h.wait_for_prompt().unwrap();
+    h.type_text("Orchestrator: Toggle Dock").unwrap();
+    h.wait_until(|h| h.screen_to_string().contains("Toggle Dock"))
+        .unwrap();
+    h.send_key(KeyCode::Enter, KeyModifiers::NONE).unwrap();
+    h.wait_until(|h| h.screen_to_string().contains("Orchestrator") && h.editor().is_dock_focused())
+        .unwrap();
+}
+
+/// Expand the dock's collapsible "Filters" section, which holds the
+/// density button and the two checkboxes.
+fn expand_filters(h: &mut EditorTestHarness) {
+    let screen = h.screen_to_string();
+    let frow = screen
+        .lines()
+        .position(|l| l.contains("Filters"))
+        .unwrap_or_else(|| panic!("screen missing 'Filters':\n{screen}")) as u16;
+    h.mouse_click(3, frow).unwrap();
+    h.wait_until(|h| h.screen_to_string().contains("Manage"))
+        .unwrap();
+}
+
+/// `defaultView: "compact"` opens the dock in list density — without it
+/// the dock always started at "card" and the user had to click "view"
+/// on every launch.
+#[test]
+fn default_view_setting_opens_dock_compact() {
+    let (_tmp, root, config) = setup(serde_json::json!({ "defaultView": "compact" }));
+    let mut h = EditorTestHarness::with_config_and_working_dir(120, 32, config, root).unwrap();
+    h.render().unwrap();
+    open_dock(&mut h);
+    expand_filters(&mut h);
+    h.wait_until(|h| h.screen_to_string().contains("view: compact"))
+        .unwrap();
+    h.assert_screen_not_contains("view: card");
+}
+
+/// The shipped default is unchanged: no setting ⇒ card density.
+#[test]
+fn default_view_setting_absent_opens_dock_card() {
+    let (_tmp, root, config) = setup(serde_json::json!({}));
+    let mut h = EditorTestHarness::with_config_and_working_dir(120, 32, config, root).unwrap();
+    h.render().unwrap();
+    open_dock(&mut h);
+    expand_filters(&mut h);
+    h.wait_until(|h| h.screen_to_string().contains("view: card"))
+        .unwrap();
+}
+
+/// The two Filters checkboxes start where the settings say: "all
+/// worktrees" checked, "show empty" unchecked — the inverse of both
+/// shipped defaults, so a stuck default would fail this.
+#[test]
+fn filter_checkbox_settings_seed_the_dock() {
+    let (_tmp, root, config) = setup(serde_json::json!({
+        "showAllWorktrees": true,
+        "showEmptyWorkspaces": false,
+    }));
+    let mut h = EditorTestHarness::with_config_and_working_dir(120, 32, config, root).unwrap();
+    h.render().unwrap();
+    open_dock(&mut h);
+    expand_filters(&mut h);
+    h.wait_until(|h| {
+        let s = h.screen_to_string();
+        s.contains("[v] all worktrees") && s.contains("[ ] show empty")
+    })
+    .unwrap();
+}
+
+/// `autoOpenDock: true` brings the dock up on the `ready` hook, and
+/// leaves the keyboard with the editor — it's a switcher, not something
+/// to type into.
+#[test]
+fn auto_open_setting_shows_dock_unfocused_at_startup() {
+    let (_tmp, root, config) = setup(serde_json::json!({ "autoOpenDock": true }));
+    let mut h = EditorTestHarness::with_config_and_working_dir(120, 32, config, root).unwrap();
+    h.render().unwrap();
+    h.editor_mut().fire_ready_hook();
+    h.wait_until(|h| h.screen_to_string().contains("Filters"))
+        .unwrap();
+    assert!(
+        !h.editor().is_dock_focused(),
+        "auto-opened dock must not steal keyboard focus"
+    );
+}
+
+/// Auto-open is opt-in: the ready hook alone leaves the dock closed.
+#[test]
+fn auto_open_defaults_off() {
+    let (_tmp, root, config) = setup(serde_json::json!({}));
+    let mut h = EditorTestHarness::with_config_and_working_dir(120, 32, config, root).unwrap();
+    h.render().unwrap();
+    h.editor_mut().fire_ready_hook();
+    // Let the ready hook round-trip through the plugin thread: open the
+    // dock the normal way and close it again, which can only complete
+    // after the plugin has processed everything queued before it.
+    open_dock(&mut h);
+    h.send_key(KeyCode::Char('p'), KeyModifiers::CONTROL)
+        .unwrap();
+    h.wait_for_prompt().unwrap();
+    h.type_text("Orchestrator: Toggle Dock").unwrap();
+    h.wait_until(|h| h.screen_to_string().contains("Toggle Dock"))
+        .unwrap();
+    h.send_key(KeyCode::Enter, KeyModifiers::NONE).unwrap();
+    // A dock auto-opened at ready would have stayed mounted behind the
+    // toggle; with auto-open off there is nothing left on screen.
+    h.wait_until(|h| !h.screen_to_string().contains("Filters"))
+        .unwrap();
+}