fix(maestro): cap and centre the spawn form's width

The form filled the full pane width, so on a 4K display every input
stretched thousands of pixels wide. Bound it to 60ch (in line with the
48ch/42ch precedents already in the type scale) and centre it with
margin auto; panes narrower than the cap still fill edge to edge.

crates/maestro-daemon/src/projects.rs

@@ -261,17 +261,13 @@ 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 !force {
+        if let Some((at, repos)) = cache.as_ref() {
-            if let Some((at, repos)) = cache.as_ref() {
+            if at.elapsed() < self.ttl {
-                if at.elapsed() < self.ttl {
+                return repos.clone();
-                    return repos.clone();
-                }
             }
         }
         let roots = self.roots.clone();
@@ -287,11 +283,11 @@ impl ProjectScanner {
         repos
     }
 
-    /// Rescan now, ignoring the TTL. Called by the background timer — going
+    /// One background-refresh tick: rescan only if the cached snapshot has
-    /// through `repos()` would hit the cache and make most ticks no-ops,
+    /// passed its TTL (#75) — the timer used to bypass it and re-walk the
-    /// leaving requests to pay for the rescan instead (#54 review).
+    /// roots every [`REFRESH_INTERVAL`].
     async fn refresh(&self) {
-        self.repos_inner(true).await;
+        self.repos().await;
     }
 
     /// Spawn the slow background refresh task. Drop the returned handle to
@@ -544,6 +540,32 @@ 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,26 +238,6 @@ 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/input.rs

@@ -117,9 +117,7 @@ impl InputKey {
                 if *alt {
                     out.push_str("alt-");
                 }
-                // Uppercase already implies shift; crossterm sets the flag
+                if *shift {
-                // on every such char, so skip the redundant prefix (#70).
-                if *shift && !c.is_uppercase() {
                     out.push_str("shift-");
                 }
                 out.push(*c);
@@ -582,28 +580,12 @@ mod tests {
 
     #[test]
     fn canonical_round_trips_simple_chars() {
-        for s in ["a", "ctrl-a", "ctrl-w", "alt-x"] {
+        for s in ["a", "ctrl-a", "ctrl-w", "alt-x", "shift-A"] {
             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,6 +147,48 @@ 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,9 +423,15 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
       return;
     }
     const target = findLeaf(tab.root, tab.focusedLeafId)!;
-    if (!target.sessionId && !target.draft) {
+    if (!target.sessionId) {
-      // An already-empty pane becomes the draft in place.
+      // Empty = no session, not `!draft` (#72): the mounted form auto-syncs
+      // picked defaults into `draft` once ready, so that's never reliably null.
       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/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;