Give the custom agent somewhere to type when running in the current workspace

The agent list ends in "custom...", whose whole point is an arbitrary
command -- but on a local new workspace that command box lives under the
Advanced fold, and both the fold and the inline fallback were gated on
"creating". Running in the current workspace therefore rendered no
command box at all: picking "custom..." left the form claiming an agent
the user had no way to name, and since the preset hands focus to a `cmd`
field that wasn't in the focus cycle, focus fell back to the top of the
form, where the next arrow key silently flipped "Launch in" over to "New
workspace".

The box is now inline wherever there is no fold to hold it -- remote
backends, and the current-workspace shape -- and `cmd` joins that
shape's focus cycle. `submitForm` already read `form.cmd.value` on this
path, so nothing downstream changes.

Also adds a multi-agent interactive tmux script. Three claude panes go
into one workspace holding 2 / 3 / 5 turns, one left running, one quit
cleanly, one crashed; after an editor restart each has to come back with
its own transcript, its own tab name, and its own session id. The turn
counts are the assertion that matters -- they are per-session state on
disk, so a resume reporting the wrong number proves the panes were
cross-wired even when the screen looks perfectly restored.

Author: claude

CHANGELOG.md

@@ -22,6 +22,7 @@ Keyboard and mouse input is now parsed by our own `fresh-input-parser` crate ins
   * 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*`.
   * **Run Agent… and New Workspace are now one dialog.** A "Launch in" switch at the top chooses the current workspace or a new one; picking a new one reveals the backend tabs, Project Path, Workspace Name and the Advanced fold, and picking the current one hides them, leaving just the agent controls. Both palette commands open the same form — they only differ in where the switch starts.
+  * Fixes the **`custom…` agent when running in the current workspace**, which had nowhere to type a command: the Agent Command box lives under the workspace-shaped Advanced fold, which that shape doesn't have, so picking `custom…` left the form claiming an agent you couldn't name — and dropped focus back to the top, where the next arrow key silently switched **Launch in** to *New workspace*. The box is now inline whenever there's no fold to hold it.
   * Fixes **Run Agent… → current workspace**, which recorded neither the launch nor the resume argv: that agent used to vanish from the saved workspace entirely, and restarting it produced a bare shell instead of the agent. It now behaves exactly like an agent started in its own new workspace.
 * **Classic Mac (CR) line endings** are now fully supported (#2736, requested by @720720).
 * **`.editorconfig` support** - `indent_style`/`indent_size`/`tab_width` are picked up automatically (#959, requested by @nyurik).

crates/fresh-editor/plugins/orchestrator.ts

@@ -6003,7 +6003,12 @@ function rebuildFormFocusCycle(): void {
   // non-null narrowing across every call below.
   const f = form;
   if (f.target === "current") {
-    cycle.push("agent_dropdown");
+    // `cmd` renders inline here (no Advanced fold in this shape), so it is a
+    // Tab stop right after the selector that fills it — and, crucially, a
+    // *reachable* focus target for the "custom…" preset, which hands focus to
+    // it. Without the entry the setFocusKey was dropped and focus fell back to
+    // the top of the form, so the next ←/→ silently flipped "Launch in".
+    cycle.push("agent_dropdown", "cmd");
     const agent = activeAgentEntry();
     if (agent?.auto) cycle.push("auto_mode");
     if (agent?.prompt) cycle.push("start_prompt");
@@ -7461,9 +7466,15 @@ function buildFormSpec(): WidgetSpec {
   }
   children.push(
     agentPresetRow(),
-    // On remote backends the command box stays inline (no Advanced fold to hold
-    // it); on local it moves into Advanced (appended in `advancedSection`).
-    ...(creating && form.backend !== "local" ? [cmdField()] : []),
+    // The command box stays inline wherever there's no Advanced fold to hold
+    // it: on remote backends, and whenever we're running in the current
+    // workspace (the fold is workspace-shaped, so it's gone entirely). Only a
+    // local *new workspace* moves it into Advanced (via `advancedSection`).
+    //
+    // It has to be reachable in current-workspace mode: the agent list ends in
+    // "custom…", and picking it with nowhere to type left the form claiming an
+    // agent the user could not actually name.
+    ...(!creating || form.backend !== "local" ? [cmdField()] : []),
     // Agent-specific controls (Auto mode / Start prompt), adaptive to the
     // resolved agent. Empty for a bare terminal / unknown command.
     ...agentOptionsFields(),

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

@@ -1634,3 +1634,77 @@ fn run_agent_and_new_workspace_are_one_dialog() {
     harness.assert_screen_contains("ORCHESTRATOR :: New Workspace");
     harness.assert_screen_contains("Run in:");
 }
+
+/// The agent list ends in "custom…", whose whole purpose is to let the user
+/// type an arbitrary command — so the Agent Command field has to be present,
+/// and focusable, in the current-workspace shape too.
+///
+/// It wasn't. On a local *new workspace* that field lives under the Advanced
+/// fold, and both the fold and the inline fallback were gated on "creating",
+/// so running in the current workspace rendered no command box at all. Picking
+/// "custom…" then left the form claiming an agent the user had no way to name,
+/// and — because the preset hands focus to a `cmd` field that wasn't in the
+/// focus cycle — dropped focus back to the top of the form, where the next
+/// arrow key silently flipped "Launch in" to "New workspace".
+#[test]
+fn custom_agent_is_typable_when_running_in_the_current_workspace() {
+    let (_temp, workspace) = set_up_workspace();
+    let mut harness = open_form_on(&workspace);
+
+    // Flip "Launch in" to the current workspace (as `Run Agent…` opens it).
+    harness
+        .send_key(KeyCode::BackTab, KeyModifiers::NONE)
+        .unwrap();
+    harness.tick_and_render().unwrap();
+    harness
+        .send_key(KeyCode::BackTab, KeyModifiers::NONE)
+        .unwrap();
+    harness.tick_and_render().unwrap();
+    harness.send_key(KeyCode::Left, KeyModifiers::NONE).unwrap();
+    harness
+        .wait_until(|h| h.screen_to_string().contains("ORCHESTRATOR :: Run Agent"))
+        .unwrap();
+
+    // The command box is here even though the workspace-shaped Advanced fold
+    // that normally holds it is not.
+    harness.assert_screen_contains("Agent Command");
+    harness.assert_screen_not_contains("Advanced");
+
+    // Walk to the agent selector and step left, which wraps the list around to
+    // "custom…" — the shortest route, and the one that used to strand focus.
+    let mut guard = 0;
+    while !focused_line(&harness.screen_to_string()).contains("Agent:") {
+        harness.send_key(KeyCode::Tab, KeyModifiers::NONE).unwrap();
+        harness.tick_and_render().unwrap();
+        guard += 1;
+        assert!(
+            guard < 20,
+            "Tab never reached the agent selector. Screen:\n{}",
+            harness.screen_to_string(),
+        );
+    }
+    harness.send_key(KeyCode::Left, KeyModifiers::NONE).unwrap();
+    harness
+        .wait_until(|h| h.screen_to_string().contains("custom"))
+        .unwrap();
+
+    // Focus followed the preset onto the command field, so the user can just
+    // type — and, critically, is not sitting on the "Launch in" switch.
+    let focused = focused_line(&harness.screen_to_string());
+    assert!(
+        !focused.contains("Launch in:"),
+        "picking 'custom…' must not drop focus onto the Launch-in switch — the \
+         next arrow key would change the workspace target. Screen:\n{}",
+        harness.screen_to_string(),
+    );
+
+    // And what gets typed lands in the command box rather than nowhere.
+    for ch in "zzcustomcmd".chars() {
+        harness
+            .send_key(KeyCode::Char(ch), KeyModifiers::NONE)
+            .unwrap();
+    }
+    harness
+        .wait_until(|h| h.screen_to_string().contains("zzcustomcmd"))
+        .unwrap();
+}