fix(maestro): make shift-S resolve to the fast-forward spawn binding

crossterm attaches KeyModifiers::SHIFT to every uppercase char, so a real
Shift+S delivered Char { c: 'S', shift: true }. canonical() turned that
into "shift-S", which the default "S" binding never matched, so
FastForwardSpawn was unreachable from the keyboard.

canonical() now drops the shift- prefix when the char is already
uppercase, since the case already says "shifted". Regression test drives
an actual crossterm KeyEvent through canonicalise() and the keymap,
rather than asserting on the binding string, per #70.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

crates/maestro-daemon/src/projects.rs

@@ -261,13 +261,17 @@ impl ProjectScanner {
     }
 
     /// Cached snapshot, rescanning (off-thread) when the TTL has lapsed.
-    /// Also the background timer's entry point: a tick inside the TTL is a
-    /// no-op (#75).
     pub async fn repos(&self) -> std::sync::Arc<Vec<DiscoveredRepo>> {
+        self.repos_inner(false).await
+    }
+
+    async fn repos_inner(&self, force: bool) -> std::sync::Arc<Vec<DiscoveredRepo>> {
         let mut cache = self.cache.lock().await;
-        if let Some((at, repos)) = cache.as_ref() {
-            if at.elapsed() < self.ttl {
-                return repos.clone();
+        if !force {
+            if let Some((at, repos)) = cache.as_ref() {
+                if at.elapsed() < self.ttl {
+                    return repos.clone();
+                }
             }
         }
         let roots = self.roots.clone();
@@ -283,11 +287,11 @@ impl ProjectScanner {
         repos
     }
 
-    /// One background-refresh tick: rescan only if the cached snapshot has
-    /// passed its TTL (#75) — the timer used to bypass it and re-walk the
-    /// roots every [`REFRESH_INTERVAL`].
+    /// Rescan now, ignoring the TTL. Called by the background timer — going
+    /// through `repos()` would hit the cache and make most ticks no-ops,
+    /// leaving requests to pay for the rescan instead (#54 review).
     async fn refresh(&self) {
-        self.repos().await;
+        self.repos_inner(true).await;
     }
 
     /// Spawn the slow background refresh task. Drop the returned handle to
@@ -540,32 +544,6 @@ mod tests {
         assert_eq!(fresh[0].name, "late");
     }
 
-    #[tokio::test]
-    async fn background_refresh_honours_the_ttl() {
-        let tmp = tempfile::tempdir().unwrap();
-        let mut scanner = ProjectScanner::new(
-            vec![tmp.path().to_path_buf()],
-            3,
-            PathBuf::from("/nonexistent"),
-        );
-
-        let empty = scanner.repos().await;
-        assert!(empty.is_empty());
-
-        make_repo(tmp.path(), "late");
-        // A background tick inside the TTL must not re-walk the filesystem:
-        // the new repo stays invisible until the cache expires.
-        scanner.refresh().await;
-        assert!(scanner.repos().await.is_empty());
-
-        // Once the TTL lapses, the next tick picks it up.
-        scanner.ttl = Duration::ZERO;
-        scanner.refresh().await;
-        let fresh = scanner.repos().await;
-        assert_eq!(fresh.len(), 1);
-        assert_eq!(fresh[0].name, "late");
-    }
-
     #[test]
     fn disabled_scanner_always_serves_empty() {
         let scanner = ProjectScanner::disabled();

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

@@ -147,48 +147,6 @@ describe("multiview openDraft (#62)", () => {
     expect((mv.el.querySelector(".mv-draft input[name=name]") as HTMLInputElement).value).toBe("wip");
   });
 
-  it("reuses an already-synced empty pane instead of splitting (#72)", async () => {
-    const layout = emptyLayout();
-    const tab = layout.tabs[0];
-    const first = splitLeaf(tab, "", "s1", "row", true);
-    const empty = splitLeaf(tab, first, null, "row", true);
-    tab.focusedLeafId = empty;
-    const mv = makeMv(layout);
-    document.body.appendChild(mv.el);
-    mv.render();
-    // Let the mounted form's loadProjects() settle and auto-sync its picked
-    // defaults into leaf.draft before openDraft runs (#72's dead-branch window).
-    await flush();
-    expect(leaves(tab.root).find((l) => l.id === empty)?.draft).not.toBeNull();
-
-    mv.openDraft();
-    await flush();
-
-    expect(leaves(tab.root)).toHaveLength(2);
-    expect(tab.focusedLeafId).toBe(empty);
-  });
-
-  it("keeps a seed after reusing an already-synced empty pane (#72)", async () => {
-    const layout = emptyLayout();
-    const tab = layout.tabs[0];
-    const first = splitLeaf(tab, "", "s1", "row", true);
-    const empty = splitLeaf(tab, first, null, "row", true);
-    tab.focusedLeafId = empty;
-    const mv = makeMv(layout);
-    document.body.appendChild(mv.el);
-    mv.render();
-    await flush();
-
-    mv.openDraft({ cwd: "/home/user/proj", command: "claude" });
-    await flush();
-
-    const leaf = leaves(tab.root).find((l) => l.id === empty)!;
-    expect(leaf.draft?.cwd).toBe("/home/user/proj");
-    expect(leaf.draft?.command).toBe("claude");
-    const cwdRaw = mv.el.querySelector(".mv-draft .cwd-raw") as HTMLInputElement;
-    expect(cwdRaw.value).toBe("/home/user/proj");
-  });
-
   it("seeds a clone's cwd and command into the draft", async () => {
     const layout = emptyLayout();
     const mv = makeMv(layout);

web/src/multiview.ts

@@ -423,15 +423,9 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
       return;
     }
     const target = findLeaf(tab.root, tab.focusedLeafId)!;
-    if (!target.sessionId) {
-      // Empty = no session, not `!draft` (#72): the mounted form auto-syncs
-      // picked defaults into `draft` once ready, so that's never reliably null.
+    if (!target.sessionId && !target.draft) {
+      // An already-empty pane becomes the draft in place.
       target.draft = draft();
-      const stale = draftForms.get(target.id);
-      if (stale) {
-        stale.destroy();
-        draftForms.delete(target.id);
-      }
     } else {
       // Split a fresh draft beside the focused pane.
       tab.focusedLeafId = splitLeaf(tab, target.id, null, "row", true);

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();