Merge remote-tracking branch 'origin/blitz/spawn-v2' into spawn-v2/73-draft-pane-swap

Center-zone pane drag swapped dragged.draft/target.draft but left
draftForms cached under the old leaf id, so both panes kept showing
their pre-swap form values while writing into the swapped leaf.

Tear down both leaves' cached forms at swap time (same pattern as
openDraft's stale-form teardown, #72) so render() remounts fresh
forms seeded from the swapped data.

Fixes #73

crates/maestro-tui/src/config.rs

@@ -238,6 +238,26 @@ mod tests {
         assert!(s.contains("ctrl-glorb"), "diagnostic: {s}");
     }
 
+    /// Regression for #70: the previous canonical form of a real Shift+S
+    /// keypress was `"shift-S"`, which the default `"S"` binding never
+    /// matched. Drive the actual crossterm event, not the binding string,
+    /// so the dead-key bug can't come back unnoticed.
+    #[test]
+    fn real_shift_s_keypress_resolves_to_fast_forward_spawn() {
+        use crossterm::event::{Event as CtEvent, KeyCode, KeyEvent, KeyModifiers};
+
+        use crate::input::{canonicalise, Region};
+
+        let cfg = TuiConfig::load(&TuiSection::default()).unwrap();
+        let ev = CtEvent::Key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
+        let key = canonicalise(&ev, |_, _| Region::Unknown).expect("key event canonicalises");
+
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Normal, &key.canonical()),
+            Some(Action::FastForwardSpawn),
+        );
+    }
+
     #[test]
     fn custom_chord_timeout_is_applied() {
         let mut section = TuiSection::default();

crates/maestro-tui/src/draft.rs

@@ -654,11 +654,6 @@ impl DraftPane {
             let project = visible[sel].project.clone();
             self.picked_cwd = Some(project.path.clone());
             self.cwd_raw_visible = false;
-            // A directory that *is* a linked worktree defaults to spawning in
-            // place (#91): creating a second worktree of its branch fails.
-            // Turning it back on by hand still tries (git's own message),
-            // which is deliberate (#91 non-goal).
-            self.worktree_enabled = !project.is_worktree;
             // The scan already knows this directory's repo (#61): no probe
             // round trip needed, exactly like the web form.
             let repo = project
@@ -1694,40 +1689,6 @@ mod tests {
         assert!(wt.create_branch);
     }
 
-    #[test]
-    fn picking_a_worktree_project_defaults_the_toggle_off() {
-        let mut draft = DraftPane::default();
-        let mut wt = repo_project("wt-91", "/repos/wt91", "/repos/main", 1, None);
-        wt.is_worktree = true;
-        draft.set_projects(
-            vec![
-                repo_project("main", "/repos/main", "/repos/main", 2, None),
-                wt,
-            ],
-            Utc::now(),
-        );
-        draft.focused_field = DraftField::DirPicker;
-        typed(&mut draft, "wt-91");
-        draft.on_input(&InputKey::Enter);
-
-        assert!(
-            !draft.worktree_enabled,
-            "the directory is already a worktree; spawning in place"
-        );
-        assert!(
-            draft.build_request().unwrap().worktree.is_none(),
-            "no worktree record — the session just runs there (#91)"
-        );
-
-        // Deliberately re-enabling still works, and the scan-known base repo
-        // survives so the toggle-on path needs no new probe.
-        draft.focused_field = DraftField::WorktreeToggle;
-        draft.on_input(&InputKey::Enter);
-        assert!(draft.worktree_enabled);
-        assert_eq!(draft.base_repo.as_deref(), Some(Path::new("/repos/main")));
-        assert!(draft.take_gitroot_probe().is_none());
-    }
-
     #[test]
     fn raw_path_targets_probe_gitroot_and_resolution_feeds_the_spec() {
         let mut draft = DraftPane {

crates/maestro-tui/src/input.rs

@@ -117,7 +117,9 @@ impl InputKey {
                 if *alt {
                     out.push_str("alt-");
                 }
-                if *shift {
+                // Uppercase already implies shift; crossterm sets the flag
+                // on every such char, so skip the redundant prefix (#70).
+                if *shift && !c.is_uppercase() {
                     out.push_str("shift-");
                 }
                 out.push(*c);
@@ -580,12 +582,28 @@ mod tests {
 
     #[test]
     fn canonical_round_trips_simple_chars() {
-        for s in ["a", "ctrl-a", "ctrl-w", "alt-x", "shift-A"] {
+        for s in ["a", "ctrl-a", "ctrl-w", "alt-x"] {
             let k = InputKey::parse(s).unwrap();
             assert_eq!(k.canonical(), s, "round-trip {s:?}");
         }
     }
 
+    /// crossterm 0.28 attaches `KeyModifiers::SHIFT` to any uppercase char,
+    /// so a real Shift+S delivers `Char { c: 'S', shift: true }`. Its
+    /// canonical form must be the bare `"S"` a keymap binds, not `"shift-S"` —
+    /// the uppercase letter already says "shifted"; a redundant prefix would
+    /// make the default `S` binding unreachable from the keyboard (#70).
+    #[test]
+    fn shift_flag_is_redundant_for_an_already_uppercase_char() {
+        let k = InputKey::Char {
+            c: 'S',
+            ctrl: false,
+            alt: false,
+            shift: true,
+        };
+        assert_eq!(k.canonical(), "S");
+    }
+
     #[test]
     fn canonical_round_trips_specials() {
         for s in [

web/src/multiview.test.ts

@@ -202,3 +202,83 @@ describe("multiview openDraft (#62)", () => {
     expect(leaf.draft?.command).toBe("claude");
   });
 });
+
+describe("multiview pane-drag swap (#73)", () => {
+  beforeEach(() => {
+    stubFetch();
+    document.body.replaceChildren();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  /** Drag `sourcePane`'s title onto `targetPane`'s center, as the real pane
+   *  drag handler does — modelled after the pointer sequence in runDrag()/
+   *  updateDock() in multiview.ts, since neither is exposed on MultiView. */
+  async function dragPaneOntoCenter(sourcePane: HTMLElement, targetPane: HTMLElement): Promise<void> {
+    // The real drag-start gate requires the pointerdown target to sit inside
+    // an `.attach-header` (attach.ts's session title bar). Draft panes mount
+    // no such element, so stand one in for the gate check itself.
+    const marker = document.createElement("div");
+    marker.className = "attach-header";
+    sourcePane.appendChild(marker);
+
+    vi.spyOn(targetPane, "getBoundingClientRect").mockReturnValue({
+      left: 100,
+      top: 0,
+      width: 100,
+      height: 100,
+      right: 200,
+      bottom: 100,
+      x: 100,
+      y: 0,
+      toJSON() {},
+    } as DOMRect);
+    (document as unknown as { elementsFromPoint: (x: number, y: number) => Element[] }).elementsFromPoint = () => [
+      targetPane,
+    ];
+
+    marker.dispatchEvent(
+      new PointerEvent("pointerdown", { clientX: 0, clientY: 0, bubbles: true, cancelable: true }),
+    );
+    window.dispatchEvent(
+      new PointerEvent("pointermove", { clientX: 150, clientY: 50, bubbles: true, cancelable: true }),
+    );
+    window.dispatchEvent(new PointerEvent("pointerup", { clientX: 150, clientY: 50, bubbles: true, cancelable: true }));
+    await flush();
+  }
+
+  it("moves each draft's form along with its data when two draft panes are swapped", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    const leaf1 = splitLeaf(tab, "", null, "row", true);
+    const leaf2 = splitLeaf(tab, leaf1, null, "row", true);
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+    mv.render();
+    await flush();
+
+    const paneOf = (leafId: string) => mv.el.querySelector(`[data-leaf-id="${leafId}"]`) as HTMLElement;
+    const nameInputOf = (leafId: string) => paneOf(leafId).querySelector("input[name=name]") as HTMLInputElement;
+
+    nameInputOf(leaf1).value = "west";
+    nameInputOf(leaf1).dispatchEvent(new Event("input"));
+    nameInputOf(leaf2).value = "east";
+    nameInputOf(leaf2).dispatchEvent(new Event("input"));
+    await flush();
+    expect(leaves(tab.root).find((l) => l.id === leaf1)?.draft?.name).toBe("west");
+    expect(leaves(tab.root).find((l) => l.id === leaf2)?.draft?.name).toBe("east");
+
+    await dragPaneOntoCenter(paneOf(leaf1), paneOf(leaf2));
+
+    // The leaf data swaps (already correct pre-fix)...
+    expect(leaves(tab.root).find((l) => l.id === leaf1)?.draft?.name).toBe("east");
+    expect(leaves(tab.root).find((l) => l.id === leaf2)?.draft?.name).toBe("west");
+    // ...and the mounted forms must follow, not stay behind showing the old
+    // pane's values (#73).
+    expect(nameInputOf(leaf1).value).toBe("east");
+    expect(nameInputOf(leaf2).value).toBe("west");
+  });
+});

web/src/multiview.ts

@@ -701,6 +701,16 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
         const dragged = findLeaf(tab.root, self)!;
         [dragged.sessionId, target.sessionId] = [target.sessionId, dragged.sessionId];
         [dragged.draft, target.draft] = [target.draft, dragged.draft];
+        // The leaf data moved but each pane's mounted form is still keyed to
+        // its old leaf (#73) — tear both down like openDraft's reuse case
+        // (#72) so render() remounts fresh forms seeded from the swapped data.
+        for (const id of [dragged.id, target.id]) {
+          const stale = draftForms.get(id);
+          if (stale) {
+            stale.destroy();
+            draftForms.delete(id);
+          }
+        }
         tab.focusedLeafId = target.id;
       } else if (sessionId) {
         const loc = locateSession(layout, sessionId);

web/src/spawnForm.ts

@@ -430,19 +430,9 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     cwdRawWrap.hidden = true;
     markActiveProject(project.path);
     // The scan already knows this directory is inside a repo (#61): the
-    // toggle defaults back on and no /api/gitroot round trip is needed —
-    // unless the directory *is* a linked worktree itself (#91): spawning
-    // in place is the only thing that works there, so default the toggle
-    // off. Turning it back on by hand still tries (and fails with git's
-    // own message), which is deliberate (#91 non-goal).
-    wtEnabled.checked = !project.is_worktree;
-    if (project.is_worktree) {
-      inferredBaseRepo = null;
-      wtBody.hidden = true;
-      wtHint.hidden = true;
-    } else {
-      applyProjectRepo(project.base_repo ?? project.path);
-    }
+    // toggle defaults back on and no /api/gitroot round trip is needed.
+    wtEnabled.checked = true;
+    applyProjectRepo(project.base_repo ?? project.path);
     emit();
     // Picking a project pre-selects the command it was last used with.
     const match = presets.find((p) => p.command === project.last_command && p.command !== "");

web/src/spawnFormWorktree.test.ts

@@ -18,7 +18,6 @@ const BRANCHES = [
  * its branch list is still in flight. */
 function stubFetch(opts?: {
   gateBranches?: (release: () => void) => void;
-  projects?: unknown[];
 }): string[] {
   const urls: string[] = [];
   const gated = new Promise<void>((resolve) => {
@@ -38,7 +37,7 @@ function stubFetch(opts?: {
         return new Response(JSON.stringify(BRANCHES), { status: 200 });
       }
       if (url.includes("/api/projects")) {
-        return new Response(JSON.stringify(opts?.projects ?? PROJECTS), { status: 200 });
+        return new Response(JSON.stringify(PROJECTS), { status: 200 });
       }
       return new Response(
         JSON.stringify({ hostname: "h", version: "0", home_dir: "/home/user", presets: [] }),
@@ -101,34 +100,6 @@ describe("spawnForm worktree defaults and branch picker (#61)", () => {
     );
   });
 
-  it("defaults the worktree toggle off for a row that is itself a worktree (#91)", async () => {
-    urls = stubFetch({
-      projects: [
-        {
-          path: "/home/user/wt-91",
-          name: "wt-91",
-          is_worktree: true,
-          base_repo: "/home/user/maestro",
-          last_activity: "2026-08-20T10:00:00Z",
-        },
-      ],
-    });
-    handle = createSpawnForm({ onSuccess() {} });
-    document.body.appendChild(handle.el);
-    for (let i = 0; i < 40; i++) await Promise.resolve();
-
-    handle.el
-      .querySelectorAll<HTMLButtonElement>(".project-row")
-      .forEach((row) => row.dataset.cwd === "/home/user/wt-91" && row.click());
-    await drain();
-
-    expect(handle.el.querySelector<HTMLInputElement>("input[name=worktree_enabled]")!.checked).toBe(
-      false,
-    );
-    expect(urls.some((u) => u.includes("/api/gitroot"))).toBe(false);
-    expect(handle.el.querySelector<HTMLElement>(".wt-body")!.hidden).toBe(true);
-  });
-
   it("still probes the gitroot for a free-text directory", async () => {
     const form = await mount();
 

web/src/styles.css

@@ -1215,6 +1215,9 @@ textarea {
 /* ---------- forms ---------- */
 
 .spawn-form {
+  width: 100%;
+  max-width: 60ch;
+  margin: 0 auto;
   padding: var(--sp-3);
   overflow: auto;
   display: flex;