feat(maestro): project discovery scanner and GET /api/projects (#54)

crates/maestro-config/src/lib.rs

@@ -162,6 +162,15 @@ pub struct SpawnSection {
     /// it resolves to just the `custom` tile.
     #[serde(default)]
     pub presets: Option<Vec<SpawnPreset>>,
+    /// Root directories the daemon scans for git repositories (#54), `~`
+    /// expanded by the daemon against its own home. When absent the daemon
+    /// scans `["~"]`.
+    #[serde(default)]
+    pub project_roots: Option<Vec<String>>,
+    /// How many directory levels below each [`Self::project_roots`] entry the
+    /// scanner descends (#54). When absent the daemon uses `3`.
+    #[serde(default)]
+    pub project_scan_depth: Option<u32>,
 }
 
 impl SpawnSection {
@@ -387,6 +396,7 @@ mod tests {
                 label: "fish".into(),
                 command: "fish".into(),
             }]),
+            ..Default::default()
         };
         let ids: Vec<String> = section
             .resolve()
@@ -403,6 +413,7 @@ mod tests {
         // only the implicit custom tile.
         let section = SpawnSection {
             presets: Some(vec![]),
+            ..Default::default()
         };
         let ids: Vec<String> = section
             .resolve()
@@ -421,6 +432,7 @@ mod tests {
                 label: "x".into(),
                 command: "x".into(),
             }]),
+            ..Default::default()
         };
         assert_eq!(empty_id.resolve().unwrap_err(), SpawnConfigError::EmptyId);
 
@@ -430,6 +442,7 @@ mod tests {
                 label: "x".into(),
                 command: "".into(),
             }]),
+            ..Default::default()
         };
         assert_eq!(
             empty_cmd.resolve().unwrap_err(),
@@ -452,6 +465,7 @@ mod tests {
                     command: "a2".into(),
                 },
             ]),
+            ..Default::default()
         };
         assert_eq!(
             dup.resolve().unwrap_err(),
@@ -464,6 +478,7 @@ mod tests {
                 label: "Custom".into(),
                 command: "whatever".into(),
             }]),
+            ..Default::default()
         };
         assert_eq!(
             reserved.resolve().unwrap_err(),
@@ -497,6 +512,30 @@ presets = [
         assert_eq!(ids, ["claude", "zsh", "custom"]);
     }
 
+    #[test]
+    fn spawn_project_scan_fields_default_to_none() {
+        // Absent [spawn].project_* → None; the daemon applies its own defaults.
+        assert_eq!(SpawnSection::default().project_roots, None);
+        assert_eq!(SpawnSection::default().project_scan_depth, None);
+    }
+
+    #[test]
+    fn spawn_project_scan_fields_parse_from_toml() {
+        let cfg = toml::from_str::<MaestroConfigFile>(
+            r#"
+[spawn]
+project_roots = ["~/code", "/srv/work"]
+project_scan_depth = 5
+"#,
+        )
+        .expect("parse");
+        assert_eq!(
+            cfg.spawn.project_roots,
+            Some(vec!["~/code".to_string(), "/srv/work".to_string()])
+        );
+        assert_eq!(cfg.spawn.project_scan_depth, Some(5));
+    }
+
     #[test]
     fn partial_file_loads_with_section_defaults() {
         // Only [daemon] present (typical single-host install).

crates/maestro-daemon/src/cli.rs

@@ -72,11 +72,19 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     tracing::info!(recovered, "adopted existing tmux sessions");
     manager.start_liveness_watcher(DEFAULT_LIVENESS_INTERVAL);
 
+    let projects = std::sync::Arc::new(crate::projects::ProjectScanner::new(
+        config.project_roots.clone(),
+        config.project_scan_depth,
+        PathBuf::from(&config.home_dir),
+    ));
+    projects.start_background_refresh();
+
     let router = local_api::router(local_api::state_for(
         manager,
         config.hostname.clone(),
         config.home_dir.clone(),
         config.spawn_presets.clone(),
+        projects,
     ));
 
     let listener = TcpListener::bind(config.bind_addr).await?;

crates/maestro-daemon/src/config.rs

@@ -23,6 +23,14 @@ pub const DEFAULT_BIND_ADDR: &str = "127.0.0.1:7070";
 /// `[daemon].spawn_history_days` is unset. `0` in config disables history.
 pub const DEFAULT_SPAWN_HISTORY_DAYS: u32 = 30;
 
+/// Default scan roots for project discovery (#54) when `[spawn].project_roots`
+/// is unset: the whole home directory, with the scanner's own ignore list
+/// keeping it cheap.
+pub const DEFAULT_PROJECT_ROOTS: [&str; 1] = ["~"];
+/// Default directory depth for project discovery (#54) when
+/// `[spawn].project_scan_depth` is unset.
+pub const DEFAULT_PROJECT_SCAN_DEPTH: u32 = 3;
+
 /// Env var that overrides `[daemon].bind_addr`.
 pub const ENV_DAEMON_BIND_ADDR: &str = "MAESTRO_DAEMON_BIND_ADDR";
 /// Env var that overrides `[daemon].tmux_tmpdir`.
@@ -74,6 +82,12 @@ pub struct DaemonConfig {
     /// built-ins) with the implicit `custom` tile appended. Advertised to
     /// clients in `GET /api/info`.
     pub spawn_presets: Vec<maestro_config::SpawnPreset>,
+    /// Project-discovery scan roots (#54): `[spawn].project_roots` (default
+    /// [`DEFAULT_PROJECT_ROOTS`]) with `~` expanded against the daemon's home.
+    pub project_roots: Vec<PathBuf>,
+    /// Project-discovery depth (#54): `[spawn].project_scan_depth`, default
+    /// [`DEFAULT_PROJECT_SCAN_DEPTH`].
+    pub project_scan_depth: u32,
 }
 
 impl DaemonConfig {
@@ -147,6 +161,25 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
         .spawn_history_days
         .unwrap_or(DEFAULT_SPAWN_HISTORY_DAYS);
 
+    // `~` in scan roots means the daemon's own home; an unresolvable home
+    // leaves the tilde as-is and the scanner treats the root as missing.
+    let project_roots: Vec<PathBuf> = file
+        .spawn
+        .project_roots
+        .unwrap_or_else(|| {
+            DEFAULT_PROJECT_ROOTS
+                .iter()
+                .map(|s| s.to_string())
+                .collect()
+        })
+        .iter()
+        .map(|root| expand_tilde(root, &home_dir))
+        .collect();
+    let project_scan_depth = file
+        .spawn
+        .project_scan_depth
+        .unwrap_or(DEFAULT_PROJECT_SCAN_DEPTH);
+
     Ok(DaemonConfig {
         hostname,
         home_dir,
@@ -157,9 +190,24 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
         tmux_tmpdir,
         spawn_history_days,
         spawn_presets,
+        project_roots,
+        project_scan_depth,
     })
 }
 
+/// Expand a leading `~` (or `~/…`) against `home`. Other paths pass through.
+fn expand_tilde(path: &str, home: &str) -> PathBuf {
+    match path.strip_prefix("~") {
+        Some(_) if home.is_empty() => PathBuf::from(path),
+        Some(rest) => {
+            let mut p = PathBuf::from(home);
+            p.push(rest.trim_start_matches('/'));
+            p
+        }
+        None => PathBuf::from(path),
+    }
+}
+
 pub fn default_state_dir() -> Result<PathBuf, ConfigError> {
     Ok(maestro_config::default_state_dir("maestro")?)
 }
@@ -280,6 +328,56 @@ spawn_history_days = 0
         assert_eq!(cfg.spawn_history_days, 0);
     }
 
+    #[test]
+    fn project_scan_defaults_to_home_root_at_depth_3() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.toml");
+        std::fs::write(&path, "").unwrap();
+        let cfg = load_config(&path, EnvOverrides::default()).unwrap();
+        assert_eq!(cfg.project_scan_depth, DEFAULT_PROJECT_SCAN_DEPTH);
+        assert_eq!(
+            cfg.project_roots,
+            vec![PathBuf::from(cfg.home_dir.clone())],
+            "bare ~ must expand to the daemon's home"
+        );
+    }
+
+    #[test]
+    fn project_scan_roots_expand_tilde_and_pass_through_absolutes() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.toml");
+        std::fs::write(
+            &path,
+            r#"
+[spawn]
+project_roots = ["~/code", "/srv/work"]
+project_scan_depth = 5
+"#,
+        )
+        .unwrap();
+        let cfg = load_config(&path, EnvOverrides::default()).unwrap();
+        assert_eq!(cfg.project_scan_depth, 5);
+        assert_eq!(
+            cfg.project_roots,
+            vec![
+                PathBuf::from(cfg.home_dir.clone()).join("code"),
+                PathBuf::from("/srv/work"),
+            ]
+        );
+    }
+
+    #[test]
+    fn tilde_expansion_handles_bare_and_nested_forms() {
+        assert_eq!(expand_tilde("~", "/home/u"), PathBuf::from("/home/u"));
+        assert_eq!(
+            expand_tilde("~/a/b", "/home/u"),
+            PathBuf::from("/home/u/a/b")
+        );
+        assert_eq!(expand_tilde("/abs", "/home/u"), PathBuf::from("/abs"));
+        // Unresolvable home leaves the tilde as-is rather than mangling it.
+        assert_eq!(expand_tilde("~", ""), PathBuf::from("~"));
+    }
+
     #[test]
     fn system_hostname_is_nonempty() {
         let h = system_hostname();

crates/maestro-daemon/src/lib.rs

@@ -16,6 +16,7 @@ pub mod gitroot;
 pub mod local_api;
 pub mod panes;
 pub mod proc;
+pub mod projects;
 pub mod pty;
 pub mod session;
 pub mod sidecar;

crates/maestro-daemon/src/local_api.rs

@@ -36,6 +36,8 @@ pub struct LocalApiState {
     pub home_dir: Arc<String>,
     /// Resolved spawn presets (#22/#26) advertised in `GET /api/info`.
     pub presets: Arc<Vec<SpawnPreset>>,
+    /// Project discovery (#54) backing `GET /api/projects`.
+    pub projects: Arc<crate::projects::ProjectScanner>,
 }
 
 pub fn router(state: LocalApiState) -> Router {
@@ -44,6 +46,7 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::patterns::SESSION, delete(kill_session))
         .route(routes::DIRS, get(list_dir))
         .route(routes::RECENT_DIRS, get(recent_dirs))
+        .route(routes::PROJECTS, get(projects))
         .route(routes::GITROOT, get(git_root))
         .route(routes::INFO, get(daemon_info))
         .route(routes::EVENTS, any(events_ws))
@@ -98,6 +101,15 @@ async fn recent_dirs(State(s): State<LocalApiState>) -> Response {
     Json(crate::spawn_history::to_wire(s.manager.recent_dirs())).into_response()
 }
 
+/// Discovered git repositories and worktrees, newest activity first (#54).
+/// `last_activity` is the later of the repo's git HEAD mtime and the newest
+/// spawn-history use of any directory inside it.
+async fn projects(State(s): State<LocalApiState>) -> Response {
+    let repos = s.projects.repos().await;
+    let history = s.manager.all_recent_dirs();
+    Json(crate::projects::to_projects(&repos, &history)).into_response()
+}
+
 /// Probe the enclosing git repo of `path`, to infer the worktree `base_repo`
 /// for the spawn form (#26). `path` is resolved against the daemon's home dir
 /// (empty/`~`/relative), like [`list_dir`].
@@ -157,18 +169,23 @@ fn error_response(status: StatusCode, code: &str, message: &str) -> Response {
 }
 
 /// Convenience constructor — pulls the bits `LocalApiState` needs from
-/// `DaemonConfig` so callers don't have to assemble it by hand.
+/// `DaemonConfig` so callers don't have to assemble it by hand. The project
+/// scanner starts with its cache cold; wire
+/// [`ProjectScanner::start_background_refresh`](crate::projects::ProjectScanner::start_background_refresh)
+/// on the returned handle's scanner to keep it eventually fresh.
 pub fn state_for(
     manager: SessionManager,
     hostname: impl Into<String>,
     home_dir: impl Into<String>,
     presets: Vec<SpawnPreset>,
+    projects: Arc<crate::projects::ProjectScanner>,
 ) -> LocalApiState {
     LocalApiState {
         manager,
         hostname: Arc::new(hostname.into()),
         home_dir: Arc::new(home_dir.into()),
         presets: Arc::new(presets),
+        projects,
     }
 }
 

crates/maestro-daemon/src/projects.rs

@@ -0,0 +1,530 @@
+//! Project discovery for `GET /api/projects` (#54).
+//!
+//! Scans `[spawn].project_roots` (default the whole home) for `.git` entries —
+//! directory or file, so linked worktrees count too — up to
+//! `[spawn].project_scan_depth` levels. Descent stops at the first repo found:
+//! nested independent repos are not discovered, but worktrees of every hit
+//! still are, via `git worktree list`, which also catches linked worktrees
+//! living outside the roots.
+//!
+//! Hidden directories are skipped everywhere; heavy well-known directories
+//! (`node_modules`, `Downloads`, …) are skipped when they sit directly in the
+//! home directory, so scanning all of home stays cheap.
+//!
+//! Results are cached behind a short TTL and refreshed on a slow background
+//! timer ([`ProjectScanner::start_background_refresh`]) — repositories appear
+//! rarely, and `/api/projects` may be polled.
+
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
+
+use chrono::{DateTime, Utc};
+
+use crate::spawn_history::RecentDir;
+
+/// Directory names never descended when they sit directly in the home dir, so
+/// scanning all of home stays cheap (#54). Hidden dirs are skipped everywhere
+/// regardless.
+pub const DEFAULT_HOME_IGNORE: &[&str] =
+    &["node_modules", "Downloads", "Library", "go", "snap", "opt"];
+
+/// How long a discovery snapshot is served as-is before the next request
+/// triggers a rescan. Short: a scan is a bounded filesystem walk plus one
+/// `git worktree list` per hit.
+pub const CACHE_TTL: Duration = Duration::from_secs(5);
+/// Background refresh cadence. Repositories appear rarely; this keeps the
+/// served list eventually fresh without anyone asking.
+pub const REFRESH_INTERVAL: Duration = Duration::from_secs(60);
+
+/// One repository or linked worktree found by [`discover`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DiscoveredRepo {
+    pub path: PathBuf,
+    /// Basename of `path`.
+    pub name: String,
+    pub is_worktree: bool,
+    /// The main checkout this worktree belongs to; set only when
+    /// [`Self::is_worktree`].
+    pub base_repo: Option<PathBuf>,
+    /// Mtime of the checkout's git HEAD — "someone committed / checked out
+    /// here". The later-of merge with spawn history happens in
+    /// [`to_projects`], which also sorts.
+    pub head_mtime: Option<DateTime<Utc>>,
+}
+
+/// Repo toplevels under each root of `roots`, at most `max_depth` levels deep.
+/// A dir holding `.git` (dir *or* file) is a hit and is not descended into;
+/// hidden directories are never entered, and `DEFAULT_HOME_IGNORE` names are
+/// skipped directly under `home`.
+pub fn scan_roots(roots: &[PathBuf], max_depth: u32, home: &Path) -> Vec<PathBuf> {
+    let mut found = Vec::new();
+    for root in roots {
+        walk(root, 0, max_depth, home, &mut found);
+    }
+    found.sort();
+    found.dedup();
+    found
+}
+
+fn walk(dir: &Path, depth: u32, max_depth: u32, home: &Path, found: &mut Vec<PathBuf>) {
+    let entries = match std::fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    let mut subdirs = Vec::new();
+    let mut has_git = false;
+    for entry in entries.flatten() {
+        match entry.file_name().to_string_lossy().into_owned() {
+            name if name == ".git" => has_git = true,
+            name if name.starts_with('.') => {}
+            name if dir == home && DEFAULT_HOME_IGNORE.contains(&name.as_str()) => {}
+            _ => {
+                if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
+                    subdirs.push(entry.path());
+                }
+            }
+        }
+    }
+    if has_git {
+        // Match `git worktree list` output, which prints real paths.
+        found.push(std::fs::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf()));
+        return;
+    }
+    if depth >= max_depth {
+        return;
+    }
+    for sub in subdirs {
+        walk(&sub, depth + 1, max_depth, home, found);
+    }
+}
+
+/// Every discovered project: the scanned repos plus all worktrees their
+/// `git worktree list` reports (linked worktrees can live outside the roots).
+/// A hit whose git invocation fails still lists, un-worktreed.
+pub fn discover(roots: &[PathBuf], max_depth: u32, home: &Path) -> Vec<DiscoveredRepo> {
+    let scanned = scan_roots(roots, max_depth, home);
+    let mut map: Vec<(PathBuf, PathBuf)> = Vec::new(); // (checkout, main)
+    for repo in scanned {
+        if map.iter().any(|(c, _)| c == &repo) {
+            continue;
+        }
+        let worktrees = list_worktrees(&repo).unwrap_or_else(|| vec![repo.clone()]);
+        let main = worktrees[0].clone();
+        for wt in worktrees {
+            if !map.iter().any(|(c, _)| c == &wt) {
+                map.push((wt, main.clone()));
+            }
+        }
+    }
+    map.into_iter()
+        .map(|(path, main)| {
+            let is_worktree = path != main;
+            DiscoveredRepo {
+                name: path
+                    .file_name()
+                    .map(|n| n.to_string_lossy().into_owned())
+                    .unwrap_or_default(),
+                is_worktree,
+                base_repo: is_worktree.then_some(main),
+                head_mtime: head_mtime(&path),
+                path,
+            }
+        })
+        .collect()
+}
+
+/// `git worktree list --porcelain` from `repo`: absolute paths, main first.
+/// `None` when git fails (broken/bare checkout).
+fn list_worktrees(repo: &Path) -> Option<Vec<PathBuf>> {
+    let out = std::process::Command::new("git")
+        .arg("-C")
+        .arg(repo)
+        .args(["worktree", "list", "--porcelain"])
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let mut paths = Vec::new();
+    for line in String::from_utf8_lossy(&out.stdout).lines() {
+        if let Some(p) = line.strip_prefix("worktree ") {
+            paths.push(PathBuf::from(p));
+        }
+    }
+    (!paths.is_empty()).then_some(paths)
+}
+
+/// Mtime of the checkout's HEAD file. For a linked worktree `.git` is a file
+/// holding a `gitdir:` pointer; resolve it so worktrees report their own HEAD
+/// rather than nothing.
+fn head_mtime(repo: &Path) -> Option<DateTime<Utc>> {
+    let dot_git = repo.join(".git");
+    let head = if dot_git.is_dir() {
+        dot_git.join("HEAD")
+    } else {
+        let ptr = std::fs::read_to_string(&dot_git).ok()?;
+        let gitdir = ptr.trim().strip_prefix("gitdir:")?.trim();
+        // Relative pointers are relative to the worktree.
+        let p = Path::new(gitdir);
+        let p = if p.is_absolute() {
+            p.to_path_buf()
+        } else {
+            repo.join(p)
+        };
+        p.join("HEAD")
+    };
+    let mtime = std::fs::metadata(head).ok()?.modified().ok()?;
+    Some(DateTime::<Utc>::from(mtime))
+}
+
+/// Fold spawn history into the discovery snapshot and produce the wire list,
+/// sorted newest-activity-first. `history` must be newest-first (what
+/// [`SpawnHistory::all_recent_dirs`](crate::spawn_history::SpawnHistory)
+/// returns): the first entry whose cwd sits inside a project is its most
+/// recent use.
+pub fn to_projects(
+    repos: &[DiscoveredRepo],
+    history: &[RecentDir],
+) -> Vec<maestro_protocol::Project> {
+    let mut projects: Vec<maestro_protocol::Project> = repos
+        .iter()
+        .map(|repo| {
+            let last_use = history.iter().find(|h| contains(&repo.path, &h.cwd));
+            maestro_protocol::Project {
+                path: repo.path.clone(),
+                name: repo.name.clone(),
+                is_worktree: repo.is_worktree,
+                base_repo: repo.base_repo.clone(),
+                last_activity: max_opt(repo.head_mtime, last_use.map(|u| u.last_used)),
+                last_command: last_use.map(|u| u.last_command.clone()),
+            }
+        })
+        .collect();
+    projects.sort_by_key(|p| std::cmp::Reverse(p.last_activity));
+    projects
+}
+
+/// Whether `dir` is `project` itself or anywhere inside it.
+fn contains(project: &Path, dir: &Path) -> bool {
+    dir == project || dir.starts_with(project)
+}
+
+fn max_opt(a: Option<DateTime<Utc>>, b: Option<DateTime<Utc>>) -> Option<DateTime<Utc>> {
+    match (a, b) {
+        (Some(a), Some(b)) => Some(a.max(b)),
+        (a, b) => a.or(b),
+    }
+}
+
+/// Cached discovery behind a short TTL plus an optional slow background
+/// refresh. Clone-free shared handle via `Arc` in [`crate::local_api`].
+#[derive(Debug)]
+pub struct ProjectScanner {
+    roots: Vec<PathBuf>,
+    max_depth: u32,
+    home: PathBuf,
+    ttl: Duration,
+    cache: tokio::sync::Mutex<Option<(Instant, std::sync::Arc<Vec<DiscoveredRepo>>)>>,
+}
+
+impl ProjectScanner {
+    /// Scanner over the resolved config roots. An empty `roots` list scans
+    /// nothing and always serves an empty list.
+    pub fn new(roots: Vec<PathBuf>, max_depth: u32, home: PathBuf) -> Self {
+        Self {
+            roots,
+            max_depth,
+            home,
+            ttl: CACHE_TTL,
+            cache: tokio::sync::Mutex::new(None),
+        }
+    }
+
+    /// Scanner that never discovers anything — tests and embedders that don't
+    /// want the endpoint populated.
+    pub fn disabled() -> Self {
+        Self::new(Vec::new(), 0, PathBuf::new())
+    }
+
+    /// Cached snapshot, rescanning (off-thread) when the TTL has lapsed.
+    pub async fn repos(&self) -> 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();
+            }
+        }
+        let roots = self.roots.clone();
+        let max_depth = self.max_depth;
+        let home = self.home.clone();
+        // Blocking fs walk + git subprocesses must not stall the reactor.
+        let repos = std::sync::Arc::new(
+            tokio::task::spawn_blocking(move || discover(&roots, max_depth, &home))
+                .await
+                .unwrap_or_default(),
+        );
+        *cache = Some((Instant::now(), repos.clone()));
+        repos
+    }
+
+    /// Rescan now, ignoring the TTL. Called by the background timer.
+    async fn refresh(&self) {
+        self.repos().await;
+    }
+
+    /// Spawn the slow background refresh task. Drop the returned handle to
+    /// detach it; it stops when the runtime shuts down.
+    pub fn start_background_refresh(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
+        let scanner = std::sync::Arc::clone(self);
+        tokio::spawn(async move {
+            let mut ticker = tokio::time::interval(REFRESH_INTERVAL);
+            ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+            ticker.tick().await; // the immediate first tick — wait a full interval
+            loop {
+                scanner.refresh().await;
+                ticker.tick().await;
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::spawn_history::RecentDir;
+
+    /// Real git repo at `<root>/<name>`, one initial commit so HEAD exists.
+    fn make_repo(root: &Path, name: &str) -> PathBuf {
+        let path = root.join(name);
+        std::fs::create_dir_all(&path).unwrap();
+        run_git(&path, &["init", "-q"]);
+        std::fs::write(path.join("f.txt"), "x\n").unwrap();
+        run_git(&path, &["add", "-A"]);
+        run_git(
+            &path,
+            &[
+                "-c",
+                "user.email=t@t",
+                "-c",
+                "user.name=t",
+                "commit",
+                "-qm",
+                "init",
+            ],
+        );
+        path
+    }
+
+    fn run_git(dir: &Path, args: &[&str]) {
+        let out = std::process::Command::new("git")
+            .arg("-C")
+            .arg(dir)
+            .args(args)
+            .output()
+            .unwrap();
+        assert!(
+            out.status.success(),
+            "git {args:?} failed: {} | {}",
+            String::from_utf8_lossy(&out.stderr),
+            String::from_utf8_lossy(&out.stdout)
+        );
+    }
+
+    fn names(repos: &[DiscoveredRepo]) -> Vec<String> {
+        let mut v: Vec<String> = repos.iter().map(|r| r.name.clone()).collect();
+        v.sort();
+        v
+    }
+
+    #[test]
+    fn scan_finds_repos_and_stops_at_the_first_hit() {
+        let tmp = tempfile::tempdir().unwrap();
+        let outer = make_repo(tmp.path(), "outer");
+        // A nested independent repo inside `outer` is NOT discovered
+        // separately: descent stops once a repo is found.
+        make_repo(&outer, "vendored");
+        std::fs::create_dir_all(tmp.path().join("plain/deep/deeper")).unwrap();
+
+        let found = scan_roots(
+            &[tmp.path().to_path_buf()],
+            3,
+            Path::new("/nonexistent-home"),
+        );
+        assert_eq!(found, vec![outer]);
+
+        let discovered = discover(
+            &[tmp.path().to_path_buf()],
+            3,
+            Path::new("/nonexistent-home"),
+        );
+        assert_eq!(names(&discovered), ["outer"]);
+        assert!(!discovered[0].is_worktree);
+        assert_eq!(discovered[0].base_repo, None);
+        assert!(discovered[0].head_mtime.is_some());
+    }
+
+    #[test]
+    fn scan_respects_depth_hidden_dirs_and_home_ignore() {
+        let tmp = tempfile::tempdir().unwrap();
+        let home = tmp.path().join("home");
+
+        // Hidden dirs are never entered, at any depth.
+        std::fs::create_dir_all(home.join(".secret/.git")).unwrap();
+        // node_modules directly under home is not descended…
+        let _ignored = make_repo(&home.join("node_modules"), "dep");
+        // …but the same name deeper down is fair game.
+        let kept = make_repo(&home.join("code/node_modules"), "dep2");
+
+        // Depth cap: a repo three levels below the root is the last tier —
+        // found at depth 3, but a fourth-level repo isn't.
+        let at_three = home.join("a/b/c");
+        std::fs::create_dir_all(at_three.join(".git")).unwrap();
+        std::fs::create_dir_all(home.join("a/b/c/d/.git")).unwrap();
+
+        let found = scan_roots(std::slice::from_ref(&home), 3, &home);
+        assert!(found.iter().all(|p| !p.starts_with(home.join(".secret"))));
+        assert!(found
+            .iter()
+            .all(|p| !p.starts_with(home.join("node_modules"))));
+        assert!(found.contains(&kept.canonicalize().unwrap()));
+        assert!(found.contains(&at_three.canonicalize().unwrap()));
+        assert!(!found.iter().any(|p| p.ends_with("d")));
+    }
+
+    #[test]
+    fn worktrees_outside_the_roots_are_discovered_via_git_worktree_list() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().join("scan-root");
+        std::fs::create_dir_all(&root).unwrap();
+        let main = make_repo(&root, "main-repo");
+        // Linked worktree deliberately outside the scan root.
+        let wt = tmp.path().join("elsewhere/wt-of-main");
+        std::fs::create_dir_all(wt.parent().unwrap()).unwrap();
+        run_git(
+            &main,
+            &[
+                "worktree",
+                "add",
+                "-q",
+                "-b",
+                "feature",
+                &wt.to_string_lossy(),
+            ],
+        );
+
+        let discovered = discover(&[root], 3, Path::new("/nonexistent-home"));
+        assert_eq!(names(&discovered), ["main-repo", "wt-of-main"]);
+        let wt_entry = discovered.iter().find(|d| d.name == "wt-of-main").unwrap();
+        assert!(wt_entry.is_worktree);
+        assert_eq!(
+            wt_entry.base_repo.as_deref(),
+            Some(main.canonicalize().unwrap().as_path())
+        );
+        let main_entry = discovered.iter().find(|d| d.name == "main-repo").unwrap();
+        assert!(!main_entry.is_worktree);
+    }
+
+    #[test]
+    fn head_mtime_resolves_a_worktrees_git_file_pointer() {
+        let tmp = tempfile::tempdir().unwrap();
+        let main = make_repo(tmp.path(), "m");
+        let wt = tmp.path().join("wt");
+        run_git(
+            &main,
+            &["worktree", "add", "-q", "-b", "b2", &wt.to_string_lossy()],
+        );
+        assert!(head_mtime(&wt).is_some());
+    }
+
+    fn recent(cwd: &str, cmd: &str, at: &str) -> RecentDir {
+        RecentDir {
+            cwd: PathBuf::from(cwd),
+            last_command: cmd.into(),
+            last_used: DateTime::parse_from_rfc3339(at)
+                .unwrap()
+                .with_timezone(&Utc),
+        }
+    }
+
+    #[test]
+    fn to_projects_merges_history_and_sorts_newest_first() {
+        let repo_old = DiscoveredRepo {
+            path: PathBuf::from("/w/old"),
+            name: "old".into(),
+            is_worktree: false,
+            base_repo: None,
+            // Committed recently but never spawned in.
+            head_mtime: Some(t("2026-08-23T10:00:00Z")),
+        };
+        let repo_hist = DiscoveredRepo {
+            path: PathBuf::from("/w/hist"),
+            name: "hist".into(),
+            is_worktree: false,
+            base_repo: None,
+            // Old commit…
+            head_mtime: Some(t("2026-08-01T10:00:00Z")),
+        };
+        let repo_stale = DiscoveredRepo {
+            path: PathBuf::from("/w/stale"),
+            name: "stale".into(),
+            is_worktree: false,
+            base_repo: None,
+            head_mtime: None,
+        };
+
+        let history = vec![
+            // Newest overall: a subdir of /w/hist (first match wins for it).
+            recent("/w/hist/crates", "opencode", "2026-08-22T09:00:00Z"),
+            recent("/w/hist", "claude", "2026-08-20T09:00:00Z"),
+        ];
+        let projects = to_projects(&[repo_old, repo_hist, repo_stale], &history);
+
+        let paths: Vec<&str> = projects.iter().map(|p| p.path.to_str().unwrap()).collect();
+        assert_eq!(paths, ["/w/old", "/w/hist", "/w/stale"]);
+
+        // old: git activity wins (never spawned).
+        assert_eq!(projects[0].last_activity, Some(t("2026-08-23T10:00:00Z")));
+        assert_eq!(projects[0].last_command, None);
+        // hist: spawn history beats the old commit; command from the newest
+        // matching entry (the crates/ one, not the repo root one).
+        assert_eq!(projects[1].last_activity, Some(t("2026-08-22T09:00:00Z")));
+        assert_eq!(projects[1].last_command.as_deref(), Some("opencode"));
+        // stale: neither source knows anything.
+        assert_eq!(projects[2].last_activity, None);
+        assert_eq!(projects[2].last_command, None);
+    }
+
+    fn t(s: &str) -> DateTime<Utc> {
+        DateTime::parse_from_rfc3339(s).unwrap().with_timezone(&Utc)
+    }
+
+    #[tokio::test]
+    async fn scanner_caches_within_ttl_and_rescans_after() {
+        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");
+        // Within the TTL the cached (empty) snapshot is still served.
+        let still_empty = scanner.repos().await;
+        assert!(still_empty.is_empty());
+
+        // After the TTL lapses the rescan sees the new repo.
+        scanner.ttl = Duration::ZERO;
+        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();
+        assert_eq!(scanner.roots, Vec::<PathBuf>::new());
+    }
+}

crates/maestro-daemon/src/session.rs

@@ -169,6 +169,16 @@ impl SessionManager {
             .unwrap_or_default()
     }
 
+    /// Every deduped recent dir, newest-first, without the picker's result
+    /// cap (#54): project enrichment folds the whole history.
+    pub fn all_recent_dirs(&self) -> Vec<RecentDir> {
+        self.inner
+            .spawn_history
+            .as_ref()
+            .map(|h| h.all_recent_dirs())
+            .unwrap_or_default()
+    }
+
     /// Subscribe to session deltas. Each subscriber gets its own lag domain —
     /// a slow client makes only itself resync.
     pub fn events(&self) -> broadcast::Receiver<CatalogEvent> {

crates/maestro-daemon/src/spawn_history.rs

@@ -143,11 +143,23 @@ impl SpawnHistory {
     /// Recent working dirs, newest use first, deduped by `cwd`, within the
     /// recency cap, capped at `max_results`. Empty when disabled or unreadable.
     pub fn recent_dirs(&self) -> Vec<RecentDir> {
-        self.recent_dirs_as_of(Utc::now())
+        self.recent_dirs_capped(Utc::now(), self.max_results)
+    }
+
+    /// Every deduped recent dir, newest-first, without the picker's result
+    /// cap (#54): project enrichment folds the whole history, not its first
+    /// page, so a project spawned in long ago still reads as fresh.
+    pub fn all_recent_dirs(&self) -> Vec<RecentDir> {
+        self.recent_dirs_capped(Utc::now(), usize::MAX)
     }
 
     /// [`recent_dirs`](Self::recent_dirs) with an explicit clock for testing.
+    #[cfg(test)]
     fn recent_dirs_as_of(&self, now: DateTime<Utc>) -> Vec<RecentDir> {
+        self.recent_dirs_capped(now, self.max_results)
+    }
+
+    fn recent_dirs_capped(&self, now: DateTime<Utc>, max_results: usize) -> Vec<RecentDir> {
         if !self.is_enabled() {
             return Vec::new();
         }
@@ -168,7 +180,7 @@ impl SpawnHistory {
                 last_command: rec.command,
                 last_used: rec.at,
             });
-            if out.len() >= self.max_results {
+            if out.len() >= max_results {
                 break;
             }
         }
@@ -362,4 +374,28 @@ mod tests {
         assert_eq!(recents[0].cwd, PathBuf::from("/d4"));
         assert_eq!(recents[1].cwd, PathBuf::from("/d3"));
     }
+
+    /// Project enrichment (#54) folds the whole log, not just the picker's
+    /// first page.
+    #[test]
+    fn all_recent_dirs_skips_the_result_cap() {
+        let tmp = tempfile::tempdir().unwrap();
+        let mut h = SpawnHistory::new(tmp.path().join("h.jsonl"), 30);
+        h.max_results = 2;
+        // Recent enough to survive the 30-day cap against the real clock.
+        let base = Utc::now() - Duration::hours(1);
+        for i in 0..5 {
+            h.append(&rec(
+                &format!("/d{i}"),
+                "claude",
+                base + Duration::minutes(i),
+            ))
+            .unwrap();
+        }
+        assert_eq!(h.recent_dirs().len(), 2);
+        let all = h.all_recent_dirs();
+        assert_eq!(all.len(), 5);
+        assert_eq!(all[0].cwd, PathBuf::from("/d4"));
+        assert_eq!(all[4].cwd, PathBuf::from("/d0"));
+    }
 }

crates/maestro-daemon/tests/attach.rs

@@ -37,6 +37,7 @@ async fn spawn_daemon_ws() -> Harness {
         "test-host",
         "/home/test",
         Vec::new(),
+        std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await

crates/maestro-daemon/tests/local_api.rs

@@ -26,6 +26,17 @@ struct Harness {
 }
 
 async fn spawn(hostname: &str) -> Harness {
+    spawn_with(
+        hostname,
+        std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+    )
+    .await
+}
+
+async fn spawn_with(
+    hostname: &str,
+    projects: std::sync::Arc<maestro_daemon::projects::ProjectScanner>,
+) -> Harness {
     let fx = DaemonFixture::new();
     let manager = fx.manager.clone();
     // Built-in presets (claude/opencode/zsh + custom) so `/api/info` advertises
@@ -36,6 +47,7 @@ async fn spawn(hostname: &str) -> Harness {
         hostname,
         "/home/test",
         presets,
+        projects,
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await
@@ -153,6 +165,73 @@ async fn recent_dirs_returns_empty_without_history() {
     assert_eq!(resp["truncated"], false);
 }
 
+/// #54: `GET /api/projects` lists every git repo under the scan roots, with
+/// real git checkouts — not mocks.
+#[tokio::test]
+async fn projects_lists_repos_under_the_scan_roots() {
+    let tmp = tempfile::tempdir().unwrap();
+    for name in ["alpha", "beta"] {
+        let repo = tmp.path().join(name);
+        std::fs::create_dir_all(&repo).unwrap();
+        for args in [
+            vec!["init", "-q"],
+            vec![
+                "-c",
+                "user.email=t@t",
+                "-c",
+                "user.name=t",
+                "commit",
+                "-qm",
+                "init",
+                "--allow-empty",
+            ],
+        ] {
+            let out = std::process::Command::new("git")
+                .arg("-C")
+                .arg(&repo)
+                .args(&args)
+                .output()
+                .unwrap();
+            assert!(out.status.success());
+        }
+    }
+
+    let scanner = std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::new(
+        vec![tmp.path().to_path_buf()],
+        3,
+        tmp.path().to_path_buf(),
+    ));
+    let h = spawn_with("naps-laptop", scanner).await;
+
+    let projects: Vec<maestro_protocol::Project> = reqwest::get(url(h.addr, "/api/projects"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+
+    let mut names: Vec<&str> = projects.iter().map(|p| p.name.as_str()).collect();
+    names.sort();
+    assert_eq!(names, ["alpha", "beta"]);
+    for p in &projects {
+        assert!(!p.is_worktree);
+        assert_eq!(p.base_repo, None);
+        assert!(p.last_activity.is_some(), "fresh commit ⇒ HEAD mtime known");
+    }
+}
+
+#[tokio::test]
+async fn projects_returns_empty_for_a_disabled_scanner() {
+    let h = spawn("naps-laptop").await;
+    let projects: Vec<maestro_protocol::Project> = reqwest::get(url(h.addr, "/api/projects"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert!(projects.is_empty());
+}
+
 #[tokio::test]
 async fn gitroot_probes_path() {
     // #26: resolves the query against the daemon home dir and walks up for a

crates/maestro-protocol/src/client.rs

@@ -15,7 +15,8 @@ use uuid::Uuid;
 
 use crate::routes::{self, UrlError};
 use crate::{
-    ApiError, CreateSessionRequest, DaemonInfo, DirListing, ErrorInfo, GitRoot, RecentDirs, Session,
+    ApiError, CreateSessionRequest, DaemonInfo, DirListing, ErrorInfo, GitRoot, Project,
+    RecentDirs, Session,
 };
 
 /// Time budget for establishing a TCP connection to the daemon.
@@ -138,6 +139,10 @@ impl DaemonClient {
             .await
     }
 
+    pub async fn list_projects(&self) -> Result<Vec<Project>, ClientError> {
+        self.get(routes::PROJECTS, &[]).await
+    }
+
     // -- plumbing -----------------------------------------------------------
 
     async fn get<T: DeserializeOwned>(

crates/maestro-protocol/src/lib.rs

@@ -188,6 +188,30 @@ pub struct GitRoot {
     pub root: Option<PathBuf>,
 }
 
+/// One discovered git repository (or linked worktree) for `GET /api/projects`
+/// (#54). The daemon reports the timestamp; clients decide what "stale" means
+/// (the web UI dims entries older than 7 days).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Project {
+    /// Absolute path of the repository/worktree toplevel.
+    pub path: PathBuf,
+    /// Basename of `path`.
+    pub name: String,
+    #[serde(default)]
+    pub is_worktree: bool,
+    /// The main checkout this worktree belongs to. Set only when
+    /// [`Self::is_worktree`].
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub base_repo: Option<PathBuf>,
+    /// Later of the repo's git HEAD mtime and the newest spawn-history use of
+    /// any directory inside it. `None` when neither is known.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_activity: Option<DateTime<Utc>>,
+    /// Command last spawned in this project, from spawn history.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_command: Option<String>,
+}
+
 /// Structured failure used everywhere we don't want to leak a string-only error.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ErrorInfo {
@@ -329,6 +353,34 @@ mod tests {
         serde_json::from_str(&json).expect("deserialize")
     }
 
+    #[test]
+    fn project_round_trips_and_defaults_on_legacy_payload() {
+        let full = Project {
+            path: PathBuf::from("/home/u/tea/maestro"),
+            name: "maestro".into(),
+            is_worktree: true,
+            base_repo: Some(PathBuf::from("/home/u/tea/maestro-main")),
+            last_activity: Some(
+                DateTime::parse_from_rfc3339("2026-08-23T12:00:00Z")
+                    .unwrap()
+                    .with_timezone(&Utc),
+            ),
+            last_command: Some("claude".into()),
+        };
+        assert_eq!(full, round_trip(&full));
+
+        // A payload from a daemon predating the optional fields still decodes.
+        let legacy = serde_json::json!({
+            "path": "/home/u/proj",
+            "name": "proj",
+        });
+        let p: Project = serde_json::from_value(legacy).unwrap();
+        assert!(!p.is_worktree);
+        assert_eq!(p.base_repo, None);
+        assert_eq!(p.last_activity, None);
+        assert_eq!(p.last_command, None);
+    }
+
     fn sample_session() -> Session {
         Session {
             id: Uuid::from_u128(0x0123_4567_89ab_cdef_0123_4567_89ab_cdef),

crates/maestro-protocol/src/routes.rs

@@ -17,6 +17,8 @@ pub const INFO: &str = "/api/info";
 pub const DIRS: &str = "/api/dirs";
 /// `GET` spawn history.
 pub const RECENT_DIRS: &str = "/api/recent-dirs";
+/// `GET` discovered git repositories and worktrees, newest activity first.
+pub const PROJECTS: &str = "/api/projects";
 /// `GET` the enclosing repository of a path. Takes a `path` query param.
 pub const GITROOT: &str = "/api/gitroot";
 /// `WS` catalog snapshot + session deltas.
@@ -172,7 +174,7 @@ mod tests {
 
     #[test]
     fn every_route_sits_under_the_api_prefix() {
-        for path in [SESSIONS, INFO, DIRS, RECENT_DIRS, GITROOT, EVENTS] {
+        for path in [SESSIONS, INFO, DIRS, RECENT_DIRS, PROJECTS, GITROOT, EVENTS] {
             assert!(path.starts_with(API_PREFIX), "{path} escapes {API_PREFIX}");
         }
         assert!(attach(id()).starts_with(API_PREFIX));

crates/maestro-tui/src/action.rs

@@ -38,7 +38,7 @@ pub enum Action {
     // Catalog actions on the highlighted sidebar row
     AttachHighlighted,
     ToggleAttachHighlighted,
-    NewDraftPane,
+    OpenSpawnModal,
     KillHighlighted,
 
     // Tabs
@@ -78,7 +78,7 @@ impl Action {
             "SidebarPrev" => return Ok(Action::SidebarPrev),
             "AttachHighlighted" => return Ok(Action::AttachHighlighted),
             "ToggleAttachHighlighted" => return Ok(Action::ToggleAttachHighlighted),
-            "NewDraftPane" => return Ok(Action::NewDraftPane),
+            "OpenSpawnModal" => return Ok(Action::OpenSpawnModal),
             "KillHighlighted" => return Ok(Action::KillHighlighted),
             "NewTab" => return Ok(Action::NewTab),
             "CloseTab" => return Ok(Action::CloseTab),
@@ -202,7 +202,6 @@ mod tests {
         for a in [
             Action::EnterInsert,
             Action::Quit,
-            Action::NewDraftPane,
             Action::FocusPane(Direction::Right),
             Action::GotoTab(7),
         ] {
@@ -210,14 +209,4 @@ mod tests {
             assert_eq!(Action::parse(&s).unwrap(), a, "round-trip for {a:?}");
         }
     }
-
-    /// The spawn modal is gone (issue #63); its old action string must not
-    /// resolve to anything.
-    #[test]
-    fn the_removed_spawn_modal_action_no_longer_parses() {
-        assert_eq!(
-            Action::parse("OpenSpawnModal").unwrap_err(),
-            ActionParseError::Unknown("OpenSpawnModal".into())
-        );
-    }
 }

crates/maestro-tui/src/app.rs

@@ -6,9 +6,9 @@
 //! changes, and a 30Hz heartbeat.
 //!
 //! Actions mutate `AppState` directly. Side effects that talk to the daemon
-//! (`AttachHighlighted` spawning a `SessionTask`, a draft-pane submit firing
-//! a POST, `KillHighlighted` confirm firing a DELETE) live inline in
-//! `dispatch` / the Insert-mode pane routing.
+//! (`AttachHighlighted` spawning a `SessionTask`, `OpenSpawnModal` submit
+//! firing a POST, `KillHighlighted` confirm firing a DELETE) live inline in
+//! `dispatch` / `handle_overlay_input`.
 
 use std::collections::{HashMap, HashSet};
 use std::io::Stdout;
@@ -24,16 +24,15 @@ use uuid::Uuid;
 use crate::action::Action;
 use crate::catalog::CatalogStore;
 use crate::config::TuiConfig;
-use crate::draft::DraftInputResult;
 use crate::emulators::SessionEmulators;
 use crate::input::{canonicalise, ChordResult, ChordState, ClickTracker, InputKey};
 use crate::keymap::Mode;
-use crate::overlays::HelpOverlay;
+use crate::overlays::{HelpOverlay, SpawnModal};
 use crate::pane::{Pane, PaneStatus};
 use crate::render::{draw, RegionMap, RenderInputs};
 use crate::session_task::{SessionInput, SessionTask};
 use crate::sidebar::Sidebar;
-use crate::state::{AppState, Focus, OverlayKind, PaneRef};
+use crate::state::{AppState, Focus, OverlayKind};
 use crate::tabs::TabBar;
 use crate::TuiError;
 
@@ -50,6 +49,7 @@ pub struct App {
     catalog: CatalogStore,
     emulators: SessionEmulators,
     state: AppState,
+    spawn: SpawnModal,
     help: HelpOverlay,
     chord: ChordState,
     daemon: DaemonClient,
@@ -90,6 +90,7 @@ impl App {
             catalog,
             emulators: SessionEmulators::default(),
             state: AppState::new(),
+            spawn: SpawnModal::default(),
             help,
             chord: ChordState::new(chord_timeout),
             daemon,
@@ -151,15 +152,7 @@ impl App {
                     self.perform(effects).await;
                 } else if self.state.mode == Mode::Insert && matches!(self.state.focus, Focus::Pane)
                 {
-                    // Insert mode over a focused pane: a draft eats the key
-                    // into its form, a session gets the raw bytes.
-                    let effect = if matches!(self.state.active_tab().pane, Some(PaneRef::Draft(_)))
-                    {
-                        self.handle_draft_input(&key)
-                    } else {
-                        self.forward_to_session(&key)
-                    };
-                    if let Some(effect) = effect {
+                    if let Some(effect) = self.forward_to_session(&key) {
                         self.perform(vec![effect]).await;
                     }
                 }
@@ -186,7 +179,27 @@ impl App {
     }
 
     fn handle_overlay_input(&mut self, key: &InputKey) -> (OverlayDecision, Vec<Effect>) {
+        use crate::overlays::SpawnInputResult;
         match self.state.overlay().cloned() {
+            Some(OverlayKind::Spawn) => {
+                let mut effects = Vec::new();
+                match self.spawn.on_input(key) {
+                    SpawnInputResult::Consumed => {}
+                    SpawnInputResult::Cancel => {
+                        self.state.dismiss_overlay();
+                    }
+                    SpawnInputResult::Submit => {
+                        effects.push(Effect::Spawn(CreateSessionRequest {
+                            cwd: std::path::PathBuf::from(self.spawn.cwd.value().to_string()),
+                            command: self.spawn.command.value().to_string(),
+                            env: Default::default(),
+                            metadata: Default::default(),
+                            worktree: None,
+                        }));
+                    }
+                }
+                (OverlayDecision::Consumed, effects)
+            }
             Some(OverlayKind::KillConfirm(id)) => match key {
                 InputKey::Char { c: 'y', .. } => {
                     self.state.dismiss_overlay();
@@ -252,7 +265,14 @@ impl App {
                 };
                 self.state.show_overlay(OverlayKind::Help);
             }
-            Action::NewDraftPane => self.state.open_draft_pane(),
+            Action::OpenSpawnModal => {
+                self.spawn = SpawnModal {
+                    cwd: Default::default(),
+                    command: Default::default(),
+                    focused_field: Default::default(),
+                };
+                self.state.show_overlay(OverlayKind::Spawn);
+            }
             Action::AttachHighlighted | Action::ToggleAttachHighlighted => {
                 if let Some(sid) = self.pick_sidebar_target() {
                     effects.push(Effect::Attach(sid));
@@ -302,38 +322,44 @@ impl App {
     /// Encode a keystroke for the focused pane. `None` when there is nothing
     /// attached to send it to.
     fn forward_to_session(&mut self, key: &InputKey) -> Option<Effect> {
-        let sid = self.state.active_session()?;
+        let sid = self.state.active_tab().pane?;
         self.emulators.get(sid)?;
-        let bytes = encode_key(key)?;
-        Some(Effect::Forward { id: sid, bytes })
-    }
-
-    /// Feed one keystroke into the active tab's draft form. Returns the spawn
-    /// effect when the user accepted the form.
-    fn handle_draft_input(&mut self, key: &InputKey) -> Option<Effect> {
-        let PaneRef::Draft(draft) = self.state.active_tab_mut().pane.as_mut()? else {
-            return None;
+        let bytes = match key {
+            InputKey::Char { c, ctrl, alt, .. } => {
+                let mut out = Vec::with_capacity(8);
+                if *alt {
+                    out.push(0x1b);
+                }
+                if *ctrl && c.is_ascii_alphabetic() {
+                    out.push((c.to_ascii_uppercase() as u8) - b'@');
+                } else {
+                    let mut b = [0u8; 4];
+                    let s = c.encode_utf8(&mut b);
+                    out.extend_from_slice(s.as_bytes());
+                }
+                out
+            }
+            InputKey::Enter => b"\r".to_vec(),
+            InputKey::Tab => b"\t".to_vec(),
+            InputKey::BackTab => b"\x1b[Z".to_vec(),
+            InputKey::Backspace => vec![0x7f],
+            InputKey::Esc => vec![0x1b],
+            InputKey::Up => b"\x1b[A".to_vec(),
+            InputKey::Down => b"\x1b[B".to_vec(),
+            InputKey::Right => b"\x1b[C".to_vec(),
+            InputKey::Left => b"\x1b[D".to_vec(),
+            InputKey::Home => b"\x1b[H".to_vec(),
+            InputKey::End => b"\x1b[F".to_vec(),
+            InputKey::Delete => b"\x1b[3~".to_vec(),
+            InputKey::Paste(_) | InputKey::Mouse { .. } => return None,
         };
-        if draft.on_input(key) != DraftInputResult::Submit {
-            return None;
-        }
-        Some(Effect::Spawn(CreateSessionRequest {
-            cwd: std::path::PathBuf::from(draft.cwd.value().to_string()),
-            command: draft.command.value().to_string(),
-            env: Default::default(),
-            metadata: Default::default(),
-            worktree: None,
-        }))
+        Some(Effect::Forward { id: sid, bytes })
     }
 
     async fn submit_spawn(&mut self, req: CreateSessionRequest) {
         match self.daemon.create_session(&req).await {
-            Ok(session) => {
-                // Fill the pane in place with the new session (web parity,
-                // #57) and attach to it right away.
-                let sid = session.id;
-                self.state.complete_spawn(sid);
-                self.attach(sid);
+            Ok(_) => {
+                self.state.dismiss_overlay();
             }
             Err(e) => self.state.toast(format!("spawn failed: {e}")),
         }
@@ -351,12 +377,7 @@ impl App {
         terminal: &mut Terminal<CrosstermBackend<Stdout>>,
     ) -> Result<(), TuiError> {
         let snap = self.catalog.snapshot();
-        let attached: HashSet<Uuid> = self
-            .state
-            .tabs
-            .iter()
-            .filter_map(crate::state::Tab::session)
-            .collect();
+        let attached: HashSet<Uuid> = self.state.tabs.iter().filter_map(|t| t.pane).collect();
         let sidebar = Sidebar {
             sessions: snap.sessions.clone(),
             highlight: self.state.sidebar_highlight,
@@ -366,7 +387,7 @@ impl App {
             tab_names: self.state.tabs.iter().map(|t| t.name.clone()).collect(),
             active_idx: self.state.active_tab_idx,
         };
-        let active_sid = self.state.active_session();
+        let active_sid = self.state.active_tab().pane;
         let pane = active_sid.and_then(|sid| {
             self.emulators.get(sid).map(|h| Pane {
                 screen: h.screen.clone(),
@@ -374,17 +395,13 @@ impl App {
                 focused: matches!(self.state.focus, Focus::Pane),
             })
         });
-        let draft = match self.state.active_tab().pane.as_ref() {
-            Some(PaneRef::Draft(d)) => Some(d),
-            _ => None,
-        };
 
         let inputs = RenderInputs {
             sidebar: &sidebar,
             tab_bar: &tab_bar,
             pane: pane.as_ref(),
             state: &self.state,
-            draft,
+            spawn: &self.spawn,
             help: &self.help,
         };
 
@@ -432,43 +449,6 @@ fn visible_sidebar_order(snap: &crate::catalog::CatalogSnapshot) -> Vec<Uuid> {
     snap.sessions.iter().map(|s| s.id).collect()
 }
 
-/// Wire encoding for a keystroke headed to a session's PTY. `None` for keys
-/// with no byte representation (mouse events). A bracketed paste is forwarded
-/// verbatim — the remote readline reassembles it, since the pane's PTY also
-/// has bracketed paste enabled.
-fn encode_key(key: &InputKey) -> Option<Vec<u8>> {
-    match key {
-        InputKey::Char { c, ctrl, alt, .. } => {
-            let mut out = Vec::with_capacity(8);
-            if *alt {
-                out.push(0x1b);
-            }
-            if *ctrl && c.is_ascii_alphabetic() {
-                out.push((c.to_ascii_uppercase() as u8) - b'@');
-            } else {
-                let mut b = [0u8; 4];
-                let s = c.encode_utf8(&mut b);
-                out.extend_from_slice(s.as_bytes());
-            }
-            Some(out)
-        }
-        InputKey::Enter => Some(b"\r".to_vec()),
-        InputKey::Tab => Some(b"\t".to_vec()),
-        InputKey::BackTab => Some(b"\x1b[Z".to_vec()),
-        InputKey::Backspace => Some(vec![0x7f]),
-        InputKey::Esc => Some(vec![0x1b]),
-        InputKey::Up => Some(b"\x1b[A".to_vec()),
-        InputKey::Down => Some(b"\x1b[B".to_vec()),
-        InputKey::Right => Some(b"\x1b[C".to_vec()),
-        InputKey::Left => Some(b"\x1b[D".to_vec()),
-        InputKey::Home => Some(b"\x1b[H".to_vec()),
-        InputKey::End => Some(b"\x1b[F".to_vec()),
-        InputKey::Delete => Some(b"\x1b[3~".to_vec()),
-        InputKey::Paste(text) => Some(text.as_bytes().to_vec()),
-        InputKey::Mouse { .. } => None,
-    }
-}
-
 /// Build the lines shown by the help overlay from the live keymap, so the
 /// user always sees the bindings that are actually active (defaults + their
 /// own `[tui.keymap.*]` overrides).
@@ -536,33 +516,10 @@ mod tests {
     }
 
     #[test]
-    fn new_draft_pane_opens_a_focused_draft_in_the_empty_tab() {
+    fn open_spawn_modal_sets_overlay() {
         let mut app = make_app();
-        app.dispatch(Action::NewDraftPane);
-        assert!(matches!(
-            app.state.active_tab().pane,
-            Some(PaneRef::Draft(_))
-        ));
-        assert_eq!(app.state.focus, Focus::Pane);
-        assert_eq!(app.state.mode, Mode::Insert);
-        assert!(app.state.overlay().is_none(), "no overlay involved");
-    }
-
-    /// A tab already showing a session gets a new tab for the draft.
-    #[test]
-    fn new_draft_pane_over_a_session_opens_a_new_tab() {
-        let sid = Uuid::from_u128(10);
-        let mut app = app_with_highlighted_session(sid);
-        app.dispatch(Action::AttachHighlighted);
-
-        app.dispatch(Action::NewDraftPane);
-        assert_eq!(app.state.tabs.len(), 2);
-        assert_eq!(app.state.active_tab_idx, 1);
-        assert!(matches!(
-            app.state.active_tab().pane,
-            Some(PaneRef::Draft(_))
-        ));
-        assert_eq!(app.state.tabs[0].session(), Some(sid));
+        app.dispatch(Action::OpenSpawnModal);
+        assert!(matches!(app.state.overlay(), Some(OverlayKind::Spawn)));
     }
 
     /// Seed the catalog with one session and highlight it.
@@ -597,7 +554,7 @@ mod tests {
             app.dispatch(Action::AttachHighlighted),
             vec![Effect::Attach(sid)]
         );
-        assert_eq!(app.state.active_tab().session(), Some(sid));
+        assert_eq!(app.state.active_tab().pane, Some(sid));
     }
 
     #[test]
@@ -630,35 +587,23 @@ mod tests {
     }
 
     #[test]
-    fn typing_into_the_draft_then_enter_carries_the_typed_fields() {
+    fn submitting_the_spawn_modal_carries_the_typed_fields() {
         let mut app = make_app();
-        app.dispatch(Action::NewDraftPane);
+        app.dispatch(Action::OpenSpawnModal);
+        app.spawn.cwd = crate::text_input::TextInput::with_value("/srv/work");
+        app.spawn.command = crate::text_input::TextInput::with_value("claude");
+        app.spawn.focused_field = crate::overlays::SpawnField::Submit;
 
-        for c in "/srv/work".chars() {
-            app.handle_draft_input(&InputKey::char(c));
-        }
-        app.handle_draft_input(&InputKey::Tab); // cwd → command
-        for c in "claude".chars() {
-            app.handle_draft_input(&InputKey::char(c));
-        }
-        app.handle_draft_input(&InputKey::Tab); // command → submit
-
-        match app.handle_draft_input(&InputKey::Enter) {
-            Some(Effect::Spawn(req)) => {
+        let (_, effects) = app.handle_overlay_input(&InputKey::Enter);
+        match effects.as_slice() {
+            [Effect::Spawn(req)] => {
                 assert_eq!(req.cwd, std::path::PathBuf::from("/srv/work"));
                 assert_eq!(req.command, "claude");
             }
-            other => panic!("expected a Spawn effect, got {other:?}"),
+            other => panic!("expected one Spawn effect, got {other:?}"),
         }
     }
 
-    /// Keys fed while no draft exists must be ignored, not panic.
-    #[test]
-    fn draft_input_is_a_no_op_without_a_draft() {
-        let mut app = make_app();
-        assert!(app.handle_draft_input(&InputKey::char('x')).is_none());
-    }
-
     /// Regression: `Toast` returned `Pass` and nothing ever cleared it, so a
     /// failure message stayed on screen until another overlay replaced it.
     #[test]
@@ -687,37 +632,6 @@ mod tests {
         assert!(app.forward_to_session(&InputKey::Enter).is_none());
     }
 
-    /// A draft pane is not a session: forwarding must not try to reach it.
-    #[test]
-    fn forwarding_is_a_no_op_with_a_draft_pane() {
-        let mut app = make_app();
-        app.dispatch(Action::NewDraftPane);
-        assert!(app.forward_to_session(&InputKey::Enter).is_none());
-    }
-
-    /// Regression review fix: `Paste(_)` used to be silently dropped, so a
-    /// paste into an attached session vanished once bracketed paste was
-    /// enabled — the payload must be forwarded verbatim.
-    #[test]
-    fn a_bracketed_paste_is_forwarded_verbatim_to_the_session() {
-        assert_eq!(
-            encode_key(&InputKey::Paste("cd /tmp/foo".into())),
-            Some(b"cd /tmp/foo".to_vec())
-        );
-    }
-
-    #[test]
-    fn mouse_events_have_no_wire_encoding() {
-        use crate::input::{MouseKind, Region};
-        assert!(encode_key(&InputKey::Mouse {
-            kind: MouseKind::Click,
-            region: Region::Pane,
-            col: 3,
-            row: 4,
-        })
-        .is_none());
-    }
-
     #[test]
     fn kill_highlighted_opens_confirm() {
         use chrono::Utc;

crates/maestro-tui/src/config.rs

@@ -45,7 +45,7 @@ const DEFAULT_NORMAL: &[(&str, &str)] = &[
     ("up", "SidebarPrev"),
     // Catalog actions
     ("enter", "AttachHighlighted"),
-    ("s", "NewDraftPane"),
+    ("s", "OpenSpawnModal"),
     ("x", "KillHighlighted"),
     // Tabs
     ("ctrl-t", "NewTab"),
@@ -155,10 +155,6 @@ mod tests {
             cfg.keymap.resolve(Mode::Normal, "g t"),
             Some(Action::NextTab),
         );
-        assert_eq!(
-            cfg.keymap.resolve(Mode::Normal, "s"),
-            Some(Action::NewDraftPane),
-        );
     }
 
     #[test]

crates/maestro-tui/src/draft.rs

@@ -1,272 +0,0 @@
-//! Draft pane — the spawn form living in an ordinary pane (issue #63).
-//!
-//! An empty pane renders a [`DraftPane`] instead of nothing; submitting hands
-//! the caller a built request and the pane is replaced with the new session,
-//! matching the web client's inline draft panes (#57). Field editing goes
-//! through [`crate::text_input::TextInput`]; Tab / BackTab walk the fields.
-//!
-//! Scope note: presets, the project list, generated names, and the worktree
-//! section land with issues #64/#65 — this is cwd + command only.
-
-use ratatui::layout::{Constraint, Layout, Rect};
-use ratatui::style::{Modifier, Style};
-use ratatui::text::{Line, Span};
-use ratatui::widgets::{Block, Borders, Paragraph};
-use ratatui::Frame;
-
-use crate::input::InputKey;
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-pub enum DraftField {
-    #[default]
-    Cwd,
-    Command,
-    Submit,
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct DraftPane {
-    pub cwd: crate::text_input::TextInput,
-    pub command: crate::text_input::TextInput,
-    pub focused_field: DraftField,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DraftInputResult {
-    Consumed,
-    Submit,
-}
-
-impl DraftPane {
-    pub fn next_field(&mut self) {
-        self.focused_field = match self.focused_field {
-            DraftField::Cwd => DraftField::Command,
-            DraftField::Command => DraftField::Submit,
-            DraftField::Submit => DraftField::Cwd,
-        };
-    }
-
-    pub fn prev_field(&mut self) {
-        self.focused_field = match self.focused_field {
-            DraftField::Cwd => DraftField::Submit,
-            DraftField::Command => DraftField::Cwd,
-            DraftField::Submit => DraftField::Command,
-        };
-    }
-
-    /// Handle one keystroke while this draft owns input (Insert mode, pane
-    /// focused). Returns [`DraftInputResult::Submit`] when the user accepts;
-    /// the caller fires the POST and replaces the draft with the session.
-    pub fn on_input(&mut self, key: &InputKey) -> DraftInputResult {
-        match key {
-            InputKey::Tab => {
-                self.next_field();
-                DraftInputResult::Consumed
-            }
-            InputKey::BackTab => {
-                self.prev_field();
-                DraftInputResult::Consumed
-            }
-            InputKey::Enter => match self.focused_field {
-                DraftField::Submit => DraftInputResult::Submit,
-                _ => {
-                    self.next_field();
-                    DraftInputResult::Consumed
-                }
-            },
-            // Everything else — characters, motion, editing, paste — goes to
-            // the focused field's text input.
-            other => {
-                match self.focused_field {
-                    DraftField::Cwd => self.cwd.handle_key(other),
-                    DraftField::Command => self.command.handle_key(other),
-                    DraftField::Submit => {}
-                }
-                DraftInputResult::Consumed
-            }
-        }
-    }
-
-    /// Draw into the pane area. `pane_focused` gates the field highlight and
-    /// cursor placement the same way a session pane hides its cursor when
-    /// unfocused.
-    pub fn render(&self, f: &mut Frame, area: Rect, pane_focused: bool) {
-        let block = Block::default().title(" draft ").borders(Borders::ALL);
-        let inner = block.inner(area);
-        f.render_widget(block, area);
-        let rows = Layout::vertical([
-            Constraint::Length(2),
-            Constraint::Length(2),
-            Constraint::Length(1),
-        ])
-        .split(inner);
-
-        let style_for = |field: DraftField| {
-            if pane_focused && self.focused_field == field {
-                Style::default().add_modifier(Modifier::REVERSED)
-            } else {
-                Style::default()
-            }
-        };
-
-        // Each text field renders through the shared `TextInput`, which
-        // handles horizontal scrolling and reports where the terminal cursor
-        // belongs. Label is fixed-width 8 chars + 1 space = column 9.
-        let label = |text: &str| Paragraph::new(Line::from(Span::raw(format!("{text:8} "))));
-        f.render_widget(label("cwd:"), rows[0]);
-        f.render_widget(label("command:"), rows[1]);
-        let draw_field =
-            |f: &mut Frame, input: &crate::text_input::TextInput, row: Rect, style: Style| -> u16 {
-                let area = Rect {
-                    x: row.x.saturating_add(9),
-                    y: row.y,
-                    width: row.width.saturating_sub(9),
-                    height: 1,
-                };
-                input.render(area, f.buffer_mut(), style)
-            };
-        let cwd_col = draw_field(f, &self.cwd, rows[0], style_for(DraftField::Cwd));
-        let cmd_col = draw_field(f, &self.command, rows[1], style_for(DraftField::Command));
-
-        f.render_widget(
-            Paragraph::new(Line::from(vec![Span::styled(
-                "[ Spawn ]",
-                style_for(DraftField::Submit),
-            )])),
-            rows[2],
-        );
-
-        if pane_focused {
-            match self.focused_field {
-                DraftField::Cwd => f.set_cursor_position((cwd_col, rows[0].y)),
-                DraftField::Command => f.set_cursor_position((cmd_col, rows[1].y)),
-                DraftField::Submit => {
-                    // The submit button is indicated by the REVERSED style; no
-                    // cursor placement.
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ratatui::backend::TestBackend;
-    use ratatui::Terminal;
-
-    fn render_to_string(w: u16, h: u16, draw: impl FnOnce(&mut Frame)) -> String {
-        let backend = TestBackend::new(w, h);
-        let mut terminal = Terminal::new(backend).unwrap();
-        terminal.draw(draw).unwrap();
-        let buf = terminal.backend().buffer().clone();
-        let mut out = String::new();
-        for y in 0..buf.area.height {
-            for x in 0..buf.area.width {
-                out.push_str(buf[(x, y)].symbol());
-            }
-            out.push('\n');
-        }
-        out
-    }
-
-    #[test]
-    fn draft_pane_renders_field_labels_and_values() {
-        let draft = DraftPane {
-            cwd: crate::text_input::TextInput::with_value("/x"),
-            command: crate::text_input::TextInput::with_value("bash"),
-            focused_field: DraftField::Cwd,
-        };
-        let rendered = render_to_string(80, 20, |f| draft.render(f, f.area(), true));
-        for s in ["cwd", "command", "draft", "Spawn", "/x", "bash"] {
-            assert!(rendered.contains(s), "missing {s:?}:\n{rendered}");
-        }
-    }
-
-    #[test]
-    fn field_rotation_wraps_in_both_directions() {
-        let mut draft = DraftPane::default();
-        assert_eq!(draft.focused_field, DraftField::Cwd);
-        draft.next_field();
-        assert_eq!(draft.focused_field, DraftField::Command);
-        draft.next_field();
-        assert_eq!(draft.focused_field, DraftField::Submit);
-        draft.next_field();
-        assert_eq!(draft.focused_field, DraftField::Cwd);
-        draft.prev_field();
-        assert_eq!(draft.focused_field, DraftField::Submit);
-
-        draft.on_input(&InputKey::BackTab);
-        assert_eq!(draft.focused_field, DraftField::Command);
-        draft.on_input(&InputKey::Tab);
-        draft.on_input(&InputKey::Tab);
-        assert_eq!(draft.focused_field, DraftField::Cwd);
-    }
-
-    /// Editing keys must reach the focused field's text input, not a bare
-    /// String — this is what gives the operator cursor motion and word ops.
-    #[test]
-    fn editing_keys_reach_the_focused_text_input() {
-        let mut draft = DraftPane::default();
-        assert_eq!(draft.focused_field, DraftField::Cwd);
-        for k in [
-            InputKey::char('/'),
-            InputKey::char('t'),
-            InputKey::char('m'),
-            InputKey::char('p'),
-        ] {
-            draft.on_input(&k);
-        }
-        draft.on_input(&InputKey::Left);
-        draft.on_input(&InputKey::Backspace);
-        assert_eq!(draft.cwd.value(), "/tp");
-
-        // Tab to command, then a paste and ctrl-w land there, not in cwd.
-        draft.on_input(&InputKey::Tab);
-        assert_eq!(draft.focused_field, DraftField::Command);
-        draft.on_input(&InputKey::Paste("/tmp/foo".into()));
-        assert_eq!(draft.command.value(), "/tmp/foo");
-        draft.on_input(&InputKey::ctrl_char('w'));
-        assert_eq!(draft.command.value(), "");
-        assert_eq!(draft.cwd.value(), "/tp", "cwd untouched while unfocused");
-    }
-
-    /// Enter walks forward until the submit field, where it submits.
-    #[test]
-    fn enter_walks_fields_then_submits_from_submit() {
-        let mut draft = DraftPane::default();
-        assert_eq!(draft.on_input(&InputKey::Enter), DraftInputResult::Consumed);
-        assert_eq!(draft.focused_field, DraftField::Command);
-        assert_eq!(draft.on_input(&InputKey::Enter), DraftInputResult::Consumed);
-        assert_eq!(draft.focused_field, DraftField::Submit);
-        assert_eq!(draft.on_input(&InputKey::Enter), DraftInputResult::Submit);
-    }
-
-    /// The terminal cursor must sit right after the typed text in the focused
-    /// field (label is 8 chars + 1 space, block border takes column 0).
-    #[test]
-    fn render_places_the_cursor_after_the_typed_text_when_focused() {
-        let draft = DraftPane {
-            cwd: crate::text_input::TextInput::with_value("abc"),
-            ..DraftPane::default()
-        };
-        let backend = TestBackend::new(80, 20);
-        let mut terminal = Terminal::new(backend).unwrap();
-        terminal.draw(|f| draft.render(f, f.area(), true)).unwrap();
-        let pos = terminal.get_cursor_position().unwrap();
-        assert_eq!(pos, ratatui::layout::Position::new(1 + 9 + 3, 1));
-
-        // Unfocused pane: no field highlight either.
-        let rendered_unfocused = render_to_string(80, 20, |f| draft.render(f, f.area(), false));
-        let backend = TestBackend::new(80, 20);
-        let mut terminal = Terminal::new(backend).unwrap();
-        terminal.draw(|f| draft.render(f, f.area(), false)).unwrap();
-        let buf = terminal.backend().buffer();
-        assert!(
-            !buf.content()
-                .iter()
-                .any(|c| c.modifier.contains(ratatui::style::Modifier::REVERSED)),
-            "unfocused draft must not highlight fields:\n{rendered_unfocused}"
-        );
-    }
-}

crates/maestro-tui/src/lib.rs

@@ -7,7 +7,6 @@ pub mod app;
 pub mod catalog;
 pub mod cli;
 pub mod config;
-pub mod draft;
 pub mod emulators;
 pub mod input;
 pub mod keymap;

crates/maestro-tui/src/overlays.rs

@@ -1,16 +1,161 @@
-//! Overlay widgets: kill-confirm prompt, help overlay, transient toast.
-//!
-//! The spawn form is no longer an overlay (issue #63) — it lives in draft
-//! panes ([`crate::draft::DraftPane`]).
+//! Overlay widgets: spawn modal, kill-confirm prompt, help overlay,
+//! transient toast.
 //!
 //! All overlays are centered popups drawn over the rest of the UI; the
 //! `Clear` widget wipes the underlying buffer before drawing.
 
-use ratatui::layout::Rect;
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::{Modifier, Style};
 use ratatui::text::Line;
 use ratatui::widgets::{Block, Borders, Clear, List, ListItem, Paragraph};
 use ratatui::Frame;
 
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum SpawnField {
+    #[default]
+    Cwd,
+    Command,
+    Submit,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct SpawnModal {
+    pub cwd: crate::text_input::TextInput,
+    pub command: crate::text_input::TextInput,
+    pub focused_field: SpawnField,
+}
+
+impl SpawnModal {
+    pub fn next_field(&mut self) {
+        self.focused_field = match self.focused_field {
+            SpawnField::Cwd => SpawnField::Command,
+            SpawnField::Command => SpawnField::Submit,
+            SpawnField::Submit => SpawnField::Cwd,
+        };
+    }
+
+    pub fn prev_field(&mut self) {
+        self.focused_field = match self.focused_field {
+            SpawnField::Cwd => SpawnField::Submit,
+            SpawnField::Command => SpawnField::Cwd,
+            SpawnField::Submit => SpawnField::Command,
+        };
+    }
+
+    /// Handle one keystroke while this modal owns input. Returns
+    /// [`SpawnInputResult::Submit`] when the user accepts; the caller fires
+    /// the POST and dismisses the modal.
+    pub fn on_input(&mut self, key: &crate::input::InputKey) -> SpawnInputResult {
+        use crate::input::InputKey;
+        match key {
+            InputKey::Tab => {
+                self.next_field();
+                SpawnInputResult::Consumed
+            }
+            InputKey::BackTab => {
+                self.prev_field();
+                SpawnInputResult::Consumed
+            }
+            InputKey::Esc => SpawnInputResult::Cancel,
+            InputKey::Enter => match self.focused_field {
+                SpawnField::Submit => SpawnInputResult::Submit,
+                _ => {
+                    self.next_field();
+                    SpawnInputResult::Consumed
+                }
+            },
+            // Everything else — characters, motion, editing, paste — goes to
+            // the focused field's text input.
+            other => {
+                match self.focused_field {
+                    SpawnField::Cwd => self.cwd.handle_key(other),
+                    SpawnField::Command => self.command.handle_key(other),
+                    SpawnField::Submit => {}
+                }
+                SpawnInputResult::Consumed
+            }
+        }
+    }
+
+    pub fn render(&self, f: &mut Frame, parent: Rect) {
+        let area = centered(parent, 60, 10);
+        f.render_widget(Clear, area);
+        let block = Block::default().title(" spawn ").borders(Borders::ALL);
+        let inner = block.inner(area);
+        f.render_widget(block, area);
+        let rows = Layout::vertical([
+            Constraint::Length(2),
+            Constraint::Length(2),
+            Constraint::Length(1),
+        ])
+        .split(inner);
+        let highlight = |field: SpawnField| {
+            if self.focused_field == field {
+                Style::default().add_modifier(Modifier::REVERSED)
+            } else {
+                Style::default()
+            }
+        };
+
+        // Each text field renders through the shared `TextInput`, which
+        // handles horizontal scrolling and reports where the terminal cursor
+        // belongs. Label is fixed-width 8 chars + 1 space = column 9.
+        let label =
+            |text: &str| Paragraph::new(Line::from(ratatui::text::Span::raw(format!("{text:8} "))));
+        f.render_widget(label("cwd:"), rows[0]);
+        f.render_widget(label("command:"), rows[1]);
+        let draw_field = |f: &mut Frame,
+                          input: &crate::text_input::TextInput,
+                          row: Rect,
+                          focused: bool|
+         -> u16 {
+            let style = if focused {
+                Style::default().add_modifier(Modifier::REVERSED)
+            } else {
+                Style::default()
+            };
+            let area = Rect {
+                x: row.x.saturating_add(9),
+                y: row.y,
+                width: row.width.saturating_sub(9),
+                height: 1,
+            };
+            input.render(area, f.buffer_mut(), style)
+        };
+        let cwd_col = draw_field(f, &self.cwd, rows[0], self.focused_field == SpawnField::Cwd);
+        let cmd_col = draw_field(
+            f,
+            &self.command,
+            rows[1],
+            self.focused_field == SpawnField::Command,
+        );
+
+        f.render_widget(
+            Paragraph::new(Line::from(vec![ratatui::text::Span::styled(
+                "[ Spawn ]",
+                highlight(SpawnField::Submit),
+            )])),
+            rows[2],
+        );
+
+        match self.focused_field {
+            SpawnField::Cwd => f.set_cursor_position((cwd_col, rows[0].y)),
+            SpawnField::Command => f.set_cursor_position((cmd_col, rows[1].y)),
+            SpawnField::Submit => {
+                // The submit button is indicated by the REVERSED style; no
+                // cursor placement.
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SpawnInputResult {
+    Consumed,
+    Cancel,
+    Submit,
+}
+
 #[derive(Debug, Clone)]
 pub struct KillConfirm {
     pub label: String,
@@ -117,6 +262,33 @@ mod tests {
         out
     }
 
+    #[test]
+    fn spawn_modal_renders_field_labels() {
+        let modal = SpawnModal {
+            cwd: crate::text_input::TextInput::with_value("/x"),
+            command: crate::text_input::TextInput::with_value("bash"),
+            focused_field: SpawnField::Cwd,
+        };
+        let rendered = render_to_string(80, 20, |f| modal.render(f, f.area()));
+        for s in ["cwd", "command", "Spawn", "/x", "bash"] {
+            assert!(rendered.contains(s), "missing {s:?}:\n{rendered}");
+        }
+    }
+
+    #[test]
+    fn spawn_modal_field_rotation() {
+        let mut modal = SpawnModal::default();
+        assert_eq!(modal.focused_field, SpawnField::Cwd);
+        modal.next_field();
+        assert_eq!(modal.focused_field, SpawnField::Command);
+        modal.next_field();
+        assert_eq!(modal.focused_field, SpawnField::Submit);
+        modal.next_field();
+        assert_eq!(modal.focused_field, SpawnField::Cwd);
+        modal.prev_field();
+        assert_eq!(modal.focused_field, SpawnField::Submit);
+    }
+
     #[test]
     fn kill_confirm_renders_prompt() {
         let modal = KillConfirm {
@@ -134,11 +306,81 @@ mod tests {
         let help = HelpOverlay {
             lines: vec![
                 "i           EnterInsert".into(),
-                "s           NewDraftPane".into(),
+                "s           OpenSpawnModal".into(),
             ],
         };
         let rendered = render_to_string(80, 12, |f| help.render(f, f.area()));
         assert!(rendered.contains("EnterInsert"));
-        assert!(rendered.contains("NewDraftPane"));
+        assert!(rendered.contains("OpenSpawnModal"));
+    }
+    /// Shift-Tab walked nowhere: `prev_field` existed with no caller, so the
+    /// spawn modal could only be cycled forwards.
+    #[test]
+    fn shift_tab_walks_the_spawn_modal_backwards() {
+        let mut modal = SpawnModal::default();
+        assert_eq!(modal.focused_field, SpawnField::Cwd);
+
+        modal.on_input(&crate::input::InputKey::BackTab);
+        assert_eq!(modal.focused_field, SpawnField::Submit);
+
+        modal.on_input(&crate::input::InputKey::BackTab);
+        assert_eq!(modal.focused_field, SpawnField::Command);
+    }
+
+    #[test]
+    fn tab_and_shift_tab_are_inverses() {
+        let mut modal = SpawnModal::default();
+        for _ in 0..3 {
+            modal.on_input(&crate::input::InputKey::Tab);
+            modal.on_input(&crate::input::InputKey::BackTab);
+            assert_eq!(modal.focused_field, SpawnField::Cwd);
+        }
+    }
+
+    /// Editing keys must reach the focused field's text input, not a bare
+    /// String — this is what gives the operator cursor motion and word ops.
+    #[test]
+    fn editing_keys_reach_the_focused_text_input() {
+        let mut modal = SpawnModal::default();
+        assert_eq!(modal.focused_field, SpawnField::Cwd);
+        for k in [
+            crate::input::InputKey::char('/'),
+            crate::input::InputKey::char('t'),
+            crate::input::InputKey::char('m'),
+            crate::input::InputKey::char('p'),
+        ] {
+            modal.on_input(&k);
+        }
+        modal.on_input(&crate::input::InputKey::Left);
+        modal.on_input(&crate::input::InputKey::Backspace);
+        assert_eq!(modal.cwd.value(), "/tp");
+
+        // Tab to command, then a paste and ctrl-w land there, not in cwd.
+        modal.on_input(&crate::input::InputKey::Tab);
+        assert_eq!(modal.focused_field, SpawnField::Command);
+        modal.on_input(&crate::input::InputKey::Paste("/tmp/foo".into()));
+        assert_eq!(modal.command.value(), "/tmp/foo");
+        modal.on_input(&crate::input::InputKey::ctrl_char('w'));
+        assert_eq!(modal.command.value(), "");
+        assert_eq!(modal.cwd.value(), "/tp", "cwd untouched while unfocused");
+    }
+
+    /// The terminal cursor must sit right after the typed text in the focused
+    /// field (label is 8 chars + 1 space, modal is centered on screen).
+    #[test]
+    fn render_places_the_cursor_after_the_typed_text() {
+        use ratatui::backend::TestBackend;
+        use ratatui::Terminal;
+
+        let modal = SpawnModal {
+            cwd: crate::text_input::TextInput::with_value("abc"),
+            ..SpawnModal::default()
+        };
+        let backend = TestBackend::new(80, 20);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal.draw(|f| modal.render(f, f.area())).unwrap();
+        // Modal: x = (80-60)/2 = 10; block border → inner.x = 11; label col 9.
+        let pos = terminal.get_cursor_position().unwrap();
+        assert_eq!(pos, ratatui::layout::Position::new(11 + 9 + 3, 6));
     }
 }

crates/maestro-tui/src/render.rs

@@ -10,7 +10,7 @@ use ratatui::Frame;
 
 use crate::input::Region;
 use crate::keymap::Mode;
-use crate::overlays::{HelpOverlay, KillConfirm, Toast};
+use crate::overlays::{HelpOverlay, KillConfirm, SpawnModal, Toast};
 use crate::pane::Pane;
 use crate::sidebar::Sidebar;
 use crate::state::{AppState, Focus, OverlayKind};
@@ -63,9 +63,8 @@ pub struct RenderInputs<'a> {
     pub sidebar: &'a Sidebar,
     pub tab_bar: &'a TabBar,
     pub pane: Option<&'a Pane>,
-    /// Inline spawn form when the active tab's pane is a draft (issue #63).
-    pub draft: Option<&'a crate::draft::DraftPane>,
     pub state: &'a AppState,
+    pub spawn: &'a SpawnModal,
     pub help: &'a HelpOverlay,
 }
 
@@ -132,9 +131,6 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
     if let Some(p) = inputs.pane {
         p.render(f, pane_area);
     }
-    if let Some(d) = inputs.draft {
-        d.render(f, pane_area, pane_focused);
-    }
     map.pane = Some(pane_area);
 
     // Status bar — always visible, never eclipsed by overlays so the user can
@@ -142,6 +138,10 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
     render_status_bar(f, status_area, inputs.state);
 
     match inputs.state.overlay() {
+        Some(OverlayKind::Spawn) => {
+            inputs.spawn.render(f, area);
+            map.modal = Some(area);
+        }
         Some(OverlayKind::KillConfirm(id)) => {
             let kc = KillConfirm {
                 label: id.to_string(),
@@ -186,7 +186,7 @@ fn render_status_bar(f: &mut Frame, area: Rect, state: &AppState) {
         Focus::Pane => "pane",
     };
     let hint = match state.mode {
-        Mode::Normal => "j/k: nav  •  enter: attach  •  s: new draft  •  ?: help  •  ^Wq: quit",
+        Mode::Normal => "j/k: nav  •  enter: attach  •  s: spawn  •  ?: help  •  ^Wq: quit",
         Mode::Insert => "^a: back to normal",
     };
     let mode_style = match state.mode {
@@ -266,57 +266,4 @@ mod tests {
         assert_eq!(map.region_at(15, 10), Region::Modal);
         assert_eq!(map.region_at(3, 12), Region::SidebarRow); // outside modal
     }
-
-    /// Issue #63: an empty pane is a draft — the frame must show the spawn
-    /// form where the terminal would otherwise be.
-    #[test]
-    fn a_draft_pane_renders_the_spawn_form_in_its_pane_area() {
-        use crate::overlays::HelpOverlay;
-        use crate::state::PaneRef;
-        use std::collections::HashSet;
-
-        let mut state = AppState::new();
-        state.open_draft_pane();
-        let draft = match &state.tabs[0].pane {
-            Some(PaneRef::Draft(d)) => d,
-            other => panic!("expected a draft pane, got {other:?}"),
-        };
-        let sidebar = Sidebar {
-            sessions: Vec::new(),
-            highlight: None,
-            attached: HashSet::new(),
-        };
-        let tab_bar = TabBar {
-            tab_names: vec!["1".into()],
-            active_idx: 0,
-        };
-        let help = HelpOverlay { lines: Vec::new() };
-        let inputs = RenderInputs {
-            sidebar: &sidebar,
-            tab_bar: &tab_bar,
-            pane: None,
-            draft: Some(draft),
-            state: &state,
-            help: &help,
-        };
-
-        let backend = ratatui::backend::TestBackend::new(80, 24);
-        let mut terminal = ratatui::Terminal::new(backend).unwrap();
-        terminal
-            .draw(|f| {
-                draw(f, inputs);
-            })
-            .unwrap();
-        let buf = terminal.backend().buffer().clone();
-        let mut out = String::new();
-        for y in 0..buf.area.height {
-            for x in 0..buf.area.width {
-                out.push_str(buf[(x, y)].symbol());
-            }
-            out.push('\n');
-        }
-        for s in ["draft", "cwd:", "command:", "[ Spawn ]"] {
-            assert!(out.contains(s), "missing {s:?}:\n{out}");
-        }
-    }
 }

crates/maestro-tui/src/state.rs

@@ -1,16 +1,14 @@
 //! `AppState` — the top-level mutable state of the running TUI.
 //!
 //! v1 keeps it small on purpose: a list of tabs (each bound to at most one
-//! session or a draft form), an active tab index, focus split between sidebar
-//! and pane, the current input mode, and an optional overlay (kill confirm,
-//! help, transient toast). The spawn form is no longer an overlay — an empty
-//! pane is a draft pane (issue #63).
+//! session), an active tab index, focus split between sidebar and pane, the
+//! current input mode, and an optional overlay (spawn modal, kill confirm,
+//! help, transient toast).
 //!
-//! v1.5 will replace `Tab::pane`'s single slot with a split tree.
+//! v1.5 will replace `Tab::pane: Option<SessionId>` with a split tree.
 
 use uuid::Uuid;
 
-use crate::draft::DraftPane;
 use crate::keymap::Mode;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -19,31 +17,15 @@ pub enum Focus {
     Pane,
 }
 
-/// What a tab's pane slot holds: a live session, or an inline draft form.
-#[derive(Debug, Clone, PartialEq)]
-pub enum PaneRef {
-    Session(Uuid),
-    Draft(DraftPane),
-}
-
 #[derive(Debug, Clone)]
 pub struct Tab {
     pub name: String,
-    pub pane: Option<PaneRef>,
-}
-
-impl Tab {
-    /// The session this tab shows, if it shows one. Draft panes have none.
-    pub fn session(&self) -> Option<Uuid> {
-        match &self.pane {
-            Some(PaneRef::Session(sid)) => Some(*sid),
-            _ => None,
-        }
-    }
+    pub pane: Option<Uuid>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum OverlayKind {
+    Spawn,
     KillConfirm(Uuid),
     Help,
     Toast(String),
@@ -126,8 +108,7 @@ impl AppState {
     ///
     /// Returns the session that tab was showing, if any, so the caller can
     /// release its emulator. Without that the tab's WebSocket task and vt100
-    /// parser outlive the tab forever. A draft pane holds no session and
-    /// releases nothing.
+    /// parser outlive the tab forever.
     pub fn close_tab(&mut self) -> Option<Uuid> {
         if self.tabs.len() <= 1 {
             return None;
@@ -136,10 +117,9 @@ impl AppState {
         if self.active_tab_idx >= self.tabs.len() {
             self.active_tab_idx = self.tabs.len() - 1;
         }
-        let sid = closed.session()?;
         // Only release it if no other tab still shows the same session.
-        let still_shown = self.tabs.iter().any(|t| t.session() == Some(sid));
-        (!still_shown).then_some(sid)
+        let still_shown = self.tabs.iter().any(|t| t.pane == closed.pane);
+        closed.pane.filter(|_| !still_shown)
     }
 
     pub fn next_tab(&mut self) {
@@ -167,37 +147,11 @@ impl AppState {
     /// drop straight into Insert mode so keystrokes go to the session
     /// without an extra `i` press. The leader returns to Normal.
     pub fn attach_to_focused(&mut self, session_id: Uuid) {
-        self.active_tab_mut().pane = Some(PaneRef::Session(session_id));
+        self.active_tab_mut().pane = Some(session_id);
         self.focus = Focus::Pane;
         self.mode = Mode::Insert;
     }
 
-    /// Open a draft form in a pane (issue #63): reuse the empty active pane,
-    /// otherwise open a fresh tab for it — v1 has no split tree, so "split"
-    /// means a new tab. Focus lands in the pane, Insert mode on, so typing
-    /// starts immediately, same flow as [`Self::attach_to_focused`].
-    pub fn open_draft_pane(&mut self) {
-        if self.active_tab().pane.is_some() {
-            self.new_tab();
-        }
-        self.active_tab_mut().pane = Some(PaneRef::Draft(DraftPane::default()));
-        self.focus = Focus::Pane;
-        self.mode = Mode::Insert;
-    }
-
-    /// A draft submit succeeded: replace whatever the active tab showed with
-    /// the new session in place, matching the web client's behaviour (#57).
-    pub fn complete_spawn(&mut self, sid: Uuid) {
-        self.active_tab_mut().pane = Some(PaneRef::Session(sid));
-        self.focus = Focus::Pane;
-        self.mode = Mode::Insert;
-    }
-
-    /// The session shown by the active tab's pane, if any.
-    pub fn active_session(&self) -> Option<Uuid> {
-        self.active_tab().session()
-    }
-
     /// Move the sidebar highlight by `delta` (positive = down) within the
     /// given ordered list of selectable session ids. Wraps. No-op on empty.
     pub fn move_sidebar_highlight(&mut self, order: &[Uuid], delta: i32) {
@@ -334,7 +288,7 @@ mod tests {
         let mut state = AppState::new();
         let sid = Uuid::from_u128(7);
         state.attach_to_focused(sid);
-        assert_eq!(state.tabs[0].session(), Some(sid));
+        assert_eq!(state.tabs[0].pane, Some(sid));
         assert_eq!(state.focus, Focus::Pane);
         // The user expects to type into the session right away; the leader
         // (default ctrl-a) is the way back.
@@ -360,7 +314,7 @@ mod tests {
         let mut state = AppState::new();
         let sid = Uuid::from_u128(3);
         state.new_tab();
-        state.active_tab_mut().pane = Some(PaneRef::Session(sid));
+        state.active_tab_mut().pane = Some(sid);
 
         assert_eq!(state.close_tab(), Some(sid));
     }
@@ -370,9 +324,9 @@ mod tests {
     fn close_tab_keeps_a_session_another_tab_still_shows() {
         let mut state = AppState::new();
         let sid = Uuid::from_u128(4);
-        state.active_tab_mut().pane = Some(PaneRef::Session(sid));
+        state.active_tab_mut().pane = Some(sid);
         state.new_tab();
-        state.active_tab_mut().pane = Some(PaneRef::Session(sid));
+        state.active_tab_mut().pane = Some(sid);
 
         assert_eq!(state.close_tab(), None);
     }
@@ -380,7 +334,7 @@ mod tests {
     #[test]
     fn close_tab_is_a_no_op_on_the_last_tab() {
         let mut state = AppState::new();
-        state.active_tab_mut().pane = Some(PaneRef::Session(Uuid::from_u128(5)));
+        state.active_tab_mut().pane = Some(Uuid::from_u128(5));
         assert_eq!(state.close_tab(), None);
         assert_eq!(state.tabs.len(), 1);
     }
@@ -393,52 +347,4 @@ mod tests {
         assert!(state.dismiss_overlay());
         assert!(state.overlay().is_none());
     }
-
-    /// Issue #63: `s` over an empty pane turns that pane into a draft —
-    /// focused, Insert mode on, typing starts immediately.
-    #[test]
-    fn open_draft_reuses_the_empty_active_pane() {
-        let mut state = AppState::new();
-        state.open_draft_pane();
-        assert!(matches!(state.active_tab().pane, Some(PaneRef::Draft(_))));
-        assert_eq!(state.focus, Focus::Pane);
-        assert_eq!(state.mode, Mode::Insert);
-        assert_eq!(state.tabs.len(), 1);
-    }
-
-    /// A tab already showing a session gets a fresh tab for the draft; v1
-    /// has no split tree, so a new tab is the "split".
-    #[test]
-    fn open_draft_over_a_session_opens_a_new_tab() {
-        let mut state = AppState::new();
-        state.attach_to_focused(Uuid::from_u128(9));
-        state.open_draft_pane();
-        assert_eq!(state.tabs.len(), 2);
-        assert_eq!(state.active_tab_idx, 1);
-        assert!(matches!(state.active_tab().pane, Some(PaneRef::Draft(_))));
-        // The session tab is untouched.
-        assert_eq!(state.tabs[0].session(), Some(Uuid::from_u128(9)));
-    }
-
-    /// Web parity (#57): submitting fills the pane in place.
-    #[test]
-    fn complete_spawn_replaces_the_draft_with_the_session() {
-        let mut state = AppState::new();
-        state.open_draft_pane();
-        let sid = Uuid::from_u128(21);
-        state.complete_spawn(sid);
-        assert_eq!(state.active_tab().session(), Some(sid));
-        assert_eq!(state.focus, Focus::Pane);
-        assert_eq!(state.mode, Mode::Insert);
-    }
-
-    /// A closed draft tab holds no session, so nothing is released.
-    #[test]
-    fn close_tab_reports_nothing_for_a_draft_pane() {
-        let mut state = AppState::new();
-        state.open_draft_pane();
-        state.new_tab();
-        state.active_tab_idx = 0;
-        assert_eq!(state.close_tab(), None);
-    }
 }

crates/maestro-tui/src/text_input.rs

@@ -14,7 +14,7 @@ use ratatui::style::Style;
 
 use crate::input::InputKey;
 
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone)]
 pub struct TextInput {
     value: String,
     /// Cursor position as a char offset into `value`.

web/package.json

@@ -17,7 +17,6 @@
     "@xterm/xterm": "^5.5.0"
   },
   "devDependencies": {
-    "happy-dom": "^20.11.6",
     "typescript": "^5.6.3",
     "vite": "^5.4.10",
     "vitest": "^2.1.9"

web/pnpm-lock.yaml

@@ -15,18 +15,15 @@ importers:
         specifier: ^5.5.0
         version: 5.5.0
     devDependencies:
-      happy-dom:
-        specifier: ^20.11.6
-        version: 20.11.6
       typescript:
         specifier: ^5.6.3
         version: 5.9.3
       vite:
         specifier: ^5.4.10
-        version: 5.4.21(@types/node@26.2.0)
+        version: 5.4.21
       vitest:
         specifier: ^2.1.9
-        version: 2.1.9(@types/node@26.2.0)(happy-dom@20.11.6)
+        version: 2.1.9
 
 packages:
 
@@ -299,15 +296,6 @@ packages:
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
-  '@types/node@26.2.0':
-    resolution: {integrity: sha512-5IviulTZeRNp2vAJ514cc/HUlY5nZ9fCbq9DMyC52BrhFZACo3nI0R7qBxhQmo/d27NFe96ur/b7Wwxklda+kg==}
-
-  '@types/whatwg-mimetype@3.0.2':
-    resolution: {integrity: sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA==}
-
-  '@types/ws@8.18.1':
-    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
-
   '@vitest/expect@2.1.9':
     resolution: {integrity: sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==}
 
@@ -349,10 +337,6 @@ packages:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
 
-  buffer-image-size@0.6.4:
-    resolution: {integrity: sha512-nEh+kZOPY1w+gcCMobZ6ETUp9WfibndnosbpwB1iJk/8Gt5ZF2bhS6+B6bPYz424KtwsR6Rflc3tCz1/ghX2dQ==}
-    engines: {node: '>=4.0'}
-
   cac@6.7.14:
     resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
     engines: {node: '>=8'}
@@ -378,10 +362,6 @@ packages:
     resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==}
     engines: {node: '>=6'}
 
-  entities@7.0.1:
-    resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
-    engines: {node: '>=0.12'}
-
   es-module-lexer@1.7.0:
     resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
 
@@ -402,10 +382,6 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
-  happy-dom@20.11.6:
-    resolution: {integrity: sha512-Hldbg8AdAa5a5oDcZpjqnGitp7JB0hqWmfv/8qr+kft4vzSD8BHsbdRfzYvL/0QcbKcURC/yyoygbeDQarPvYg==}
-    engines: {node: '>=20.0.0'}
-
   loupe@3.2.1:
     resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==}
 
@@ -475,9 +451,6 @@ packages:
     engines: {node: '>=14.17'}
     hasBin: true
 
-  undici-types@8.3.0:
-    resolution: {integrity: sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==}
-
   vite-node@2.1.9:
     resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
     engines: {node: ^18.0.0 || >=20.0.0}
@@ -539,27 +512,11 @@ packages:
       jsdom:
         optional: true
 
-  whatwg-mimetype@3.0.0:
-    resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==}
-    engines: {node: '>=12'}
-
   why-is-node-running@2.3.0:
     resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
     engines: {node: '>=8'}
     hasBin: true
 
-  ws@8.21.3:
-    resolution: {integrity: sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==}
-    engines: {node: '>=10.0.0'}
-    peerDependencies:
-      bufferutil: ^4.0.1
-      utf-8-validate: '>=5.0.2'
-    peerDependenciesMeta:
-      bufferutil:
-        optional: true
-      utf-8-validate:
-        optional: true
-
 snapshots:
 
   '@esbuild/aix-ppc64@0.21.5':
@@ -710,16 +667,6 @@ snapshots:
 
   '@types/estree@1.0.8': {}
 
-  '@types/node@26.2.0':
-    dependencies:
-      undici-types: 8.3.0
-
-  '@types/whatwg-mimetype@3.0.2': {}
-
-  '@types/ws@8.18.1':
-    dependencies:
-      '@types/node': 26.2.0
-
   '@vitest/expect@2.1.9':
     dependencies:
       '@vitest/spy': 2.1.9
@@ -727,13 +674,13 @@ snapshots:
       chai: 5.3.3
       tinyrainbow: 1.2.0
 
-  '@vitest/mocker@2.1.9(vite@5.4.21(@types/node@26.2.0))':
+  '@vitest/mocker@2.1.9(vite@5.4.21)':
     dependencies:
       '@vitest/spy': 2.1.9
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 5.4.21(@types/node@26.2.0)
+      vite: 5.4.21
 
   '@vitest/pretty-format@2.1.9':
     dependencies:
@@ -768,10 +715,6 @@ snapshots:
 
   assertion-error@2.0.1: {}
 
-  buffer-image-size@0.6.4:
-    dependencies:
-      '@types/node': 26.2.0
-
   cac@6.7.14: {}
 
   chai@5.3.3:
@@ -790,8 +733,6 @@ snapshots:
 
   deep-eql@5.0.2: {}
 
-  entities@7.0.1: {}
-
   es-module-lexer@1.7.0: {}
 
   esbuild@0.21.5:
@@ -829,19 +770,6 @@ snapshots:
   fsevents@2.3.3:
     optional: true
 
-  happy-dom@20.11.6:
-    dependencies:
-      '@types/node': 26.2.0
-      '@types/whatwg-mimetype': 3.0.2
-      '@types/ws': 8.18.1
-      buffer-image-size: 0.6.4
-      entities: 7.0.1
-      whatwg-mimetype: 3.0.0
-      ws: 8.21.3
-    transitivePeerDependencies:
-      - bufferutil
-      - utf-8-validate
-
   loupe@3.2.1: {}
 
   magic-string@0.30.21:
@@ -915,15 +843,13 @@ snapshots:
 
   typescript@5.9.3: {}
 
-  undici-types@8.3.0: {}
-
-  vite-node@2.1.9(@types/node@26.2.0):
+  vite-node@2.1.9:
     dependencies:
       cac: 6.7.14
       debug: 4.4.3
       es-module-lexer: 1.7.0
       pathe: 1.1.2
-      vite: 5.4.21(@types/node@26.2.0)
+      vite: 5.4.21
     transitivePeerDependencies:
       - '@types/node'
       - less
@@ -935,19 +861,18 @@ snapshots:
       - supports-color
       - terser
 
-  vite@5.4.21(@types/node@26.2.0):
+  vite@5.4.21:
     dependencies:
       esbuild: 0.21.5
       postcss: 8.5.15
       rollup: 4.60.4
     optionalDependencies:
-      '@types/node': 26.2.0
       fsevents: 2.3.3
 
-  vitest@2.1.9(@types/node@26.2.0)(happy-dom@20.11.6):
+  vitest@2.1.9:
     dependencies:
       '@vitest/expect': 2.1.9
-      '@vitest/mocker': 2.1.9(vite@5.4.21(@types/node@26.2.0))
+      '@vitest/mocker': 2.1.9(vite@5.4.21)
       '@vitest/pretty-format': 2.1.9
       '@vitest/runner': 2.1.9
       '@vitest/snapshot': 2.1.9
@@ -963,12 +888,9 @@ snapshots:
       tinyexec: 0.3.2
       tinypool: 1.1.1
       tinyrainbow: 1.2.0
-      vite: 5.4.21(@types/node@26.2.0)
-      vite-node: 2.1.9(@types/node@26.2.0)
+      vite: 5.4.21
+      vite-node: 2.1.9
       why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@types/node': 26.2.0
-      happy-dom: 20.11.6
     transitivePeerDependencies:
       - less
       - lightningcss
@@ -980,11 +902,7 @@ snapshots:
       - supports-color
       - terser
 
-  whatwg-mimetype@3.0.0: {}
-
   why-is-node-running@2.3.0:
     dependencies:
       siginfo: 2.0.0
       stackback: 0.0.2
-
-  ws@8.21.3: {}

web/src/dirAutocomplete.test.ts

@@ -1,143 +0,0 @@
-// @vitest-environment happy-dom
-import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("./api.js", () => ({ listDir: vi.fn() }));
-
-import { attachDirAutocomplete, type DirAutocompleteHandle } from "./dirAutocomplete.js";
-import { listDir } from "./api.js";
-
-const listDirMock = vi.mocked(listDir);
-
-let input: HTMLInputElement;
-let nextField: HTMLInputElement;
-let docKeydown: ReturnType<typeof vi.fn>;
-let ac: DirAutocompleteHandle | undefined;
-
-function popup(): HTMLUListElement {
-  return document.querySelector(".dir-ac") as HTMLUListElement;
-}
-
-function items(): HTMLElement[] {
-  return [...popup().querySelectorAll<HTMLElement>(".dir-ac-item")];
-}
-
-async function type(value: string): Promise<void> {
-  input.focus();
-  input.value = value;
-  input.dispatchEvent(new Event("input", { bubbles: true }));
-  await vi.advanceTimersByTimeAsync(100); // past the fetch debounce
-}
-
-/** Dispatch a cancelable, bubbling keydown on the input; report whether the
- * default browser behaviour (focus move, form submit) was suppressed. */
-function press(key: string): { defaultPrevented: boolean } {
-  const evt = new KeyboardEvent("keydown", { key, bubbles: true, cancelable: true });
-  input.dispatchEvent(evt);
-  return { defaultPrevented: evt.defaultPrevented };
-}
-
-beforeEach(() => {
-  vi.useFakeTimers();
-  document.body.replaceChildren();
-  input = document.createElement("input");
-  nextField = document.createElement("input");
-  document.body.append(input, nextField);
-  docKeydown = vi.fn();
-  document.addEventListener("keydown", docKeydown);
-  listDirMock.mockReset().mockResolvedValue({ path: "/tmp", entries: ["proj-a", "proj-b", "other"], truncated: false });
-});
-
-afterEach(() => {
-  ac?.destroy();
-  document.removeEventListener("keydown", docKeydown);
-  vi.useRealTimers();
-});
-
-describe("dirAutocomplete dismissal", () => {
-  it("Escape closes the popup, keeps the typed value and does not propagate", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/pro");
-    expect(popup().hidden).toBe(false);
-
-    const { defaultPrevented } = press("Escape");
-
-    expect(defaultPrevented).toBe(true);
-    expect(popup().hidden).toBe(true);
-    expect(input.value).toBe("/tmp/pro");
-    expect(document.activeElement).toBe(input);
-    expect(docKeydown).not.toHaveBeenCalled(); // a draft pane's Escape handler must not fire
-  });
-
-  it("blur dismisses the popup", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/pro");
-    expect(popup().hidden).toBe(false);
-
-    input.blur();
-    await vi.advanceTimersByTimeAsync(150);
-
-    expect(popup().hidden).toBe(true);
-  });
-
-  it("does not reopen on refocus until the operator types again", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/pro");
-    input.blur();
-    await vi.advanceTimersByTimeAsync(150);
-
-    input.focus();
-    await vi.advanceTimersByTimeAsync(150);
-    expect(popup().hidden).toBe(true);
-
-    await type("/tmp/ot");
-    expect(popup().hidden).toBe(false);
-  });
-});
-
-describe("dirAutocomplete keyboard model", () => {
-  it("Tab commits the highlighted entry and lets focus move to the next field", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/pro"); // highlight defaults to the first match: proj-a
-
-    nextField.focus();
-    const { defaultPrevented } = press("Tab");
-
-    expect(input.value).toBe("/tmp/proj-a/");
-    expect(defaultPrevented).toBe(false); // native tab navigation proceeds
-    expect(document.activeElement).toBe(nextField); // focus was not yanked back
-  });
-
-  it("Tab with nothing highlighted just moves on", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/nope-matches-nothing");
-    expect(popup().hidden).toBe(true);
-
-    const { defaultPrevented } = press("Tab");
-
-    expect(defaultPrevented).toBe(false);
-    expect(input.value).toBe("/tmp/nope-matches-nothing");
-  });
-
-  it("arrows move the highlight and Enter commits it without submitting", async () => {
-    ac = attachDirAutocomplete(input);
-    await type("/tmp/");
-
-    press("ArrowDown");
-    expect(items()[1].classList.contains("is-active")).toBe(true);
-
-    const enter = press("Enter");
-    expect(enter.defaultPrevented).toBe(true); // no form submit
-    expect(input.value).toBe("/tmp/proj-b/");
-  });
-});
-
-describe("dirAutocomplete opening", () => {
-  it("still opens on focus when not previously dismissed", async () => {
-    ac = attachDirAutocomplete(input);
-    input.focus();
-    await vi.advanceTimersByTimeAsync(50);
-
-    expect(popup().hidden).toBe(false);
-    expect(listDirMock).toHaveBeenCalled();
-  });
-});

web/src/dirAutocomplete.ts

@@ -4,19 +4,15 @@
 // per directory, and filters the trailing path segment locally — so typing within a segment is instant and only crossing a `/`
 // hits the network. Keyboard model mirrors `cd dir/sub<tab>`:
 //
-//   Tab    commit the highlighted entry and let focus move on; with nothing
-//          highlighted, plain tab navigation
+//   Tab    complete the longest common prefix; if one match, accept it (and
+//          append `/` so the next level loads); if nothing to extend, cycle.
 //   ↑/↓    move the highlight
 //   Enter  accept the highlighted entry (and suppress form submit)
-//   Esc    close the dropdown, refocus the input, and swallow the key so it
-//          can't also discard a surrounding draft pane
-//
-// Once dismissed (Esc or blur) the popup stays closed until the operator types
-// again — refocusing alone doesn't reopen it.
+//   Esc    close the dropdown
 //
 // Failures (offline daemon, permission denied) degrade to no suggestions.
 
-import { splitPath } from "./paths.js";
+import { longestCommonPrefix, splitPath } from "./paths.js";
 import { listDir } from "./api.js";
 
 export interface DirAutocompleteHandle {
@@ -46,9 +42,6 @@ export function attachDirAutocomplete(input: HTMLInputElement): DirAutocompleteH
   let fetchSeq = 0;
   let debounce: number | undefined;
   let open = false;
-  // Set when the operator dismissed the popup (Esc, blur, outside click); a
-  // refocus must not reopen it — only new typing does.
-  let dismissed = false;
 
 
   function close(): void {
@@ -61,11 +54,6 @@ export function attachDirAutocomplete(input: HTMLInputElement): DirAutocompleteH
     window.removeEventListener("resize", reposition);
   }
 
-  function dismiss(): void {
-    dismissed = true;
-    close();
-  }
-
   function reposition(): void {
     const r = input.getBoundingClientRect();
     dropdown.style.left = `${r.left}px`;
@@ -144,28 +132,21 @@ export function attachDirAutocomplete(input: HTMLInputElement): DirAutocompleteH
   }
 
   // Accept `name` as the next path segment: complete it and append `/` so the
-  // child directory's listing loads on the next interaction (the drill-in
-  // gesture). Unlike `accept`, doesn't steal focus — Tab uses this to commit
-  // and move to the next field in one gesture.
-  function commit(name: string): void {
+  // child directory's listing loads immediately (the drill-in gesture).
+  function accept(name: string): void {
     const { dir } = splitPath(input.value);
     input.value = `${dir}${name}/`;
-    // Notify other listeners (spawnForm marks the field user-edited).
+    input.focus();
+    // Notify other listeners (spawn.ts marks the field user-edited) and load
+    // the child level.
     input.dispatchEvent(new Event("input", { bubbles: true }));
   }
 
-  function accept(name: string): void {
-    commit(name);
-    input.focus();
-  }
-
   function onInput(): void {
-    dismissed = false;
     scheduleRefresh();
   }
 
   function onFocus(): void {
-    if (dismissed) return;
     refresh();
   }
 
@@ -173,17 +154,27 @@ export function attachDirAutocomplete(input: HTMLInputElement): DirAutocompleteH
     if (e.key === "Escape") {
       if (open) {
         e.preventDefault();
-        // Swallow the key: an Escape that bubbles would also discard the
-        // draft pane hosting this form.
-        e.stopPropagation();
-        dismiss();
-        input.focus();
+        close();
       }
       return;
     }
     if (e.key === "Tab") {
-      if (!open || highlight < 0 || highlight >= filtered.length) return; // plain tab navigation
-      commit(filtered[highlight]); // no preventDefault — focus moves to the next field
+      if (!open || filtered.length === 0) return; // let focus move normally
+      e.preventDefault();
+      if (filtered.length === 1) {
+        accept(filtered[0]);
+        return;
+      }
+      const { dir, prefix } = splitPath(input.value);
+      const lcp = longestCommonPrefix(filtered);
+      if (lcp.length > prefix.length) {
+        input.value = `${dir}${lcp}`;
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+      } else {
+        // Nothing to extend — cycle the highlight like a second shell <tab>.
+        highlight = (highlight + 1) % filtered.length;
+        render();
+      }
       return;
     }
     if (!open) return;
@@ -205,7 +196,7 @@ export function attachDirAutocomplete(input: HTMLInputElement): DirAutocompleteH
 
   function onBlur(): void {
     // Delay so a dropdown mousedown can complete first.
-    window.setTimeout(dismiss, 120);
+    window.setTimeout(close, 120);
   }
 
   input.addEventListener("input", onInput);