feat(maestro): GET /api/worktrees and DELETE reclaim endpoints

Closes #77

CLAUDE.md

@@ -62,6 +62,10 @@ nix/                     # Home Manager module (`services.maestro`)
 
 See `docs/INSTALL.md` for end-user install instructions.
 
+`docs/WORKTREES.md` is the contract for session worktrees — placement,
+collisions, what blocks a kill, what `--force` retains, and what reclaim
+touches. Read it before changing anything that creates or removes one.
+
 `nix run .#dev` (or `just dev`) brings up the whole local stack under
 process-compose: a debug daemon on 127.0.0.1:7071, then Vite on :5173 once the
 daemon answers `/api/info`. The SPA proxies `/api/*` back to the daemon, so only

Cargo.lock

@@ -1193,6 +1193,7 @@ dependencies = [
  "maestro-protocol",
  "maestro-testing",
  "ratatui",
+ "reqwest",
  "serde_json",
  "thiserror 1.0.69",
  "tokio",

DESIGN.md

@@ -79,16 +79,15 @@ no bounce. Tokens `--dur-fast`/`--dur`/`--dur-slow`.
   `connecting` state pill pulses.
 - Interaction: row hover/focus, button press (1px), input focus ring, chevron
   rotation, theme-toggle sun/moon swap.
-- Modal: bottom-sheet slide-up on mobile, scale-pop on ≥600px.
 - Every animation has a `prefers-reduced-motion: reduce` path (pulses off,
   transitions near-instant).
 
 ## Layout & structure
 
 Mobile-first, structural responsiveness (not fluid type). Single `≤520px`
-breakpoint stacks the header (full-width search, wrapped actions). `≥600px`
-switches the spawn modal from bottom-sheet to centered dialog. A faint slate grid texture sits on `--bg` as
-terminal atmosphere (very low contrast, not decoration).
+breakpoint stacks the header (full-width search, wrapped actions). A faint
+slate grid texture sits on `--bg` as terminal atmosphere (very low contrast,
+not decoration).
 
 ## Components
 
@@ -101,8 +100,10 @@ Three surfaces, all DOM built in TS, styled by class:
   no-sessions, no-search-match.
 - **Attach** — header (back, `session <id>`, live/closed/error state pill) over
   a framed dark xterm with a green cursor.
-- **Spawn modal** — bottom-sheet/dialog form; mono inputs with green focus
-  ring; grouped worktree fieldset.
+- **Draft pane** — the spawn form mounted inline in an empty split pane,
+  focusable like any session pane; mono inputs with green focus ring; grouped
+  worktree fieldset. Spawn opens one (reusing an empty focused pane, else
+  splitting), and "Spawn similar" seeds one from a session's dir + command.
 
 Interactive elements ship default / hover / focus-visible / active / disabled
 states; the accent green is used only for action, selection, focus, and live
@@ -111,5 +112,5 @@ status — never decoration.
 ## Dev review aids (DEV-only, stripped from production)
 
 `web/src/mock.ts` + query params seed a representative catalog without a running
-daemon: `?mock` (seed sessions), `?mock&spawn` (open the spawn modal),
+daemon: `?mock` (seed sessions), `?mock&spawn` (open a draft pane),
 `?theme=light|dark` (pin a theme). Guarded by `import.meta.env.DEV`.

crates/maestro-cli/src/sessions.rs

@@ -153,6 +153,7 @@ mod tests {
             command: command.into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
+            worktree: None,
             status: SessionStatus::Running,
             created_at: Utc.with_ymd_and_hms(2026, 5, 25, 12, 0, 0).unwrap(),
             foreground: None,

crates/maestro-daemon/src/branches.rs

@@ -0,0 +1,167 @@
+//! `GET /api/branches` — local branches of one repository (#55).
+//!
+//! Spawning into a worktree on an *existing* branch needs to know which
+//! branches the repository has and which are taken: git refuses to check the
+//! same branch out in two worktrees at once. Each [`BranchInfo`] answers for
+//! one local branch — its name, whether it is the main checkout's HEAD, and
+//! which linked worktree (if any) holds it.
+//!
+//! Read-only, like [`crate::gitroot`]: two git probes (`for-each-ref`,
+//! `worktree list --porcelain`) with no write path anywhere. A path outside
+//! any repository yields an empty list rather than an error, matching how
+//! `/api/gitroot` reports "not a repository".
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use axum::extract::{Query, State};
+use axum::response::{IntoResponse, Response};
+use axum::Json;
+use maestro_protocol::BranchInfo;
+use serde::Deserialize;
+
+use crate::local_api::LocalApiState;
+
+/// Query string for `GET /api/branches`. Same `path` convention as
+/// `/api/dirs` and `/api/gitroot`: resolved against the daemon's home dir.
+#[derive(Debug, Deserialize)]
+pub struct BranchesQuery {
+    #[serde(default)]
+    pub path: String,
+}
+
+pub async fn handler(State(s): State<LocalApiState>, Query(q): Query<BranchesQuery>) -> Response {
+    let dir = crate::dirlist::resolve(&s.home_dir, &q.path);
+    Json(list(&dir)).into_response()
+}
+
+/// List the enclosing repository's local branches. Empty when `dir` is not
+/// inside a repository.
+pub fn list(dir: &Path) -> Vec<BranchInfo> {
+    let Some(root) = crate::gitroot::find_root(dir) else {
+        return Vec::new();
+    };
+    let worktrees = worktree_branches(&root);
+    // The first porcelain record is always the main checkout; its branch is
+    // the HEAD answer. Linked worktrees are the occupancy map.
+    let head_branch = worktrees.first().and_then(|(branch, _)| branch.clone());
+    let occupied: HashMap<&str, &Path> = worktrees
+        .iter()
+        .skip(1)
+        .filter_map(|(branch, path)| branch.as_deref().map(|b| (b, path.as_path())))
+        .collect();
+
+    branch_names(&root)
+        .into_iter()
+        .map(|name| BranchInfo {
+            is_head: head_branch.as_deref() == Some(name.as_str()),
+            worktree: occupied.get(name.as_str()).copied().map(Path::to_path_buf),
+            name,
+        })
+        .collect()
+}
+
+fn run_git(root: &Path, args: &[&str]) -> Option<String> {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(root)
+        .args(args)
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    Some(String::from_utf8_lossy(&out.stdout).into_owned())
+}
+
+fn branch_names(root: &Path) -> Vec<String> {
+    run_git(
+        root,
+        &["for-each-ref", "refs/heads", "--format=%(refname:short)"],
+    )
+    .map(|out| {
+        out.lines()
+            .filter(|l| !l.is_empty())
+            .map(str::to_owned)
+            .collect()
+    })
+    .unwrap_or_default()
+}
+
+fn worktree_branches(root: &Path) -> Vec<(Option<String>, PathBuf)> {
+    let out = match run_git(root, &["worktree", "list", "--porcelain"]) {
+        Some(out) => out,
+        None => return Vec::new(),
+    };
+    parse_worktrees(&out)
+}
+
+/// Parse `git worktree list --porcelain` into `(branch, toplevel)` records,
+/// branch-less for detached/bare checkouts. Records are separated by blank
+/// lines; each `worktree` line starts a new one.
+fn parse_worktrees(out: &str) -> Vec<(Option<String>, PathBuf)> {
+    let mut result: Vec<(Option<String>, PathBuf)> = Vec::new();
+    let mut pending: Option<PathBuf> = None;
+    let mut branch: Option<String> = None;
+
+    for line in out.lines() {
+        if let Some(path) = line.strip_prefix("worktree ") {
+            if let Some(prev) = pending.take() {
+                result.push((branch.take(), prev));
+            }
+            pending = Some(PathBuf::from(path));
+        } else if let Some(b) = line.strip_prefix("branch ") {
+            branch = Some(b.trim_start_matches("refs/heads/").to_owned());
+        }
+    }
+    if let Some(path) = pending {
+        result.push((branch.take(), path));
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_main_and_linked_worktrees() {
+        let out = "\
+worktree /repos/maestro
+HEAD 0123abcd
+branch refs/heads/main
+
+worktree /repos/wt-feature
+HEAD 4567abcd
+branch refs/heads/spawn-v2
+
+";
+        assert_eq!(
+            parse_worktrees(out),
+            vec![
+                (Some("main".into()), PathBuf::from("/repos/maestro")),
+                (Some("spawn-v2".into()), PathBuf::from("/repos/wt-feature")),
+            ]
+        );
+    }
+
+    #[test]
+    fn detached_head_yields_no_branch() {
+        let out = "\
+worktree /repos/detached
+HEAD 0123abcd
+detached
+
+";
+        assert_eq!(
+            parse_worktrees(out),
+            vec![(None, PathBuf::from("/repos/detached"))]
+        );
+    }
+
+    #[test]
+    fn empty_output_yields_no_records() {
+        assert!(parse_worktrees("").is_empty());
+    }
+}

crates/maestro-daemon/src/cli.rs

@@ -85,6 +85,9 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
         config.home_dir.clone(),
         config.spawn_presets.clone(),
         projects,
+        std::sync::Arc::new(crate::retained_store::RetainedStore::new(
+            config.retained_worktree_dir(),
+        )),
     ));
 
     let listener = TcpListener::bind(config.bind_addr).await?;

crates/maestro-daemon/src/config.rs

@@ -103,6 +103,11 @@ impl DaemonConfig {
     pub fn spawn_history_path(&self) -> PathBuf {
         self.state_dir.join("spawn-history.jsonl")
     }
+
+    /// Retained-worktree store directory (#78): `<state_dir>/retained-worktrees/`.
+    pub fn retained_worktree_dir(&self) -> PathBuf {
+        self.state_dir.join("retained-worktrees")
+    }
 }
 
 /// Env-var overrides applied by [`load_config`]. Tests pass explicit

crates/maestro-daemon/src/lib.rs

@@ -9,6 +9,7 @@
 
 pub mod activity;
 pub mod attach;
+pub mod branches;
 pub mod cli;
 pub mod config;
 pub mod dirlist;
@@ -18,11 +19,13 @@ pub mod panes;
 pub mod proc;
 pub mod projects;
 pub mod pty;
+pub mod retained_store;
 pub mod session;
 pub mod sidecar;
 pub mod spawn_history;
 pub mod tmux;
 pub mod worktree;
+pub mod worktree_probe;
 
 pub use config::{default_config_path, default_state_dir, load_config, DaemonConfig, EnvOverrides};
 pub use session::{SessionError, SessionManager};

crates/maestro-daemon/src/local_api.rs

@@ -38,6 +38,9 @@ pub struct LocalApiState {
     pub presets: Arc<Vec<SpawnPreset>>,
     /// Project discovery (#54) backing `GET /api/projects`.
     pub projects: Arc<crate::projects::ProjectScanner>,
+    /// Retained worktrees (#78) backing `GET /api/worktrees` and their
+    /// reclaim endpoint (#80).
+    pub retained: Arc<crate::retained_store::RetainedStore>,
 }
 
 pub fn router(state: LocalApiState) -> Router {
@@ -48,7 +51,10 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::RECENT_DIRS, get(recent_dirs))
         .route(routes::PROJECTS, get(projects))
         .route(routes::GITROOT, get(git_root))
+        .route(routes::BRANCHES, get(crate::branches::handler))
         .route(routes::NAMES, get(names))
+        .route(routes::WORKTREES, get(list_worktrees))
+        .route(routes::patterns::WORKTREE, delete(reclaim_worktree))
         .route(routes::INFO, get(daemon_info))
         .route(routes::EVENTS, any(events_ws))
         .route(routes::patterns::ATTACH, any(attach_ws))
@@ -181,6 +187,114 @@ async fn kill_session(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> R
     }
 }
 
+/// `GET /api/worktrees` (#80): every retained worktree, with the in-the-way
+/// breakdown recomputed at read time — never stored, so a tree whose work has
+/// since been committed or pushed says so. Entries whose directory somebody
+/// removed by hand are pruned on the way through.
+async fn list_worktrees(State(s): State<LocalApiState>) -> Response {
+    let retained = s.retained.clone();
+    let listed = tokio::task::spawn_blocking(move || {
+        retained.prune_missing()?;
+        retained
+            .load_all()?
+            .iter()
+            .map(|entry| {
+                // A tree git cannot read (permissions, corrupt checkout)
+                // still gets listed; it just reports nothing in the way.
+                let in_the_way =
+                    crate::worktree_probe::in_the_way(&entry.path, &entry.base_repo, &entry.branch)
+                        .unwrap_or_default();
+                Ok(maestro_protocol::RetainedWorktree {
+                    id: entry.id,
+                    path: entry.path.clone(),
+                    base_repo: entry.base_repo.clone(),
+                    branch: entry.branch.clone(),
+                    reason: entry.reason,
+                    retained_at: entry.retained_at,
+                    in_the_way,
+                })
+            })
+            .collect::<Result<Vec<_>, crate::retained_store::RetainedStoreError>>()
+    })
+    .await;
+    match listed {
+        Ok(Ok(worktrees)) => Json(worktrees).into_response(),
+        Ok(Err(e)) => error_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "store_failed",
+            &e.to_string(),
+        ),
+        Err(e) => error_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "join_failed",
+            &e.to_string(),
+        ),
+    }
+}
+
+/// `DELETE /api/worktrees/:id` (#80): reclaim one retained worktree. Removes
+/// the directory and drops the store entry, without consulting the guard —
+/// reclaim is the deliberate destructive act, chosen while looking at what is
+/// in the way. The branch itself is never deleted; commits on it survive.
+async fn reclaim_worktree(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
+    let found = {
+        let retained = s.retained.clone();
+        tokio::task::spawn_blocking(move || -> Result<
+            Option<crate::retained_store::RetainedWorktreeRecord>,
+            crate::retained_store::RetainedStoreError,
+        > {
+            Ok(retained.load_all()?.into_iter().find(|e| e.id == id))
+        })
+        .await
+    };
+    let entry = match found {
+        Ok(Ok(Some(entry))) => entry,
+        Ok(Ok(None)) => {
+            return error_response(
+                StatusCode::NOT_FOUND,
+                "not_found",
+                "no such retained worktree",
+            )
+        }
+        Ok(Err(e)) => {
+            return error_response(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "store_failed",
+                &e.to_string(),
+            )
+        }
+        Err(e) => {
+            return error_response(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "join_failed",
+                &e.to_string(),
+            )
+        }
+    };
+
+    let outcome = {
+        let retained = s.retained.clone();
+        tokio::task::spawn_blocking(move || -> Result<(), String> {
+            crate::worktree_probe::reclaim(&entry.base_repo, &entry.path)
+                .map_err(|e| e.to_string())?;
+            retained.remove(id).map_err(|e| e.to_string())?;
+            Ok(())
+        })
+        .await
+    };
+    match outcome {
+        Ok(Ok(())) => StatusCode::NO_CONTENT.into_response(),
+        // The directory could not be removed: leave the entry so the
+        // operator still sees the tree and can retry.
+        Ok(Err(e)) => error_response(StatusCode::BAD_GATEWAY, "reclaim_failed", &e.to_string()),
+        Err(e) => error_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "join_failed",
+            &e.to_string(),
+        ),
+    }
+}
+
 fn error_response(status: StatusCode, code: &str, message: &str) -> Response {
     (status, Json(ApiError::new(code, message))).into_response()
 }
@@ -196,6 +310,7 @@ pub fn state_for(
     home_dir: impl Into<String>,
     presets: Vec<SpawnPreset>,
     projects: Arc<crate::projects::ProjectScanner>,
+    retained: Arc<crate::retained_store::RetainedStore>,
 ) -> LocalApiState {
     LocalApiState {
         manager,
@@ -203,6 +318,7 @@ pub fn state_for(
         home_dir: Arc::new(home_dir.into()),
         presets: Arc::new(presets),
         projects,
+        retained,
     }
 }
 

crates/maestro-daemon/src/projects.rs

@@ -29,9 +29,14 @@ 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);
+/// triggers a rescan.
+///
+/// A scan walks the roots and runs one `git worktree list` per hit, holding
+/// the scanner lock throughout, and clients re-request whenever a draft pane
+/// re-mounts — which `multiview.render()` does on unrelated events. Keep this
+/// comfortably longer than [`REFRESH_INTERVAL`] so the background timer is
+/// what refreshes, and a request only rescans when that timer has failed to.
+pub const CACHE_TTL: Duration = Duration::from_secs(180);
 /// 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);
@@ -154,9 +159,15 @@ fn list_worktrees(repo: &Path) -> Option<Vec<PathBuf>> {
     (!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.
+/// Mtime of the checkout's reflog, falling back to `HEAD` itself.
+///
+/// `HEAD` is only rewritten on checkout — committing updates
+/// `refs/heads/<branch>` and appends to `logs/HEAD`, leaving `HEAD` alone. A
+/// repo worked on daily from one long-lived branch would otherwise report its
+/// last *branch switch* as its activity and get dimmed as stale (#54 review).
+///
+/// For a linked worktree `.git` is a file holding a `gitdir:` pointer;
+/// resolve it so worktrees report their own reflog rather than nothing.
 fn head_mtime(repo: &Path) -> Option<DateTime<Utc>> {
     let dot_git = repo.join(".git");
     let head = if dot_git.is_dir() {
@@ -173,6 +184,9 @@ fn head_mtime(repo: &Path) -> Option<DateTime<Utc>> {
         };
         p.join("HEAD")
     };
+    // Prefer the reflog next to whichever HEAD we resolved.
+    let reflog = head.with_file_name("logs").join("HEAD");
+    let head = if reflog.exists() { reflog } else { head };
     let mtime = std::fs::metadata(head).ok()?.modified().ok()?;
     Some(DateTime::<Utc>::from(mtime))
 }
@@ -248,10 +262,16 @@ impl ProjectScanner {
 
     /// Cached snapshot, rescanning (off-thread) when the TTL has lapsed.
     pub async fn repos(&self) -> std::sync::Arc<Vec<DiscoveredRepo>> {
+        self.repos_inner(false).await
+    }
+
+    async fn repos_inner(&self, force: bool) -> std::sync::Arc<Vec<DiscoveredRepo>> {
         let mut cache = self.cache.lock().await;
-        if let Some((at, repos)) = cache.as_ref() {
-            if at.elapsed() < self.ttl {
-                return repos.clone();
+        if !force {
+            if let Some((at, repos)) = cache.as_ref() {
+                if at.elapsed() < self.ttl {
+                    return repos.clone();
+                }
             }
         }
         let roots = self.roots.clone();
@@ -267,9 +287,11 @@ impl ProjectScanner {
         repos
     }
 
-    /// Rescan now, ignoring the TTL. Called by the background timer.
+    /// Rescan now, ignoring the TTL. Called by the background timer — going
+    /// through `repos()` would hit the cache and make most ticks no-ops,
+    /// leaving requests to pay for the rescan instead (#54 review).
     async fn refresh(&self) {
-        self.repos().await;
+        self.repos_inner(true).await;
     }
 
     /// Spawn the slow background refresh task. Drop the returned handle to

crates/maestro-daemon/src/retained_store.rs

@@ -0,0 +1,310 @@
+//! Store of retained worktrees (#78): worktrees the daemon created whose
+//! session is gone.
+//!
+//! One JSON file per entry under `<state_dir>/retained-worktrees/`, written
+//! the way `sidecar.rs` writes session records — atomic tmp+rename replace,
+//! missing or malformed files tolerated on read. The store survives a daemon
+//! restart; it is the recovery path for everything else in the worktree
+//! lifecycle.
+//!
+//! It is not an ownership record: it must never be consulted to decide whether
+//! a path may be adopted. Its only job is to remember what the daemon is
+//! holding so it can be listed and reclaimed.
+
+use std::path::{Path, PathBuf};
+
+use chrono::{DateTime, Utc};
+/// Why a worktree outlived its session — [`maestro_protocol::RetainedReason`],
+/// so the store and the wire payload cannot drift apart.
+pub use maestro_protocol::RetainedReason;
+use uuid::Uuid;
+
+#[derive(Debug, thiserror::Error)]
+pub enum RetainedStoreError {
+    #[error("io: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("json: {0}")]
+    Json(#[from] serde_json::Error),
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct RetainedWorktreeRecord {
+    pub id: Uuid,
+    pub path: PathBuf,
+    pub base_repo: PathBuf,
+    pub branch: String,
+    pub reason: RetainedReason,
+    pub retained_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct RetainedStore {
+    dir: PathBuf,
+}
+
+impl RetainedStore {
+    pub fn new(dir: impl Into<PathBuf>) -> Self {
+        Self { dir: dir.into() }
+    }
+
+    pub fn dir(&self) -> &Path {
+        &self.dir
+    }
+
+    fn path_for(&self, id: Uuid) -> PathBuf {
+        self.dir.join(format!("{id}.json"))
+    }
+
+    /// Record a retained worktree and return the entry that was written.
+    pub fn retain(
+        &self,
+        path: &Path,
+        base_repo: &Path,
+        branch: &str,
+        reason: RetainedReason,
+    ) -> Result<RetainedWorktreeRecord, RetainedStoreError> {
+        let entry = RetainedWorktreeRecord {
+            id: Uuid::new_v4(),
+            path: path.to_path_buf(),
+            base_repo: base_repo.to_path_buf(),
+            branch: branch.to_string(),
+            reason,
+            retained_at: Utc::now(),
+        };
+        self.overwrite(&entry)?;
+        Ok(entry)
+    }
+
+    /// Atomically write `entry`. Creates the directory if it does not exist.
+    pub fn overwrite(&self, entry: &RetainedWorktreeRecord) -> Result<(), RetainedStoreError> {
+        std::fs::create_dir_all(&self.dir)?;
+        let final_path = self.path_for(entry.id);
+        let tmp = self.dir.join(format!("{}.json.tmp", entry.id));
+        let json = serde_json::to_vec_pretty(entry)?;
+        std::fs::write(&tmp, json)?;
+        std::fs::rename(&tmp, &final_path)?;
+        Ok(())
+    }
+
+    /// Drop one entry. No-op when the id is unknown — reclaiming an entry the
+    /// store already lost (e.g. pruned) must not fail.
+    pub fn remove(&self, id: Uuid) -> Result<(), RetainedStoreError> {
+        match std::fs::remove_file(self.path_for(id)) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    /// Read every entry. Files that are missing or malformed are skipped
+    /// silently: a corrupt record must not hide the others, and an empty or
+    /// absent directory simply means nothing is retained.
+    pub fn load_all(&self) -> Result<Vec<RetainedWorktreeRecord>, RetainedStoreError> {
+        let mut out = Vec::new();
+        let entries = match std::fs::read_dir(&self.dir) {
+            Ok(e) => e,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(out),
+            Err(e) => return Err(e.into()),
+        };
+        for entry in entries {
+            let entry = entry?;
+            let path = entry.path();
+            if path.extension().and_then(|s| s.to_str()) != Some("json") {
+                continue;
+            }
+            let Ok(bytes) = std::fs::read(&path) else {
+                continue;
+            };
+            if let Ok(worktree) = serde_json::from_slice::<RetainedWorktreeRecord>(&bytes) {
+                out.push(worktree);
+            }
+        }
+        out.sort_by_key(|w| w.retained_at);
+        Ok(out)
+    }
+
+    /// Drop entries whose worktree directory no longer exists — somebody
+    /// removed it by hand. Returns the ids that were pruned.
+    pub fn prune_missing(&self) -> Result<Vec<Uuid>, RetainedStoreError> {
+        let mut pruned = Vec::new();
+        for entry in self.load_all()? {
+            if !entry.path.exists() {
+                self.remove(entry.id)?;
+                pruned.push(entry.id);
+            }
+        }
+        Ok(pruned)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Duration;
+    use std::path::PathBuf;
+
+    fn tmp_dir() -> tempfile::TempDir {
+        tempfile::tempdir().expect("tempdir")
+    }
+
+    fn sample_path(root: &std::path::Path, name: &str) -> PathBuf {
+        let p = root.join(name);
+        std::fs::create_dir_all(&p).expect("mkdir");
+        p
+    }
+
+    #[test]
+    fn retain_then_load_round_trips_every_field() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let wt = sample_path(dir.path(), "wt");
+        let repo = sample_path(dir.path(), "repo");
+
+        let entry = store
+            .retain(&wt, &repo, "feature/login", RetainedReason::ForceKilled)
+            .expect("retain");
+
+        let all = store.load_all().expect("load_all");
+        assert_eq!(all, vec![entry.clone()]);
+        assert_eq!(entry.path, wt);
+        assert_eq!(entry.base_repo, repo);
+        assert_eq!(entry.branch, "feature/login");
+        assert_eq!(entry.reason, RetainedReason::ForceKilled);
+        let age = Utc::now() - entry.retained_at;
+        assert!(age >= Duration::zero() && age < Duration::minutes(1));
+    }
+
+    #[test]
+    fn reason_serializes_kebab_case() {
+        let json =
+            serde_json::to_string(&RetainedReason::ExitedWithUnsavedWork).expect("serialize");
+        assert_eq!(json, r#""exited-with-unsaved-work""#);
+    }
+
+    #[test]
+    fn entries_survive_a_restart() {
+        let dir = tmp_dir();
+        let wt = sample_path(dir.path(), "wt");
+
+        let first = RetainedStore::new(dir.path());
+        let entry = first
+            .retain(&wt, dir.path(), "main", RetainedReason::ForceKilled)
+            .expect("retain");
+
+        // A fresh store over the same state_dir — what a daemon restart sees.
+        let second = RetainedStore::new(dir.path());
+        assert_eq!(second.load_all().expect("load_all"), vec![entry]);
+    }
+
+    #[test]
+    fn missing_store_reads_as_empty() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path().join("does-not-exist"));
+        assert_eq!(store.load_all().expect("load_all"), Vec::new());
+    }
+
+    #[test]
+    fn malformed_entries_are_skipped_silently() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let wt = sample_path(dir.path(), "wt");
+        store
+            .retain(&wt, dir.path(), "kept", RetainedReason::ForceKilled)
+            .expect("retain");
+        std::fs::write(dir.path().join("not-a-uuid.json"), b"{oops").expect("write junk");
+
+        let all = store.load_all().expect("load_all");
+        assert_eq!(all.len(), 1);
+        assert_eq!(all[0].branch, "kept");
+    }
+
+    #[test]
+    fn ids_are_unique() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let a = store
+            .retain(dir.path(), dir.path(), "a", RetainedReason::ForceKilled)
+            .expect("retain");
+        let b = store
+            .retain(dir.path(), dir.path(), "b", RetainedReason::ForceKilled)
+            .expect("retain");
+        assert_ne!(a.id, b.id);
+    }
+
+    #[test]
+    fn remove_drops_the_entry() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let wt = sample_path(dir.path(), "wt");
+        let entry = store
+            .retain(&wt, dir.path(), "main", RetainedReason::ForceKilled)
+            .expect("retain");
+
+        store.remove(entry.id).expect("remove");
+        assert_eq!(store.load_all().expect("load_all"), Vec::new());
+
+        // Removing an unknown id is a no-op, not an error.
+        store.remove(entry.id).expect("remove again");
+    }
+
+    #[test]
+    fn load_all_is_sorted_by_time() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let mut first = store
+            .retain(dir.path(), dir.path(), "first", RetainedReason::ForceKilled)
+            .expect("retain");
+        first.retained_at -= Duration::hours(1);
+        store.overwrite(&first).expect("rewrite");
+
+        let second = store
+            .retain(
+                dir.path(),
+                dir.path(),
+                "second",
+                RetainedReason::ForceKilled,
+            )
+            .expect("retain");
+
+        let branches: Vec<_> = store
+            .load_all()
+            .expect("load_all")
+            .into_iter()
+            .map(|e| e.branch)
+            .collect();
+        assert_eq!(branches, vec!["first", "second"]);
+        let _ = second;
+    }
+
+    #[test]
+    fn prune_missing_drops_gone_directories_only() {
+        let dir = tmp_dir();
+        let store = RetainedStore::new(dir.path());
+        let alive = sample_path(dir.path(), "alive");
+        let gone = sample_path(dir.path(), "gone");
+        let keep = store
+            .retain(&alive, dir.path(), "keep", RetainedReason::ForceKilled)
+            .expect("retain");
+        let drop = store
+            .retain(
+                &gone,
+                dir.path(),
+                "drop",
+                RetainedReason::ExitedWithUnsavedWork,
+            )
+            .expect("retain");
+        std::fs::remove_dir_all(&gone).expect("rm");
+
+        let pruned = store.prune_missing().expect("prune_missing");
+        assert_eq!(pruned, vec![drop.id]);
+
+        let branches: Vec<_> = store
+            .load_all()
+            .expect("load_all")
+            .into_iter()
+            .map(|e| e.branch)
+            .collect();
+        assert_eq!(branches, vec!["keep"]);
+        let _ = keep;
+    }
+}

crates/maestro-daemon/src/session.rs

@@ -226,6 +226,9 @@ impl SessionManager {
                 let WorktreeSpec {
                     base_repo, branch, ..
                 } = spec;
+                // A path collision is sidestepped inside `run_add` (#77), and
+                // a branch already checked out elsewhere is git's refusal,
+                // not ours.
                 let path = if spec.create_branch {
                     self.inner.worktree_mgr.add_new(base_repo, branch)
                 } else {
@@ -290,6 +293,12 @@ impl SessionManager {
             command: req.command,
             env: req.env,
             metadata: req.metadata,
+            worktree: worktree_path.as_ref().zip(worktree_base_repo.as_ref()).map(
+                |(path, base_repo)| maestro_protocol::SessionWorktree {
+                    path: path.clone(),
+                    base_repo: base_repo.clone(),
+                },
+            ),
             status: SessionStatus::Running,
             created_at: Utc::now(),
             // A freshly-spawned session is producing its initial output; the
@@ -430,6 +439,7 @@ impl SessionManager {
                     command: String::new(),
                     env: Default::default(),
                     metadata: Default::default(),
+                    worktree: None,
                     status: SessionStatus::Running,
                     created_at: Utc::now(),
                     // Activity is unknown on adoption; the watcher fills it in.
@@ -457,8 +467,11 @@ impl SessionManager {
                 SessionRecord {
                     session: session.clone(),
                     fifo_path,
-                    worktree_path: None,
-                    worktree_base_repo: None,
+                    // Restored from the sidecar: without it the recovered
+                    // session cleans up nothing on kill, and the leftover
+                    // directory blocks that branch forever (#54 review).
+                    worktree_path: session.worktree.as_ref().map(|w| w.path.clone()),
+                    worktree_base_repo: session.worktree.as_ref().map(|w| w.base_repo.clone()),
                     bridge,
                 },
             );

crates/maestro-daemon/src/worktree.rs

@@ -10,10 +10,6 @@ pub enum WorktreeError {
     Spawn(#[from] std::io::Error),
     #[error("git exited with code {code}: {stderr}")]
     NonZero { code: i32, stderr: String },
-    /// A worktree already occupies the target path. The caller decides what
-    /// to do; the daemon never relocates to a different directory (#56).
-    #[error("worktree path already exists: {}", .path.display())]
-    PathExists { path: PathBuf },
     /// The worktree holds unsaved work; removal was refused (#56).
     #[error("left {} on disk: {}", .path.display(), .reason)]
     Guarded { path: PathBuf, reason: String },
@@ -39,17 +35,48 @@ impl WorktreeManager {
     }
 
     /// Where a worktree for `branch` will be created: the override root, or
-    /// `<base_repo>/worktrees/<sanitized branch>` by default. The path is
-    /// predictable (no UUID suffix), so an existing directory at the target
-    /// is an error rather than a silently different location.
+    /// `<main checkout>/worktrees/<sanitized branch>` by default. If the path
+    /// is occupied, [`Self::add_new`] / [`Self::add_existing`] sidestep to
+    /// `<path>-2`, `<path>-3`, ... instead.
+    ///
+    /// `base_repo` is whatever the client picked, which the project list makes
+    /// easy to point at a *linked worktree* — placing the new tree inside it
+    /// would nest one worktree in another, and git hides a registered
+    /// worktree's contents from the outer `git status`, so the outer tree
+    /// would later look clean and its removal would delete the inner one's
+    /// uncommitted work (#54 review). Always place against the main checkout.
+    ///
+    /// The override root gets the repo's basename too: without it two repos
+    /// spawning the same branch name target one directory.
     fn target_path(&self, base_repo: &Path, branch: &str) -> PathBuf {
-        let slug = sanitize_branch_for_path(branch);
+        // An unusable branch name falls back to a digest rather than escaping
+        // the root; `run_add` surfaces git's own error for it anyway.
+        let slug = branch_relpath(branch).unwrap_or_else(|| PathBuf::from(short_hash(branch)));
+        let main = main_checkout(base_repo);
         match &self.root_override {
-            Some(root) => root.join(slug),
-            None => base_repo.join("worktrees").join(slug),
+            Some(root) => {
+                // Basename alone collides for two checkouts of the same name
+                // (`~/a/maestro` and `~/b/maestro`), so disambiguate with a
+                // digest of the full path (#54 review).
+                let base = main
+                    .file_name()
+                    .map(|n| n.to_string_lossy().into_owned())
+                    .unwrap_or_else(|| "repo".into());
+                let repo = format!("{base}-{}", short_hash(&main.to_string_lossy()));
+                root.join(repo).join(slug)
+            }
+            None => main.join("worktrees").join(slug),
         }
     }
 
+    /// [`Self::target_path`] with `-n` appended to the final component, the
+    /// collision suffix (#77).
+    fn target_path_suffixed(&self, base_repo: &Path, branch: &str, n: u32) -> PathBuf {
+        let mut name = self.target_path(base_repo, branch).into_os_string();
+        name.push(format!("-{n}"));
+        PathBuf::from(name)
+    }
+
     /// `git -C <base_repo> worktree add -b <branch> <path>` — creates the
     /// branch. Returns the path of the new worktree on success.
     pub fn add_new(&self, base_repo: &Path, branch: &str) -> Result<PathBuf, WorktreeError> {
@@ -68,12 +95,18 @@ impl WorktreeManager {
         branch: &str,
         create_branch: bool,
     ) -> Result<PathBuf, WorktreeError> {
-        let path = self.target_path(base_repo, branch);
-        // Clear registrations whose directory is gone before testing the
-        // path, so a previously-leaked entry doesn't block this branch.
+        // Clear registrations whose directory is gone first, so a
+        // previously-leaked entry doesn't push this branch to a suffix.
         prune(base_repo)?;
-        if path.symlink_metadata().is_ok() {
-            return Err(WorktreeError::PathExists { path });
+        // Anything occupying the target — a tree we left behind, one the
+        // operator made, an unrelated directory — is sidestepped with a
+        // numeric suffix on the directory; the branch stays whatever was
+        // requested (#77). The daemon never adopts what it finds.
+        let mut path = self.target_path(base_repo, branch);
+        let mut n = 1;
+        while path.symlink_metadata().is_ok() {
+            n += 1;
+            path = self.target_path_suffixed(base_repo, branch, n);
         }
         // The parent (`<repo>/worktrees` or the override root) may not exist
         // yet; the target itself must not.
@@ -108,6 +141,12 @@ impl WorktreeManager {
         if !path.exists() {
             return prune(base_repo);
         }
+        if let Some(inner) = nested_worktree(path) {
+            return Err(WorktreeError::Guarded {
+                path: path.to_path_buf(),
+                reason: format!("holds a nested worktree at {}", inner.display()),
+            });
+        }
         if let Some(reason) = unsafe_to_remove(path)? {
             return Err(WorktreeError::Guarded {
                 path: path.to_path_buf(),
@@ -124,19 +163,92 @@ impl WorktreeManager {
     }
 }
 
-fn sanitize_branch_for_path(branch: &str) -> String {
-    let mut out = String::with_capacity(branch.len());
-    for c in branch.chars() {
-        if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
-            out.push(c);
-        } else if c == '/' || c == '.' {
-            out.push('-');
-        }
+/// The repository's main checkout. `--git-common-dir` points at the shared
+/// `.git` for every linked worktree, so its parent is the main tree. Falls
+/// back to the input when git can't answer.
+fn main_checkout(path: &Path) -> PathBuf {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(path)
+        .args(["rev-parse", "--path-format=absolute", "--git-common-dir"])
+        .output();
+    let Ok(out) = out else {
+        return path.to_path_buf();
+    };
+    if !out.status.success() {
+        return path.to_path_buf();
     }
-    if out.is_empty() {
-        out.push_str("wt");
+    let common = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim().to_string());
+    common
+        .parent()
+        .map(Path::to_path_buf)
+        .unwrap_or_else(|| path.to_path_buf())
+}
+
+/// `Some(inner)` when a registered worktree lives under `path`. Git omits
+/// those directories from `git status`, so the dirty-work guard cannot see
+/// them and removal would delete them (#54 review).
+fn nested_worktree(path: &Path) -> Option<PathBuf> {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(path)
+        .args(["worktree", "list", "--porcelain"])
+        .output()
+        .ok()?;
+    // `worktree list` prints fully-resolved paths while ours comes from
+    // `--git-common-dir` and may still hold symlinks. Comparing the two forms
+    // directly makes the guard silently pass on any symlinked repo path — and
+    // this guard is what stands between a kill and deleting an inner
+    // worktree's uncommitted work (#54 review).
+    let needle = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+    let text = String::from_utf8_lossy(&out.stdout);
+    text.lines()
+        .filter_map(|l| l.strip_prefix("worktree "))
+        .map(PathBuf::from)
+        .find(|p| {
+            let real = p.canonicalize().unwrap_or_else(|_| p.clone());
+            real != needle && real.starts_with(&needle)
+        })
+}
+
+/// Short digest used to disambiguate override roots.
+///
+/// Hand-rolled FNV-1a rather than `DefaultHasher`: this value becomes a
+/// directory name, and `DefaultHasher`'s algorithm is explicitly not
+/// guaranteed stable across Rust releases — a toolchain bump would remap every
+/// repo to a new directory and orphan the worktrees under the old one
+/// (#67 review).
+fn short_hash(s: &str) -> String {
+    let mut h: u32 = 0x811c_9dc5;
+    for b in s.as_bytes() {
+        h ^= u32::from(*b);
+        h = h.wrapping_mul(0x0100_0193);
     }
-    out
+    format!("{h:08x}")
+}
+
+/// The relative directory a branch's worktree lives in.
+///
+/// A git branch name is already a valid relative path — git stores it as
+/// `.git/refs/heads/feat/example` — so it is used verbatim and `feat/example`
+/// nests under `worktrees/feat/`. That keeps the path readable *and* keeps the
+/// mapping injective: flattening `/` and `.` to `-` made `feat/x`, `feat.x`
+/// and `feat-x` share one directory (#54 review).
+///
+/// Git already forbids holding both `feat` and `feat/x`, so the directory
+/// collision that nesting could cause cannot arise from valid refs. Only
+/// traversal and absolute components are rejected.
+fn branch_relpath(branch: &str) -> Option<PathBuf> {
+    use std::path::Component;
+    let candidate = Path::new(branch);
+    if branch.is_empty()
+        || !candidate
+            .components()
+            .all(|c| matches!(c, Component::Normal(_)))
+    {
+        return None;
+    }
+    Some(candidate.to_path_buf())
 }
 
 /// `Some(reason)` when deleting `path` would destroy work.

crates/maestro-daemon/src/worktree_probe.rs

@@ -0,0 +1,316 @@
+//! Read-side git probes for retained worktrees (#80): what is currently in
+//! the way, and guard-free reclaim.
+//!
+//! The kill-refusal breakdown lives in `worktree.rs`, which this module must
+//! not touch (#77 owns it) and must not consult for reclaim — reclaim is the
+//! deliberate destructive act and never asks the guard. Issue #79 will factor
+//! the shared git plumbing out of `worktree.rs`; until then these probes are
+//! duplicated here on purpose.
+
+use std::path::Path;
+
+use maestro_protocol::InTheWay;
+
+#[derive(Debug, thiserror::Error)]
+pub enum ProbeError {
+    #[error("failed to spawn git: {0}")]
+    Spawn(#[from] std::io::Error),
+    #[error("git exited with code {code}: {stderr}")]
+    NonZero { code: i32, stderr: String },
+}
+
+/// What a kill refusal would report about the worktree at `path`, right now.
+///
+/// Ignored files never count (`--ignored=no`) — every Rust worktree has a
+/// `target/`, and counting those would put every tree permanently in the way.
+/// A directory that no longer exists reports nothing in the way: there is
+/// nothing left to lose, and the store's own pruning drops the entry.
+pub fn in_the_way(path: &Path, base_repo: &Path, branch: &str) -> Result<InTheWay, ProbeError> {
+    let mut breakdown = InTheWay::default();
+    if !path.exists() {
+        return Ok(breakdown);
+    }
+    let status = run_git(
+        path,
+        [
+            "status",
+            "--porcelain",
+            "--ignored=no",
+            "--untracked-files=normal",
+        ],
+    )?;
+    for line in String::from_utf8_lossy(&status.stdout).lines() {
+        if line.starts_with("??") {
+            breakdown.untracked_files += 1;
+        } else if !line.is_empty() {
+            breakdown.uncommitted_files += 1;
+        }
+    }
+    // Commits reachable from the branch but from no remote-tracking ref. A
+    // branch pushed anywhere counts as pushed; there is no "which remote"
+    // question to get wrong.
+    let unpushed = run_git(
+        base_repo,
+        [
+            "rev-list",
+            "--count",
+            &format!("refs/heads/{branch}"),
+            "--not",
+            "--glob=refs/remotes",
+        ],
+    )?;
+    breakdown.unpushed_commits = String::from_utf8_lossy(&unpushed.stdout)
+        .trim()
+        .parse()
+        .unwrap_or(0);
+    Ok(breakdown)
+}
+
+/// Remove a retained worktree's directory without consulting any guard, per
+/// the reclaim contract: the operator chose this while looking at what was in
+/// the way. `git worktree remove` keeps `refs/heads/<branch>`, so commits on
+/// the branch survive even when they were never pushed.
+///
+/// A directory that is already gone only leaves a stale registration behind;
+/// `worktree prune` clears it so the branch can be spawned again.
+pub fn reclaim(base_repo: &Path, path: &Path) -> Result<(), ProbeError> {
+    if !path.exists() {
+        return run_git(base_repo, ["worktree", "prune"]).map(|_| ());
+    }
+    run_git(
+        base_repo,
+        [
+            "worktree",
+            "remove",
+            "--force",
+            path.to_str().expect("worktree path is valid utf-8"),
+        ],
+    )
+    .map(|_| ())
+}
+
+fn run_git<I, S>(dir: &Path, args: I) -> Result<std::process::Output, ProbeError>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<std::ffi::OsStr>,
+{
+    let mut cmd = std::process::Command::new("git");
+    cmd.arg("-C").arg(dir).args(args);
+    let out = cmd.output()?;
+    if !out.status.success() {
+        return Err(ProbeError::NonZero {
+            code: out.status.code().unwrap_or(-1),
+            stderr: String::from_utf8_lossy(&out.stderr).into_owned(),
+        });
+    }
+    Ok(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+    use std::process::Command;
+
+    struct Repo {
+        root: tempfile::TempDir,
+        repo: PathBuf,
+    }
+
+    fn git(dir: &Path, args: &[&str]) {
+        let out = Command::new("git")
+            .arg("-C")
+            .arg(dir)
+            .args(args)
+            .output()
+            .expect("git spawn");
+        assert!(
+            out.status.success(),
+            "git {args:?} failed: {}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+
+    /// A repo with a remote, one commit on `main`, and a linked worktree for
+    /// branch `feature` at `<repo>/worktrees/feature`.
+    fn repo_with_worktree() -> Repo {
+        let root = tempfile::tempdir().expect("tempdir");
+        let repo = root.path().join("repo");
+        let remote = root.path().join("remote.git");
+        std::fs::create_dir_all(&repo).unwrap();
+        std::fs::create_dir_all(&remote).unwrap();
+        git(&repo, &["init", "-q", "-b", "main"]);
+        git(&repo, &["config", "user.email", "t@t"]);
+        git(&repo, &["config", "user.name", "T"]);
+        std::fs::write(repo.join("README"), b"hello\n").unwrap();
+        git(&repo, &["add", "."]);
+        git(&repo, &["commit", "-q", "-m", "init"]);
+        git(&remote, &["init", "-q", "--bare"]);
+        git(&repo, &["remote", "add", "origin", &path_str(&remote)]);
+        git(&repo, &["push", "-q", "-u", "origin", "main"]);
+        git(
+            &repo,
+            &[
+                "worktree",
+                "add",
+                "-q",
+                "-b",
+                "feature",
+                "worktrees/feature",
+            ],
+        );
+        Repo { root, repo }
+    }
+
+    fn path_str(path: &Path) -> String {
+        path.to_string_lossy().into_owned()
+    }
+
+    impl Repo {
+        fn wt(&self) -> PathBuf {
+            self.repo.join("worktrees").join("feature")
+        }
+
+        fn commit_in_wt(&self, msg: &str) {
+            std::fs::write(self.wt().join("README"), msg.as_bytes()).unwrap();
+            git(&self.wt(), &["add", "-A"]);
+            git(&self.wt(), &["commit", "-qm", msg]);
+        }
+    }
+
+    #[test]
+    fn a_clean_pushed_worktree_has_nothing_in_the_way() {
+        let r = repo_with_worktree();
+        git(&r.wt(), &["push", "-q", "-u", "origin", "feature"]);
+        let breakdown = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(breakdown, InTheWay::default());
+        assert!(breakdown.is_clear());
+    }
+
+    #[test]
+    fn uncommitted_untracked_and_unpushed_are_counted_separately() {
+        let r = repo_with_worktree();
+        std::fs::write(r.wt().join("README"), b"edited\n").unwrap();
+        std::fs::write(r.wt().join("scratch.txt"), b"untracked\n").unwrap();
+
+        let dirty = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(dirty.uncommitted_files, 1);
+        assert_eq!(dirty.untracked_files, 1);
+        assert_eq!(dirty.unpushed_commits, 0);
+        assert!(!dirty.is_clear());
+
+        // Committing clears exactly one dimension and creates another.
+        git(&r.wt(), &["add", "README"]);
+        git(&r.wt(), &["commit", "-qm", "wip"]);
+
+        let breakdown = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(breakdown.uncommitted_files, 0);
+        assert_eq!(breakdown.untracked_files, 1);
+        assert_eq!(breakdown.unpushed_commits, 1);
+    }
+
+    #[test]
+    fn tracked_edits_count_as_uncommitted() {
+        let r = repo_with_worktree();
+        std::fs::write(r.wt().join("README"), b"edited\n").unwrap();
+        let breakdown = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(breakdown.uncommitted_files, 1);
+        assert_eq!(breakdown.untracked_files, 0);
+    }
+
+    #[test]
+    fn pushing_clears_unpushed_but_keeps_other_entries() {
+        let r = repo_with_worktree();
+        std::fs::write(r.wt().join("new.txt"), b"x\n").unwrap();
+        r.commit_in_wt("wip");
+
+        let before = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(before.unpushed_commits, 1);
+
+        git(&r.wt(), &["push", "-q", "-u", "origin", "feature"]);
+        // Same stored entry, different tree: the breakdown must move with it.
+        let after = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(after.unpushed_commits, 0);
+        assert_eq!(after.untracked_files, 0);
+
+        std::fs::write(r.wt().join("loose.txt"), b"x\n").unwrap();
+        let dirty = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(dirty.untracked_files, 1);
+    }
+
+    #[test]
+    fn ignored_files_never_count() {
+        let r = repo_with_worktree();
+        std::fs::write(r.wt().join(".gitignore"), b"target/\n").unwrap();
+        std::fs::create_dir_all(r.wt().join("target")).unwrap();
+        std::fs::write(r.wt().join("target/artifact"), b"x").unwrap();
+
+        let breakdown = in_the_way(&r.wt(), &r.repo, "feature").expect("probe");
+        assert_eq!(
+            breakdown,
+            InTheWay {
+                untracked_files: 1,
+                ..InTheWay::default()
+            },
+            "the .gitignore itself is untracked; target/ is not"
+        );
+    }
+
+    #[test]
+    fn a_missing_directory_reports_nothing_in_the_way() {
+        let r = repo_with_worktree();
+        let gone = r.root.path().join("nowhere");
+        let breakdown = in_the_way(&gone, &r.repo, "feature").expect("probe");
+        assert!(breakdown.is_clear());
+    }
+
+    #[test]
+    fn reclaim_removes_the_directory_and_prunes_a_gone_one() {
+        let r = repo_with_worktree();
+        r.commit_in_wt("precious");
+        reclaim(&r.repo, &r.wt()).expect("reclaim");
+        assert!(!r.wt().exists());
+
+        // A second reclaim over the now-missing path just prunes.
+        reclaim(&r.repo, &r.wt()).expect("reclaim again");
+    }
+
+    #[test]
+    fn reclaim_keeps_the_branch_and_its_commits() {
+        let r = repo_with_worktree();
+        r.commit_in_wt("precious");
+        let sha = {
+            let out = Command::new("git")
+                .arg("-C")
+                .arg(r.wt())
+                .args(["rev-parse", "HEAD"])
+                .output()
+                .unwrap();
+            String::from_utf8_lossy(&out.stdout).trim().to_string()
+        };
+
+        reclaim(&r.repo, &r.wt()).expect("reclaim");
+
+        let out = Command::new("git")
+            .arg("-C")
+            .arg(&r.repo)
+            .args(["rev-parse", "--verify", "refs/heads/feature"])
+            .output()
+            .unwrap();
+        assert!(
+            out.status.success(),
+            "branch must survive reclaim: {}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), sha);
+    }
+
+    #[test]
+    fn reclaim_is_guard_free_on_a_dirty_tree() {
+        let r = repo_with_worktree();
+        std::fs::write(r.wt().join("README"), b"unsaved\n").unwrap();
+        std::fs::write(r.wt().join("notes.txt"), b"unsaved\n").unwrap();
+        reclaim(&r.repo, &r.wt()).expect("reclaim ignores the guard");
+        assert!(!r.wt().exists());
+    }
+}

crates/maestro-daemon/tests/attach.rs

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

crates/maestro-daemon/tests/branches.rs

@@ -0,0 +1,142 @@
+//! Integration tests for `GET /api/branches` (#55).
+
+mod common;
+
+use std::net::{Ipv4Addr, SocketAddr};
+use std::path::Path;
+use std::process::Command;
+use std::sync::Arc;
+
+use common::DaemonFixture;
+use maestro_daemon::local_api;
+use tokio::net::TcpListener;
+use tokio::sync::oneshot;
+
+struct Harness {
+    addr: SocketAddr,
+    _shutdown: oneshot::Sender<()>,
+    _fx: DaemonFixture,
+}
+
+async fn spawn() -> Harness {
+    let fx = DaemonFixture::new();
+    let presets = maestro_config::SpawnSection::default().resolve().unwrap();
+    let router = local_api::router(local_api::state_for(
+        fx.manager.clone(),
+        "naps-laptop",
+        "/home/test",
+        presets,
+        Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        std::sync::Arc::new(fx.retained_store()),
+    ));
+    let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
+        .await
+        .unwrap();
+    let addr = listener.local_addr().unwrap();
+    let (tx, rx) = oneshot::channel::<()>();
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router)
+            .with_graceful_shutdown(async move {
+                let _ = rx.await;
+            })
+            .await;
+    });
+    Harness {
+        addr,
+        _shutdown: tx,
+        _fx: fx,
+    }
+}
+
+fn git(repo: &Path, args: &[&str]) {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(repo)
+        .args(args)
+        .output()
+        .unwrap();
+    assert!(
+        out.status.success(),
+        "git {args:?} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+}
+
+/// A real repo on `main` with a second branch `feature`, and a linked
+/// worktree at `<tmp>/wt-feature` holding `feature`.
+fn repo_with_occupied_branch() -> tempfile::TempDir {
+    let tmp = tempfile::tempdir().unwrap();
+    let repo = tmp.path();
+    git(repo, &["init", "-q", "-b", "main"]);
+    git(
+        repo,
+        &[
+            "-c",
+            "user.email=t@t",
+            "-c",
+            "user.name=t",
+            "commit",
+            "-qm",
+            "init",
+            "--allow-empty",
+        ],
+    );
+    git(repo, &["branch", "feature"]);
+    let wt = tmp.path().join("wt-feature");
+    git(repo, &["worktree", "add", &wt.to_string_lossy(), "feature"]);
+    tmp
+}
+
+async fn get_branches(addr: SocketAddr, path: &Path) -> Vec<maestro_protocol::BranchInfo> {
+    reqwest::get(format!(
+        "http://{addr}/api/branches?path={}",
+        urlencoding::encode(&path.to_string_lossy())
+    ))
+    .await
+    .unwrap()
+    .json()
+    .await
+    .unwrap()
+}
+
+/// #55: every local branch is listed; the main checkout's HEAD reports
+/// `is_head`, and a branch held by a linked worktree reports that worktree's
+/// path so the client can explain why the entry is disabled.
+#[tokio::test]
+async fn branches_lists_local_branches_and_worktree_occupancy() {
+    let tmp = repo_with_occupied_branch();
+    let h = spawn().await;
+
+    let mut branches = get_branches(h.addr, tmp.path()).await;
+    branches.sort_by(|a, b| a.name.cmp(&b.name));
+
+    assert_eq!(
+        branches.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(),
+        ["feature", "main"]
+    );
+
+    let main = branches.iter().find(|b| b.name == "main").unwrap();
+    assert!(main.is_head, "main is the main checkout's HEAD");
+    assert_eq!(main.worktree, None, "HEAD occupancy rides `is_head`");
+
+    let feature = branches.iter().find(|b| b.name == "feature").unwrap();
+    assert!(!feature.is_head);
+    assert_eq!(
+        feature.worktree.as_deref(),
+        Some(tmp.path().join("wt-feature").as_path()),
+        "the linked worktree holding the branch must be reported"
+    );
+}
+
+/// #55: a path outside any repository is not an error — an empty list,
+/// matching how `/api/gitroot` reports "not a repository".
+#[tokio::test]
+async fn branches_returns_empty_for_a_path_outside_a_repository() {
+    let h = spawn().await;
+    let tmp = tempfile::tempdir().unwrap();
+    let plain = tmp.path().join("plain");
+    std::fs::create_dir_all(&plain).unwrap();
+
+    let branches = get_branches(h.addr, &plain).await;
+    assert!(branches.is_empty());
+}

crates/maestro-daemon/tests/common/mod.rs

@@ -163,6 +163,15 @@ impl DaemonFixture {
         self.state_dir.path().join("sessions")
     }
 
+    /// Retained-worktree store rooted at the fixture's own state dir (#78).
+    pub fn retained_store(&self) -> maestro_daemon::retained_store::RetainedStore {
+        maestro_daemon::retained_store::RetainedStore::new(self.retained_dir())
+    }
+
+    pub fn retained_dir(&self) -> PathBuf {
+        self.state_dir.path().join("retained-worktrees")
+    }
+
     pub fn fifo_dir(&self) -> PathBuf {
         self.state_dir.path().join("fifos")
     }

crates/maestro-daemon/tests/local_api.rs

@@ -48,6 +48,7 @@ async fn spawn_with(
         "/home/test",
         presets,
         projects,
+        std::sync::Arc::new(fx.retained_store()),
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await
@@ -492,3 +493,234 @@ async fn next_event(ws: &mut WsClient) -> maestro_protocol::CatalogEvent {
         }
     }
 }
+
+// ---------------------------------------------------------------------------
+// GET /api/worktrees + DELETE /api/worktrees/:id (#80)
+// ---------------------------------------------------------------------------
+
+/// `git -C dir args`, asserting success — the worktree endpoints are tested
+/// against real git, like everything else in this crate.
+fn git(dir: &std::path::Path, args: &[&str]) {
+    let out = std::process::Command::new("git")
+        .arg("-C")
+        .arg(dir)
+        .args(args)
+        .output()
+        .expect("git spawn");
+    assert!(
+        out.status.success(),
+        "git {args:?} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+}
+
+struct RetainedFixture {
+    repo: tempfile::TempDir,
+    wt: std::path::PathBuf,
+}
+
+/// A real repo with a linked worktree for branch `feat/login` whose tree holds
+/// an uncommitted tracked edit and an unpushed commit.
+fn retained_fixture() -> RetainedFixture {
+    let repo = tempfile::tempdir().unwrap();
+    common::init_repo(repo.path());
+    // A pushed main, so "unpushed" means commits made on the feature branch,
+    // not the shared history.
+    let remote = repo.path().join("remote.git");
+    std::fs::create_dir_all(&remote).unwrap();
+    let remote_s = remote.to_string_lossy().into_owned();
+    git(&remote, &["init", "-q", "--bare"]);
+    git(repo.path(), &["remote", "add", "origin", &remote_s]);
+    git(repo.path(), &["push", "-q", "-u", "origin", "main"]);
+    git(
+        repo.path(),
+        &[
+            "worktree",
+            "add",
+            "-q",
+            "-b",
+            "feat/login",
+            "worktrees/feat/login",
+        ],
+    );
+    let wt = repo.path().join("worktrees").join("feat").join("login");
+    RetainedFixture { repo, wt }
+}
+
+impl RetainedFixture {
+    fn commit_in_wt(&self, msg: &str) {
+        std::fs::write(self.wt.join("README"), msg.as_bytes()).unwrap();
+        git(&self.wt, &["add", "-A"]);
+        git(&self.wt, &["commit", "-qm", msg]);
+    }
+
+    fn branch_sha(&self, branch: &str) -> String {
+        let out = std::process::Command::new("git")
+            .arg("-C")
+            .arg(self.repo.path())
+            .args(["rev-parse", "--verify", &format!("refs/heads/{branch}")])
+            .output()
+            .unwrap();
+        assert!(out.status.success(), "branch {branch} must exist");
+        String::from_utf8_lossy(&out.stdout).trim().to_string()
+    }
+}
+
+#[tokio::test]
+async fn worktrees_lists_retained_entries_with_recomputed_breakdown() {
+    let h = spawn("naps-laptop").await;
+    let fx = retained_fixture();
+    // Uncommitted tracked edit + an untracked file; the branch has no commits
+    // beyond main yet.
+    std::fs::write(fx.wt.join("README"), b"unsaved\n").unwrap();
+    std::fs::write(fx.wt.join("scratch.txt"), b"loose\n").unwrap();
+
+    let store = h._fx.retained_store();
+    let entry = store
+        .retain(
+            &fx.wt,
+            fx.repo.path(),
+            "feat/login",
+            maestro_daemon::retained_store::RetainedReason::ForceKilled,
+        )
+        .unwrap();
+
+    let listed: Vec<maestro_protocol::RetainedWorktree> =
+        reqwest::get(url(h.addr, "/api/worktrees"))
+            .await
+            .unwrap()
+            .json()
+            .await
+            .unwrap();
+    assert_eq!(listed.len(), 1);
+    let w = &listed[0];
+    assert_eq!(w.id, entry.id);
+    assert_eq!(w.path, fx.wt);
+    assert_eq!(w.base_repo, fx.repo.path());
+    assert_eq!(w.branch, "feat/login");
+    assert_eq!(w.reason, maestro_protocol::RetainedReason::ForceKilled);
+    assert_eq!(w.in_the_way.uncommitted_files, 1);
+    assert_eq!(w.in_the_way.untracked_files, 1);
+    assert_eq!(w.in_the_way.unpushed_commits, 0);
+
+    // The operator saves the work themselves. The stored entry is untouched —
+    // the next read must report the tree as it is *now*, not as it was when
+    // it was retained.
+    fx.commit_in_wt("saved");
+    let listed: Vec<maestro_protocol::RetainedWorktree> =
+        reqwest::get(url(h.addr, "/api/worktrees"))
+            .await
+            .unwrap()
+            .json()
+            .await
+            .unwrap();
+    assert_eq!(listed.len(), 1, "same entry, still retained");
+    assert_eq!(listed[0].id, entry.id);
+    assert_eq!(listed[0].in_the_way.uncommitted_files, 0);
+    assert_eq!(listed[0].in_the_way.unpushed_commits, 1);
+}
+
+#[tokio::test]
+async fn reclaim_removes_directory_and_entry_but_never_the_branch() {
+    let h = spawn("naps-laptop").await;
+    let fx = retained_fixture();
+    fx.commit_in_wt("precious");
+    let sha = fx.branch_sha("feat/login");
+    std::fs::write(fx.wt.join("README"), b"unsaved\n").unwrap(); // guard would refuse
+
+    let store = h._fx.retained_store();
+    let entry = store
+        .retain(
+            &fx.wt,
+            fx.repo.path(),
+            "feat/login",
+            maestro_daemon::retained_store::RetainedReason::ExitedWithUnsavedWork,
+        )
+        .unwrap();
+
+    let resp = reqwest::Client::new()
+        .delete(url(h.addr, &format!("/api/worktrees/{}", entry.id)))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NO_CONTENT);
+
+    assert!(!fx.wt.exists(), "reclaim removes the directory");
+    let listed: Vec<maestro_protocol::RetainedWorktree> =
+        reqwest::get(url(h.addr, "/api/worktrees"))
+            .await
+            .unwrap()
+            .json()
+            .await
+            .unwrap();
+    assert!(listed.is_empty(), "reclaim drops the store entry");
+    assert_eq!(
+        fx.branch_sha("feat/login"),
+        sha,
+        "the branch and its commits survive"
+    );
+}
+
+#[tokio::test]
+async fn reclaim_of_an_already_gone_directory_still_drops_the_entry() {
+    let h = spawn("naps-laptop").await;
+    let fx = retained_fixture();
+    let store = h._fx.retained_store();
+    let entry = store
+        .retain(
+            &fx.wt,
+            fx.repo.path(),
+            "feat/login",
+            maestro_daemon::retained_store::RetainedReason::ForceKilled,
+        )
+        .unwrap();
+    std::fs::remove_dir_all(&fx.wt).unwrap(); // operator rm -rf
+
+    let resp = reqwest::Client::new()
+        .delete(url(h.addr, &format!("/api/worktrees/{}", entry.id)))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NO_CONTENT);
+    assert!(store.load_all().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn reclaim_unknown_id_returns_404() {
+    let h = spawn("naps-laptop").await;
+    let resp = reqwest::Client::new()
+        .delete(url(h.addr, &format!("/api/worktrees/{}", Uuid::new_v4())))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn worktrees_prunes_entries_whose_directory_vanished_by_hand() {
+    let h = spawn("naps-laptop").await;
+    let fx = retained_fixture();
+    let store = h._fx.retained_store();
+    store
+        .retain(
+            &fx.wt,
+            fx.repo.path(),
+            "feat/login",
+            maestro_daemon::retained_store::RetainedReason::ForceKilled,
+        )
+        .unwrap();
+    std::fs::remove_dir_all(&fx.wt).unwrap();
+
+    let listed: Vec<maestro_protocol::RetainedWorktree> =
+        reqwest::get(url(h.addr, "/api/worktrees"))
+            .await
+            .unwrap()
+            .json()
+            .await
+            .unwrap();
+    assert!(listed.is_empty(), "a hand-removed directory is not listed");
+    assert!(
+        store.load_all().unwrap().is_empty(),
+        "and its entry is gone"
+    );
+}

crates/maestro-daemon/tests/session_manager.rs

@@ -370,7 +370,7 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
     let fx = DaemonFixture::new();
     let repo = TempDir::new().unwrap();
     init_repo(repo.path());
-    let wt_path = repo.path().join("worktrees").join("feat-keep");
+    let wt_path = repo.path().join("worktrees").join("feat").join("keep");
 
     let s = fx
         .manager
@@ -401,7 +401,7 @@ async fn kill_leaves_worktree_with_unsaved_work_on_disk() {
     let fx = DaemonFixture::new();
     let repo = TempDir::new().unwrap();
     init_repo(repo.path());
-    let wt_path = repo.path().join("worktrees").join("feat-guarded");
+    let wt_path = repo.path().join("worktrees").join("feat").join("guarded");
 
     let s = fx
         .manager

crates/maestro-daemon/tests/sidecar.rs

@@ -19,6 +19,7 @@ fn sample(id: Uuid) -> Session {
         command: "bash".into(),
         env: HashMap::from([("FOO".into(), "bar".into())]),
         metadata: HashMap::from([("name".into(), Value::String("maestro-impl".into()))]),
+        worktree: None,
         status: SessionStatus::Running,
         created_at: DateTime::parse_from_rfc3339("2026-05-24T12:00:00Z")
             .unwrap()

crates/maestro-daemon/tests/worktree.rs

@@ -53,7 +53,7 @@ fn add_places_worktree_inside_the_base_repo_by_default() {
     let mgr = WorktreeManager::new(None);
 
     let path = mgr.add_new(&repo, "feat/example").expect("add worktree");
-    assert_eq!(path, repo.join("worktrees").join("feat-example"));
+    assert_eq!(path, repo.join("worktrees").join("feat").join("example"));
     assert!(path.exists());
     assert!(path.join("README").exists());
 
@@ -70,32 +70,51 @@ fn worktree_root_override_redirects_placement() {
     let wt_root = TempDir::new().unwrap();
     let mgr = WorktreeManager::new(Some(wt_root.path().to_path_buf()));
 
+    // The repo's basename sits between the root and the branch slug, so two
+    // repos spawning the same branch name don't target one directory.
+    let repo_name = repo.file_name().unwrap();
     let path = mgr.add_new(&repo, "feat/example").expect("add worktree");
-    assert_eq!(path, wt_root.path().join("feat-example"));
+    // The override root disambiguates same-named checkouts with a digest of
+    // the full repo path, and the branch keeps its own shape.
+    // <root>/<repo basename>-<digest>/feat/example
+    let prefix = format!("{}-", repo_name.to_string_lossy());
+    let repo_dir_name = path
+        .strip_prefix(wt_root.path())
+        .unwrap()
+        .components()
+        .next()
+        .unwrap();
+    assert!(
+        repo_dir_name
+            .as_os_str()
+            .to_string_lossy()
+            .starts_with(&prefix),
+        "{path:?}"
+    );
+    assert!(path.ends_with("feat/example"), "{path:?}");
     assert!(path.exists());
 }
 
+/// Anything at all occupying the target path — ours, the operator's, or an
+/// unrelated directory — is sidestepped, not adopted and not reported (#77).
 #[test]
-fn existing_directory_at_target_path_is_an_error_carrying_the_path() {
+fn an_occupied_target_path_gets_a_numeric_suffix() {
     let repo_dir = TempDir::new().unwrap();
     let repo = repo_dir.path().to_path_buf();
     init_repo(&repo);
 
-    // A predictable path means collisions are possible; they must be
-    // reported, never silently relocated.
-    std::fs::create_dir_all(repo.join("worktrees").join("feat-collide")).unwrap();
+    // A non-git directory sits exactly where the worktree would go.
+    let squatter = repo.join("worktrees").join("feat").join("collide");
+    std::fs::create_dir_all(&squatter).unwrap();
+    std::fs::write(squatter.join("operator-notes.txt"), b"mine\n").unwrap();
 
     let mgr = WorktreeManager::new(None);
-    let err = mgr.add_new(&repo, "feat/collide").unwrap_err();
-    let msg = format!("{err}");
+    let path = mgr.add_new(&repo, "feat/collide").expect("sidesteps");
+    assert_eq!(path, repo.join("worktrees").join("feat").join("collide-2"));
+    assert!(path.exists());
     assert!(
-        msg.contains(
-            repo.join("worktrees")
-                .join("feat-collide")
-                .to_str()
-                .unwrap()
-        ),
-        "{msg}"
+        squatter.join("operator-notes.txt").exists(),
+        "the occupant is untouched"
     );
 }
 
@@ -288,3 +307,145 @@ fn add_fails_when_branch_already_exists() {
     let msg = format!("{err}");
     assert!(msg.contains("git exited"), "{msg}");
 }
+
+/// The project picker lists linked worktrees as pickable rows, so `base_repo`
+/// is easily a worktree rather than the main checkout. Placing inside it would
+/// nest one worktree in another — and git hides a registered worktree's
+/// contents from the outer `git status`, so the outer tree reads clean and
+/// removing it deletes the inner one's uncommitted work (#54 review).
+#[test]
+fn placement_resolves_a_linked_worktree_to_the_main_checkout() {
+    let repo_dir = TempDir::new().unwrap();
+    let repo = repo_dir.path().to_path_buf();
+    init_repo(&repo);
+
+    let mgr = WorktreeManager::new(None);
+    let outer = mgr.add_new(&repo, "feat/outer").expect("add outer");
+
+    // Spawn again with the *worktree* as the base, the way the picker would.
+    let inner = mgr.add_new(&outer, "feat/inner").expect("add inner");
+    assert!(
+        !inner.starts_with(&outer),
+        "must not nest: {inner:?} inside {outer:?}"
+    );
+    assert!(
+        inner.starts_with(repo.canonicalize().unwrap().join("worktrees")),
+        "placed against the main checkout: {inner:?}"
+    );
+}
+
+/// Belt and braces for a nesting that predates this daemon: refuse to remove
+/// a worktree that has another registered underneath it.
+#[test]
+fn remove_refuses_a_worktree_holding_a_nested_one() {
+    let repo_dir = TempDir::new().unwrap();
+    let repo = repo_dir.path().to_path_buf();
+    init_repo(&repo);
+
+    let mgr = WorktreeManager::new(None);
+    let outer = mgr.add_new(&repo, "feat/outer").expect("add outer");
+    // Register one by hand inside `outer`, bypassing our placement.
+    let nested = outer.join("worktrees").join("hand-rolled");
+    run_git(
+        &repo,
+        &[
+            "worktree",
+            "add",
+            "-b",
+            "feat/hand",
+            nested.to_str().unwrap(),
+        ],
+    );
+    std::fs::write(nested.join("notes.txt"), b"unsaved\n").unwrap();
+
+    mgr.remove(&repo, &outer)
+        .expect_err("a worktree holding a nested one must be refused");
+    assert!(nested.join("notes.txt").exists(), "inner work survives");
+}
+
+/// Two repos spawning the same branch name under one override root must not
+/// collide (#54 review).
+#[test]
+fn override_root_keeps_repos_apart() {
+    let root_dir = TempDir::new().unwrap();
+    let a_dir = TempDir::new().unwrap();
+    let b_dir = TempDir::new().unwrap();
+    init_repo(a_dir.path());
+    init_repo(b_dir.path());
+
+    let mgr = WorktreeManager::new(Some(root_dir.path().to_path_buf()));
+    let a = mgr.add_new(a_dir.path(), "feat/shared").expect("repo a");
+    let b = mgr.add_new(b_dir.path(), "feat/shared").expect("repo b");
+    assert_ne!(a, b, "same branch name in two repos must not collide");
+}
+
+/// Flattening `/` and `.` to `-` made these three share one directory, so the
+/// losers could never get a worktree (#54 review).
+#[test]
+fn similar_branch_names_get_distinct_directories() {
+    let repo_dir = TempDir::new().unwrap();
+    let repo = repo_dir.path().to_path_buf();
+    init_repo(&repo);
+
+    let mgr = WorktreeManager::new(None);
+    let a = mgr.add_new(&repo, "feat/x").expect("feat/x");
+    let b = mgr.add_new(&repo, "feat.x").expect("feat.x");
+    let c = mgr.add_new(&repo, "feat-x").expect("feat-x");
+    assert_ne!(a, b);
+    assert_ne!(b, c);
+    assert_ne!(a, c);
+    assert!(a.ends_with("feat/x"), "{a:?}");
+}
+
+/// A guarded leftover stays on disk untouched, and is never adopted (#77).
+/// Re-spawning its branch is refused by git itself — the branch is still
+/// checked out inside the leftover — which the caller surfaces.
+#[test]
+fn a_guarded_leftover_is_never_adopted() {
+    let repo_dir = TempDir::new().unwrap();
+    let repo = repo_dir.path().to_path_buf();
+    init_repo(&repo);
+
+    let mgr = WorktreeManager::new(None);
+    let first = mgr.add_new(&repo, "feat/resume").expect("add");
+    std::fs::write(first.join("notes.txt"), b"unsaved\n").unwrap();
+
+    // The guard refuses, leaving it on disk.
+    mgr.remove(&repo, &first)
+        .expect_err("dirty tree is guarded");
+
+    let err = mgr
+        .add_existing(&repo, "feat/resume")
+        .expect_err("a branch already checked out cannot be spawned twice");
+    assert!(format!("{err}").contains("git exited"), "{err}");
+    assert!(
+        first.join("notes.txt").exists(),
+        "the leftover's unsaved work is untouched"
+    );
+}
+
+/// The `worktree_root` override gets the same collision suffix (#77).
+#[test]
+fn the_override_root_suffixes_collisions_too() {
+    let repo_dir = TempDir::new().unwrap();
+    let repo = repo_dir.path().to_path_buf();
+    init_repo(&repo);
+
+    let wt_root = TempDir::new().unwrap();
+    let mgr = WorktreeManager::new(Some(wt_root.path().to_path_buf()));
+
+    // First add settles `<root>/<repo basename>-<digest>/` so the squatter
+    // can be created at the exact target.
+    mgr.add_new(&repo, "feat/first").expect("add first");
+    let repo_dir_in_root = std::fs::read_dir(wt_root.path())
+        .unwrap()
+        .next()
+        .unwrap()
+        .unwrap()
+        .path();
+    let squatter = repo_dir_in_root.join("feat").join("collide");
+    std::fs::create_dir_all(&squatter).unwrap();
+
+    let path = mgr.add_new(&repo, "feat/collide").expect("sidesteps");
+    assert_eq!(path, squatter.with_file_name("collide-2"), "{path:?}");
+}

crates/maestro-e2e/src/client.rs

@@ -11,7 +11,9 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use futures_util::{SinkExt, StreamExt};
-use maestro_protocol::{CatalogEvent, CreateSessionRequest, DaemonClient, Session};
+use maestro_protocol::{
+    BranchInfo, CatalogEvent, CreateSessionRequest, DaemonClient, Project, Session,
+};
 use tokio_tungstenite::tungstenite::client::IntoClientRequest;
 use tokio_tungstenite::tungstenite::Message as WsMessage;
 use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
@@ -62,6 +64,14 @@ impl TestClient {
         Ok(self.daemon.kill_session(id).await?)
     }
 
+    pub async fn list_projects(&self) -> Result<Vec<Project>, ClientError> {
+        Ok(self.daemon.list_projects().await?)
+    }
+
+    pub async fn list_branches(&self, path: &str) -> Result<Vec<BranchInfo>, ClientError> {
+        Ok(self.daemon.list_branches(path).await?)
+    }
+
     /// Connect to the daemon's per-session WS and return the stream. The
     /// caller drives the conversation.
     pub async fn attach(

crates/maestro-e2e/src/daemon.rs

@@ -29,11 +29,32 @@ impl Daemon {
         Self::spawn_at(SocketAddr::from((Ipv4Addr::LOCALHOST, free_port()))).await
     }
 
+    /// Spawn with a config file pre-seeded at the daemon's expected path
+    /// (`$XDG_CONFIG_HOME/maestro/config.toml`).
+    pub async fn spawn_with_config(toml: &str) -> Self {
+        Self::spawn_config_at(
+            SocketAddr::from((Ipv4Addr::LOCALHOST, free_port())),
+            Some(toml),
+        )
+        .await
+    }
+
     /// Spawn on a caller-supplied bind address.
     pub async fn spawn_at(bind: SocketAddr) -> Self {
+        Self::spawn_config_at(bind, None).await
+    }
+
+    /// Spawn on a caller-supplied bind address, with an optional config file.
+    async fn spawn_config_at(bind: SocketAddr, config: impl Into<Option<&str>>) -> Self {
         let home = TempDir::new().expect("home tmpdir");
         let tmux = TempDir::new().expect("tmux tmpdir");
 
+        if let Some(toml) = config.into() {
+            let dir = home.path().join(".config").join("maestro");
+            std::fs::create_dir_all(&dir).expect("config dir");
+            std::fs::write(dir.join("config.toml"), toml).expect("write config.toml");
+        }
+
         let child = launch(bind, home.path(), tmux.path());
         let me = Self {
             bind_addr: bind,

crates/maestro-e2e/src/lib.rs

@@ -14,5 +14,5 @@ pub mod daemon;
 pub mod util;
 
 pub use build::workspace_target_bin;
-pub use client::TestClient;
+pub use client::{ClientError, TestClient};
 pub use daemon::Daemon;

crates/maestro-e2e/tests/e2e.rs

@@ -35,6 +35,22 @@ fn create_req(cwd: &std::path::Path, command: &str) -> CreateSessionRequest {
     }
 }
 
+/// Spawn request carrying a worktree spec against `base`.
+fn worktree_req(base: &std::path::Path, branch: &str, create_branch: bool) -> CreateSessionRequest {
+    CreateSessionRequest {
+        cwd: base.to_path_buf(),
+        command: "sleep 30".into(),
+        env: HashMap::new(),
+        metadata: HashMap::new(),
+        worktree: Some(WorktreeSpec {
+            base_repo: base.to_path_buf(),
+            branch: branch.into(),
+            cleanup_on_kill: true,
+            create_branch,
+        }),
+    }
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn lists_spawned_sessions() {
     let (_daemon, client) = bring_up().await;
@@ -140,7 +156,7 @@ async fn kill_removes_clean_worktree() {
     assert!(
         worktrees
             .iter()
-            .any(|w| w.contains("worktrees/feature-e2e")),
+            .any(|w| w.contains("worktrees/feature/e2e")),
         "expected a worktree for feature/e2e under <repo>/worktrees, got: {worktrees:?}"
     );
 
@@ -170,7 +186,11 @@ async fn kill_spares_worktree_with_uncommitted_changes() {
 
     let base = TempDir::new().unwrap();
     init_repo(base.path());
-    let wt_path = base.path().join("worktrees").join("feature-unsaved");
+    let wt_path = base
+        .path()
+        .join("worktrees")
+        .join("feature")
+        .join("unsaved");
 
     let req = CreateSessionRequest {
         cwd: base.path().to_path_buf(),
@@ -204,6 +224,19 @@ async fn kill_spares_worktree_with_uncommitted_changes() {
         wt_path.exists(),
         "guarded worktree must be left on disk after kill"
     );
+    // Left findable, not silently half-deleted: git still registers it and
+    // the uncommitted edit survives byte for byte (#66).
+    assert!(
+        git_worktree_list(base.path())
+            .iter()
+            .any(|w| w.contains("feature/unsaved")),
+        "guarded worktree must stay registered in git worktree list"
+    );
+    assert_eq!(
+        std::fs::read(wt_path.join("README")).unwrap(),
+        b"unsaved edits\n",
+        "uncommitted changes must survive the guarded kill"
+    );
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -240,6 +273,283 @@ async fn spawn_on_existing_branch_checks_it_out() {
     client.kill_session(s.id).await.expect("kill");
 }
 
+/// #66: a fresh branch spawns a worktree at `<repo>/worktrees/<branch>` and
+/// the session actually runs inside it — `current_cwd` comes from tmux's live
+/// pane state, not from the spawn request.
+#[tokio::test(flavor = "multi_thread")]
+async fn spawn_new_branch_creates_worktree_and_runs_in_it() {
+    let (_daemon, client) = bring_up().await;
+
+    let base = TempDir::new().unwrap();
+    init_repo(base.path());
+    let wt_path = base.path().join("worktrees").join("feature").join("fresh");
+
+    let s = client
+        .spawn_session(&worktree_req(base.path(), "feature/fresh", true))
+        .await
+        .expect("spawn new-branch worktree");
+
+    assert_eq!(
+        s.cwd, wt_path,
+        "session must report the worktree as its cwd"
+    );
+    assert!(wt_path.is_dir(), "worktree directory must exist on disk");
+
+    // The activity watcher fills `current_cwd` from tmux's pane_current_path,
+    // so this is the daemon confirming where the process really runs.
+    wait_for_async(
+        "session's live cwd is the worktree",
+        Duration::from_secs(20),
+        || {
+            let client = client.clone();
+            let id = s.id;
+            let want = wt_path.clone();
+            async move {
+                client
+                    .list_sessions()
+                    .await
+                    .ok()
+                    .and_then(|ss| ss.iter().find(|s| s.id == id).cloned())
+                    .map(|s| s.current_cwd == Some(want.clone()))
+                    .unwrap_or(false)
+            }
+        },
+    )
+    .await;
+
+    client.kill_session(s.id).await.expect("kill");
+}
+
+/// #66: a second spawn onto a branch that already has a worktree is rejected
+/// with a structured worktree error; the first worktree stays intact.
+#[tokio::test(flavor = "multi_thread")]
+async fn second_spawn_on_same_branch_is_rejected() {
+    let (_daemon, client) = bring_up().await;
+
+    let base = TempDir::new().unwrap();
+    init_repo(base.path());
+
+    let first = client
+        .spawn_session(&worktree_req(base.path(), "feature/dup", true))
+        .await
+        .expect("first spawn");
+    let dup = client
+        .spawn_session(&worktree_req(base.path(), "feature/dup", true))
+        .await;
+    match dup {
+        Err(maestro_e2e::ClientError::Api(maestro_protocol::ClientError::Api { info, .. })) => {
+            assert_eq!(
+                info.code, "worktree_failed",
+                "expected worktree error: {info:?}"
+            );
+        }
+        other => panic!("expected rejection for duplicate branch, got {other:?}"),
+    }
+
+    // Exactly one registration, one directory, still usable.
+    // Count branch records only: the worktree path now contains the branch
+    // name too (`worktrees/feature/dup`), so a substring match over every line
+    // would count the same tree twice.
+    let holders = git_worktree_list(base.path())
+        .iter()
+        .filter(|w| w.as_str() == "branch refs/heads/feature/dup")
+        .count();
+    assert_eq!(holders, 1, "duplicate spawn must not register another tree");
+    assert!(
+        base.path()
+            .join("worktrees")
+            .join("feature")
+            .join("dup")
+            .is_dir(),
+        "original worktree must be untouched"
+    );
+
+    client.kill_session(first.id).await.expect("kill");
+}
+
+/// #66/#56: when the client picks a *linked worktree* as base_repo, placement
+/// resolves through `--git-common-dir` to the main checkout, so the new tree
+/// lands at `<main>/worktrees/<branch>` instead of nesting inside another
+/// worktree.
+#[tokio::test(flavor = "multi_thread")]
+async fn spawn_from_linked_worktree_places_in_main_checkout() {
+    let (_daemon, client) = bring_up().await;
+
+    let base = TempDir::new().unwrap();
+    init_repo(base.path());
+    let linked = base.path().join("linked");
+    run_git(
+        &[
+            "worktree",
+            "add",
+            "-q",
+            "-b",
+            "other",
+            &linked.to_string_lossy(),
+        ],
+        base.path(),
+    );
+
+    let s = client
+        .spawn_session(&worktree_req(&linked, "feature/nested", true))
+        .await
+        .expect("spawn from linked worktree");
+
+    let want = base.path().join("worktrees").join("feature").join("nested");
+    assert_eq!(
+        s.cwd, want,
+        "worktree must be placed under the main checkout"
+    );
+    assert!(want.is_dir());
+    assert!(
+        !s.cwd.starts_with(&linked),
+        "worktrees must never nest inside another worktree"
+    );
+
+    client.kill_session(s.id).await.expect("kill");
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/projects + /api/branches (#54/#55/#66)
+// ---------------------------------------------------------------------------
+
+/// #66: two repos under a configured `[spawn].project_roots` root are both
+/// discovered by `GET /api/projects`; git activity gives every repo a
+/// `last_activity`, and spawning inside one merges its command into the
+/// project entry via spawn history.
+#[tokio::test(flavor = "multi_thread")]
+async fn projects_endpoint_discovers_roots_and_merges_activity() {
+    let root = TempDir::new().unwrap();
+    let alpha = make_repo(root.path(), "alpha");
+    make_repo(root.path(), "beta");
+
+    let daemon = Daemon::spawn_with_config(&format!(
+        "[spawn]\nproject_roots = [\"{}\"]\nproject_scan_depth = 2\n",
+        root.path().display()
+    ))
+    .await;
+    let client = TestClient::new(&daemon.http_base());
+
+    let projects = client.list_projects().await.expect("list projects");
+    let names: Vec<&str> = projects.iter().map(|p| p.name.as_str()).collect();
+    assert!(
+        names.contains(&"alpha") && names.contains(&"beta"),
+        "both repos must be discovered, got: {names:?}"
+    );
+
+    let find = |name: &str| {
+        projects
+            .iter()
+            .find(|p| p.name == name)
+            .cloned()
+            .expect("project present")
+    };
+    // Both have commits, so git activity alone populates last_activity…
+    assert!(
+        find("alpha").last_activity.is_some(),
+        "git activity must surface"
+    );
+    assert!(
+        find("beta").last_activity.is_some(),
+        "git activity must surface"
+    );
+    // …and neither has been spawned into yet.
+    assert_eq!(find("alpha").last_command, None);
+    assert_eq!(find("beta").last_command, None);
+
+    // Spawning inside alpha writes durable history; /api/projects folds it in.
+    let s = client
+        .spawn_session(&create_req(&alpha, "sleep 30"))
+        .await
+        .expect("spawn in alpha");
+
+    wait_for_async(
+        "alpha's project entry reflects spawn history",
+        Duration::from_secs(5),
+        || {
+            let client = client.clone();
+            async move {
+                client
+                    .list_projects()
+                    .await
+                    .ok()
+                    .map(|ps| {
+                        ps.iter()
+                            .find(|p| p.name == "alpha")
+                            .map(|p| p.last_command.as_deref() == Some("sleep 30"))
+                            .unwrap_or(false)
+                    })
+                    .unwrap_or(false)
+            }
+        },
+    )
+    .await;
+
+    // beta was never spawned into: no command recorded there.
+    let beta_after = client
+        .list_projects()
+        .await
+        .expect("list after spawn")
+        .into_iter()
+        .find(|p| p.name == "beta")
+        .unwrap();
+    assert_eq!(beta_after.last_command, None);
+
+    client.kill_session(s.id).await.expect("kill");
+}
+
+/// #66: `GET /api/branches` lists every local branch, flags the main
+/// checkout's HEAD with `is_head`, and reports which linked worktree holds an
+/// occupied branch.
+#[tokio::test(flavor = "multi_thread")]
+async fn branches_endpoint_lists_branches_and_flags_occupied() {
+    let (_daemon, client) = bring_up().await;
+
+    let base = TempDir::new().unwrap();
+    init_repo(base.path());
+    run_git(&["branch", "feature/taken"], base.path());
+    run_git(&["branch", "feature/free"], base.path());
+    let holder = base.path().join("holder-wt");
+    run_git(
+        &[
+            "worktree",
+            "add",
+            "-q",
+            &holder.to_string_lossy(),
+            "feature/taken",
+        ],
+        base.path(),
+    );
+
+    let branches = client
+        .list_branches(&base.path().to_string_lossy())
+        .await
+        .expect("list branches");
+    let by_name = |name: &str| {
+        branches
+            .iter()
+            .find(|b| b.name == name)
+            .cloned()
+            .unwrap_or_else(|| panic!("branch {name} missing from {branches:?}"))
+    };
+
+    let main = by_name("main");
+    assert!(main.is_head, "main is the main checkout's HEAD");
+    assert_eq!(main.worktree, None);
+
+    let taken = by_name("feature/taken");
+    assert!(!taken.is_head);
+    assert_eq!(
+        taken.worktree.as_deref(),
+        Some(holder.canonicalize().unwrap().as_path()),
+        "occupied branch must report its holding worktree"
+    );
+
+    let free = by_name("feature/free");
+    assert!(!free.is_head);
+    assert_eq!(free.worktree, None, "unoccupied branch must be spawnable");
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn daemon_restart_recovers_session() {
     let (mut daemon, client) = bring_up().await;
@@ -428,6 +738,15 @@ fn init_repo(dir: &std::path::Path) {
     run_git(&["commit", "-q", "-m", "initial"], dir);
 }
 
+/// Real git repo at `<root>/<name>`, canonicalized (the scanner canonicalizes
+/// discovered paths too, so comparisons must agree on the real path).
+fn make_repo(root: &std::path::Path, name: &str) -> std::path::PathBuf {
+    let dir = root.join(name);
+    std::fs::create_dir_all(&dir).unwrap();
+    init_repo(&dir);
+    dir.canonicalize().unwrap()
+}
+
 fn run_git(args: &[&str], cwd: &std::path::Path) {
     let out = Command::new("git")
         .arg("-C")

crates/maestro-protocol/src/client.rs

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

crates/maestro-protocol/src/lib.rs

@@ -53,6 +53,14 @@ pub struct Session {
     pub env: HashMap<String, String>,
     #[serde(default)]
     pub metadata: HashMap<String, Value>,
+    /// The worktree this session owns, when it was spawned with one.
+    ///
+    /// Persisted rather than kept in memory only: after a daemon restart the
+    /// recovered session must still know what to clean up, and with
+    /// deterministic worktree paths a forgotten association leaves a directory
+    /// that blocks that branch from ever being spawned again (#54 review).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub worktree: Option<SessionWorktree>,
     pub status: SessionStatus,
     pub created_at: DateTime<Utc>,
     /// Current foreground command in the session's pane (e.g. `claude`,
@@ -127,6 +135,66 @@ fn default_true() -> bool {
     true
 }
 
+/// The worktree a running session owns, carried on [`Session`] so it survives
+/// a daemon restart.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SessionWorktree {
+    pub path: PathBuf,
+    pub base_repo: PathBuf,
+}
+
+/// Why a retained worktree outlived its session (#80). Same values the
+/// daemon's retained store persists; new variants are additive but clients
+/// should render unknown reasons generically.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum RetainedReason {
+    /// The session was killed with `--force` while its worktree held unsaved
+    /// work.
+    ForceKilled,
+    /// The session ended by itself and its worktree held unsaved work.
+    ExitedWithUnsavedWork,
+}
+
+/// What a kill refusal would report about a worktree right now (#80) — the
+/// same breakdown that blocks an unforced kill, recomputed on every read of
+/// [`RetainedWorktree`] so it reflects the tree now rather than when it was
+/// retained.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InTheWay {
+    /// Tracked files with uncommitted modifications.
+    #[serde(default)]
+    pub uncommitted_files: usize,
+    /// Untracked files that are not ignored (ignored files never block).
+    #[serde(default)]
+    pub untracked_files: usize,
+    /// Commits on the branch reachable from no remote-tracking ref.
+    #[serde(default)]
+    pub unpushed_commits: usize,
+}
+
+impl InTheWay {
+    /// Nothing blocks any more — the work has since been committed and pushed.
+    pub fn is_clear(&self) -> bool {
+        *self == Self::default()
+    }
+}
+
+/// One entry of `GET /api/worktrees` (#80): a retained worktree with its
+/// in-the-way state as of this read. Reclaiming it via
+/// `DELETE /api/worktrees/:id` removes the directory but **never** the branch.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RetainedWorktree {
+    pub id: Uuid,
+    pub path: PathBuf,
+    pub base_repo: PathBuf,
+    pub branch: String,
+    pub reason: RetainedReason,
+    pub retained_at: DateTime<Utc>,
+    #[serde(default)]
+    pub in_the_way: InTheWay,
+}
+
 /// HTTP `POST /api/sessions` body.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CreateSessionRequest {
@@ -212,6 +280,21 @@ pub struct Project {
     pub last_command: Option<String>,
 }
 
+/// One local branch of a repository for `GET /api/branches` (#55). A client
+/// disables the entry when `is_head` is set or `worktree` is present — git
+/// refuses to check the same branch out in two worktrees at once.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BranchInfo {
+    /// Short branch name (`main`, `feature/foo`).
+    pub name: String,
+    /// Whether this branch is the main checkout's current HEAD. The main
+    /// checkout's occupancy reports here rather than through `worktree`.
+    pub is_head: bool,
+    /// Toplevel path of the linked worktree holding this branch, if any.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub worktree: Option<PathBuf>,
+}
+
 /// Structured failure used everywhere we don't want to leak a string-only error.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ErrorInfo {
@@ -395,6 +478,7 @@ mod tests {
             command: "claude".into(),
             env: HashMap::from([("FOO".into(), "bar".into())]),
             metadata: HashMap::from([("name".into(), Value::String("maestro-impl".into()))]),
+            worktree: None,
             status: SessionStatus::Running,
             created_at: DateTime::parse_from_rfc3339("2026-05-24T12:00:00Z")
                 .unwrap()
@@ -507,6 +591,60 @@ mod tests {
         assert_eq!(spec, round_trip(&spec));
     }
 
+    fn sample_retained_worktree() -> RetainedWorktree {
+        RetainedWorktree {
+            id: Uuid::from_u128(0x0123_4567_89ab_cdef_0123_4567_89ab_cdef),
+            path: PathBuf::from("/work/maestro/worktrees/feat/login"),
+            base_repo: PathBuf::from("/work/maestro"),
+            branch: "feat/login".into(),
+            reason: RetainedReason::ForceKilled,
+            retained_at: DateTime::parse_from_rfc3339("2026-08-24T10:00:00Z")
+                .unwrap()
+                .with_timezone(&Utc),
+            in_the_way: InTheWay {
+                uncommitted_files: 2,
+                untracked_files: 1,
+                unpushed_commits: 3,
+            },
+        }
+    }
+
+    #[test]
+    fn retained_worktree_round_trips() {
+        let wt = sample_retained_worktree();
+        assert_eq!(wt, round_trip(&wt));
+    }
+
+    /// A payload from a daemon predating `in_the_way` still decodes; the
+    /// breakdown defaults to "nothing in the way".
+    #[test]
+    fn retained_worktree_defaults_in_the_way_on_legacy_payload() {
+        let legacy = serde_json::json!({
+            "id": Uuid::from_u128(1),
+            "path": "/w/t",
+            "base_repo": "/w",
+            "branch": "feat/login",
+            "reason": "force-killed",
+            "retained_at": "2026-08-24T10:00:00Z",
+        });
+        let wt: RetainedWorktree = serde_json::from_value(legacy).unwrap();
+        assert_eq!(wt.reason, RetainedReason::ForceKilled);
+        assert_eq!(wt.in_the_way, InTheWay::default());
+        assert!(wt.in_the_way.is_clear());
+    }
+
+    #[test]
+    fn retained_reason_serializes_kebab_case() {
+        assert_eq!(
+            serde_json::to_value(RetainedReason::ForceKilled).unwrap(),
+            serde_json::json!("force-killed")
+        );
+        assert_eq!(
+            serde_json::to_value(RetainedReason::ExitedWithUnsavedWork).unwrap(),
+            serde_json::json!("exited-with-unsaved-work")
+        );
+    }
+
     #[test]
     fn catalog_event_round_trips_and_tags() {
         let session = sample_session();

crates/maestro-protocol/src/routes.rs

@@ -21,13 +21,18 @@ pub const RECENT_DIRS: &str = "/api/recent-dirs";
 pub const PROJECTS: &str = "/api/projects";
 /// `GET` the enclosing repository of a path. Takes a `path` query param.
 pub const GITROOT: &str = "/api/gitroot";
+/// `GET` one repository's local branches. Takes a `path` query param.
+pub const BRANCHES: &str = "/api/branches";
 /// `GET` a batch of generated session handles (#53). Takes a `count` query
 /// param (default 1, capped at [`maestro_names`]' batch cap).
 pub const NAMES: &str = "/api/names";
+/// `GET` retained worktrees (#80): what the store holds, with the in-the-way
+/// breakdown recomputed on read.
+pub const WORKTREES: &str = "/api/worktrees";
 /// `WS` catalog snapshot + session deltas.
 pub const EVENTS: &str = "/api/events";
 
-/// Name of the query parameter [`DIRS`] and [`GITROOT`] both take.
+/// Name of the query parameter [`DIRS`], [`GITROOT`], and [`BRANCHES`] take.
 pub const PATH_QUERY: &str = "path";
 
 /// Name of the query parameter [`NAMES`] takes.
@@ -38,6 +43,11 @@ pub fn session(id: Uuid) -> String {
     format!("{SESSIONS}/{id}")
 }
 
+/// `DELETE /api/worktrees/:id` — reclaim one retained worktree (#80).
+pub fn worktree(id: Uuid) -> String {
+    format!("{WORKTREES}/{id}")
+}
+
 /// `WS /api/attach/:id` — raw PTY bytes.
 pub fn attach(id: Uuid) -> String {
     format!("{API_PREFIX}/attach/{id}")
@@ -48,6 +58,7 @@ pub fn attach(id: Uuid) -> String {
 pub mod patterns {
     pub const SESSION: &str = "/api/sessions/:id";
     pub const ATTACH: &str = "/api/attach/:id";
+    pub const WORKTREE: &str = "/api/worktrees/:id";
 }
 
 /// A daemon base URL that could not be turned into a WebSocket base.
@@ -158,6 +169,10 @@ mod tests {
             attach(id()),
             "/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
         );
+        assert_eq!(
+            worktree(id()),
+            "/api/worktrees/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
+        );
         assert_eq!(
             attach_url("https://laptop.lan:7070", id()).unwrap(),
             "wss://laptop.lan:7070/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
@@ -176,6 +191,10 @@ mod tests {
             patterns::ATTACH.trim_end_matches(":id"),
             attach(id()).trim_end_matches(&id().to_string())
         );
+        assert_eq!(
+            patterns::WORKTREE.trim_end_matches(":id"),
+            worktree(id()).trim_end_matches(&id().to_string())
+        );
     }
 
     #[test]
@@ -187,7 +206,9 @@ mod tests {
             RECENT_DIRS,
             PROJECTS,
             GITROOT,
+            BRANCHES,
             NAMES,
+            WORKTREES,
             EVENTS,
         ] {
             assert!(path.starts_with(API_PREFIX), "{path} escapes {API_PREFIX}");

crates/maestro-testing/src/lib.rs

@@ -36,6 +36,7 @@ pub fn session(id: Uuid, cwd: &str, command: &str) -> Session {
         command: command.into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
+        worktree: None,
         status: SessionStatus::Running,
         created_at: Utc::now(),
         foreground: None,

crates/maestro-tui/Cargo.toml

@@ -8,12 +8,14 @@ publish.workspace = true
 description = "Terminal UI client over the local maestro daemon's `/api/*` surface."
 
 [dependencies]
+chrono.workspace = true
 clap.workspace = true
 crossterm.workspace = true
 futures-util.workspace = true
 maestro-config.workspace = true
 maestro-protocol = { workspace = true, features = ["client"] }
 ratatui.workspace = true
+reqwest.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["sync", "time", "macros", "rt"] }

crates/maestro-tui/src/action.rs

@@ -39,6 +39,9 @@ pub enum Action {
     AttachHighlighted,
     ToggleAttachHighlighted,
     NewDraftPane,
+    /// Fast-forward spawn (#67): spawn immediately with every default
+    /// resolved; unresolvable defaults open a pre-filled draft instead.
+    FastForwardSpawn,
     KillHighlighted,
 
     // Tabs
@@ -79,6 +82,7 @@ impl Action {
             "AttachHighlighted" => return Ok(Action::AttachHighlighted),
             "ToggleAttachHighlighted" => return Ok(Action::ToggleAttachHighlighted),
             "NewDraftPane" => return Ok(Action::NewDraftPane),
+            "FastForwardSpawn" => return Ok(Action::FastForwardSpawn),
             "KillHighlighted" => return Ok(Action::KillHighlighted),
             "NewTab" => return Ok(Action::NewTab),
             "CloseTab" => return Ok(Action::CloseTab),
@@ -197,6 +201,16 @@ mod tests {
         assert_eq!(err, ActionParseError::Malformed("GotoTab(3".into()));
     }
 
+    /// The fast-forward pair sits next to the draft-pane key (#67).
+    #[test]
+    fn fast_forward_spawn_round_trips() {
+        assert_eq!(
+            Action::parse("FastForwardSpawn").unwrap(),
+            Action::FastForwardSpawn
+        );
+        assert_eq!(Action::FastForwardSpawn.to_string(), "FastForwardSpawn");
+    }
+
     #[test]
     fn display_round_trips() {
         for a in [

crates/maestro-tui/src/app.rs

@@ -12,11 +12,13 @@
 
 use std::collections::{HashMap, HashSet};
 use std::io::Stdout;
+use std::path::PathBuf;
 use std::time::Duration;
 
+use chrono::Utc;
 use crossterm::event::{Event as CtEvent, EventStream};
 use futures_util::StreamExt;
-use maestro_protocol::{CreateSessionRequest, DaemonClient};
+use maestro_protocol::{routes, BranchInfo, CreateSessionRequest, DaemonClient, NameBatch};
 use ratatui::backend::CrosstermBackend;
 use ratatui::Terminal;
 use uuid::Uuid;
@@ -53,6 +55,17 @@ pub struct App {
     help: HelpOverlay,
     chord: ChordState,
     daemon: DaemonClient,
+    /// Results of draft data loads, delivered back to the event loop.
+    ///
+    /// These are network calls — `/api/projects` on a cold cache walks all of
+    /// `$HOME` — and awaiting them inside `perform` froze the whole TUI: no
+    /// keys, no frames, attached panes stalled, for up to the request timeout
+    /// (#67 review). They run as detached tasks and post here instead.
+    draft_tx: tokio::sync::mpsc::UnboundedSender<DraftUpdate>,
+    draft_rx: tokio::sync::mpsc::UnboundedReceiver<DraftUpdate>,
+    /// Direct HTTP for the one endpoint [`DaemonClient`] doesn't cover yet:
+    /// `GET /api/names` (#64).
+    http: reqwest::Client,
     region: RegionMap,
     last_sent_size: HashMap<Uuid, (u16, u16)>,
     clicks: ClickTracker,
@@ -76,15 +89,40 @@ pub enum Effect {
     Attach(Uuid),
     Spawn(CreateSessionRequest),
     Kill(Uuid),
-    Forward { id: Uuid, bytes: Vec<u8> },
+    Forward {
+        id: Uuid,
+        bytes: Vec<u8>,
+    },
+    /// Fetch presets / projects / names for a freshly opened draft (#64).
+    LoadDraft(usize),
+    /// Fast-forward spawn (#67): resolve every default from the daemon and
+    /// spawn with no form; unresolvable defaults open a pre-filled draft.
+    FastForward,
+    /// A reroll drained the draft's local name batch (#64).
+    RefillNames(usize),
+    /// The draft's target changed: probe `/api/gitroot` so the worktree
+    /// section knows its base repo (#65). `seq` guards stale answers.
+    ProbeGitRoot {
+        tab: usize,
+        seq: u32,
+        path: PathBuf,
+    },
+    /// Fetch the draft target's branches from `/api/branches` (#65).
+    LoadBranches(usize),
 }
 
 impl App {
     pub fn new(cfg: TuiConfig, catalog: CatalogStore, daemon: DaemonClient) -> Self {
+        let (draft_tx, draft_rx) = tokio::sync::mpsc::unbounded_channel();
         let chord_timeout = cfg.chord_timeout;
         let help = HelpOverlay {
             lines: render_help_lines(&cfg),
         };
+        let http = reqwest::Client::builder()
+            .connect_timeout(maestro_protocol::client::DEFAULT_CONNECT_TIMEOUT)
+            .timeout(maestro_protocol::client::DEFAULT_REQUEST_TIMEOUT)
+            .build()
+            .expect("build reqwest client");
         Self {
             cfg,
             catalog,
@@ -93,6 +131,9 @@ impl App {
             help,
             chord: ChordState::new(chord_timeout),
             daemon,
+            http,
+            draft_tx,
+            draft_rx,
             region: RegionMap::default(),
             last_sent_size: HashMap::new(),
             clicks: ClickTracker::default(),
@@ -114,6 +155,9 @@ impl App {
                         return Ok(());
                     }
                 }
+                Some(update) = self.draft_rx.recv() => {
+                    self.apply_draft_update(update).await;
+                }
                 _ = self.catalog.changed() => {
                     // Render on next loop iteration.
                 }
@@ -153,15 +197,13 @@ impl App {
                 {
                     // 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(_)))
+                    let effects = if matches!(self.state.active_tab().pane, Some(PaneRef::Draft(_)))
                     {
                         self.handle_draft_input(&key)
                     } else {
-                        self.forward_to_session(&key)
+                        self.forward_to_session(&key).into_iter().collect()
                     };
-                    if let Some(effect) = effect {
-                        self.perform(vec![effect]).await;
-                    }
+                    self.perform(effects).await;
                 }
                 Ok(false)
             }
@@ -176,6 +218,13 @@ impl App {
                 Effect::Attach(id) => self.attach(id),
                 Effect::Spawn(req) => self.submit_spawn(req).await,
                 Effect::Kill(id) => self.submit_kill(id).await,
+                Effect::LoadDraft(tab_idx) => self.spawn_load_draft(tab_idx),
+                Effect::FastForward => self.spawn_fast_forward(),
+                Effect::RefillNames(tab_idx) => self.spawn_refill_names(tab_idx),
+                Effect::ProbeGitRoot { tab, seq, path } => {
+                    self.spawn_probe_git_root(tab, seq, path)
+                }
+                Effect::LoadBranches(tab) => self.spawn_load_branches(tab),
                 Effect::Forward { id, bytes } => {
                     if let Some(handle) = self.emulators.get(id) {
                         let _ = handle.tx.send(SessionInput::Bytes(bytes)).await;
@@ -252,7 +301,11 @@ impl App {
                 };
                 self.state.show_overlay(OverlayKind::Help);
             }
-            Action::NewDraftPane => self.state.open_draft_pane(),
+            Action::NewDraftPane => {
+                self.state.open_draft_pane();
+                effects.push(Effect::LoadDraft(self.state.active_tab_idx));
+            }
+            Action::FastForwardSpawn => effects.push(Effect::FastForward),
             Action::AttachHighlighted | Action::ToggleAttachHighlighted => {
                 if let Some(sid) = self.pick_sidebar_target() {
                     effects.push(Effect::Attach(sid));
@@ -309,21 +362,283 @@ impl App {
     }
 
     /// 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;
+    /// effect when the user accepted a valid form; an invalid one names the
+    /// missing field inside the form (#64) instead of posting.
+    fn handle_draft_input(&mut self, key: &InputKey) -> Vec<Effect> {
+        let tab_idx = self.state.active_tab_idx;
+        let Some(PaneRef::Draft(draft)) = self.state.active_tab_mut().pane.as_mut() else {
+            return Vec::new();
         };
-        if draft.on_input(key) != DraftInputResult::Submit {
-            return None;
+        let mut effects = Vec::new();
+        if draft.on_input(key) == DraftInputResult::Submit {
+            match draft.build_request() {
+                Ok(req) => {
+                    draft.error = None;
+                    effects.push(Effect::Spawn(req));
+                }
+                Err(e) => draft.error = Some(e.to_string()),
+            }
         }
-        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,
-        }))
+        if draft.take_name_refill() {
+            effects.push(Effect::RefillNames(tab_idx));
+        }
+        if let Some((seq, path)) = draft.take_gitroot_probe() {
+            effects.push(Effect::ProbeGitRoot {
+                tab: tab_idx,
+                seq,
+                path,
+            });
+        }
+        if draft.take_branch_load().is_some() {
+            effects.push(Effect::LoadBranches(tab_idx));
+        }
+        effects
+    }
+
+    /// Populate a freshly opened draft: presets from `/api/info` (falling back
+    /// to the built-ins already in place), projects from `/api/projects`, and
+    /// a first name batch. Applies only if that tab still shows the draft —
+    /// a slow response must never clobber what replaced it.
+    /// Kick off the draft's initial data load without blocking the loop.
+    fn spawn_load_draft(&self, tab: usize) {
+        let Some(draft) = self.draft_id(tab) else {
+            return;
+        };
+        let (daemon, http, base, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let (info, projects) = tokio::join!(daemon.daemon_info(), daemon.list_projects());
+            let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await;
+            let _ = tx.send(DraftUpdate::Data {
+                draft,
+                info: info.ok(),
+                projects: projects.ok(),
+                names,
+            });
+        });
+    }
+
+    fn spawn_refill_names(&self, tab: usize) {
+        let Some(draft) = self.draft_id(tab) else {
+            return;
+        };
+        let (_, http, base, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await;
+            let _ = tx.send(DraftUpdate::Names { draft, names });
+        });
+    }
+
+    fn spawn_probe_git_root(&self, tab: usize, seq: u32, path: PathBuf) {
+        let Some(draft) = self.draft_id(tab) else {
+            return;
+        };
+        let (daemon, _, _, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let root = daemon
+                .git_root(&path.to_string_lossy())
+                .await
+                .ok()
+                .and_then(|g| g.root);
+            let _ = tx.send(DraftUpdate::GitRoot { draft, seq, root });
+        });
+    }
+
+    fn spawn_load_branches(&self, tab: usize) {
+        let Some(draft) = self.draft_id(tab) else {
+            return;
+        };
+        let Some(cwd) = self
+            .state
+            .tabs
+            .get(tab)
+            .and_then(|t| t.pane.as_ref())
+            .and_then(|p| match p {
+                PaneRef::Draft(d) => d.cwd(),
+                _ => None,
+            })
+        else {
+            return;
+        };
+        let (_, http, base, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let branches = fetch_branches(&http, &base, &cwd).await;
+            let _ = tx.send(DraftUpdate::Branches {
+                draft,
+                cwd,
+                branches,
+            });
+        });
+    }
+
+    /// The draft pane living in `tab`, by identity.
+    fn draft_id(&self, tab: usize) -> Option<u64> {
+        match self.state.tabs.get(tab).and_then(|t| t.pane.as_ref()) {
+            Some(PaneRef::Draft(d)) => Some(d.id),
+            _ => None,
+        }
+    }
+
+    fn loader_handles(
+        &self,
+    ) -> (
+        DaemonClient,
+        reqwest::Client,
+        String,
+        tokio::sync::mpsc::UnboundedSender<DraftUpdate>,
+    ) {
+        (
+            self.daemon.clone(),
+            self.http.clone(),
+            self.daemon.base().to_string(),
+            self.draft_tx.clone(),
+        )
+    }
+
+    /// Fold a finished background load into the draft that asked for it.
+    async fn apply_draft_update(&mut self, update: DraftUpdate) {
+        if let DraftUpdate::FastForward {
+            info,
+            projects,
+            names,
+        } = update
+        {
+            self.fast_forward_spawn(info, projects, names).await;
+            return;
+        }
+        let want = match &update {
+            DraftUpdate::Data { draft, .. }
+            | DraftUpdate::Names { draft, .. }
+            | DraftUpdate::GitRoot { draft, .. }
+            | DraftUpdate::Branches { draft, .. } => *draft,
+            // Handled above; it targets no particular draft.
+            DraftUpdate::FastForward { .. } => unreachable!(),
+        };
+        // Find it by identity: closing a tab shifts every index to its right,
+        // so an in-flight load addressed by index would be dropped or land on
+        // whatever pane inherited the slot (#67 review).
+        let Some(tab_idx) = self
+            .state
+            .tabs
+            .iter()
+            .position(|t| matches!(&t.pane, Some(PaneRef::Draft(d)) if d.id == want))
+        else {
+            // The draft went away while the request was in flight.
+            return;
+        };
+        let Some(PaneRef::Draft(draft)) = self
+            .state
+            .tabs
+            .get_mut(tab_idx)
+            .and_then(|t| t.pane.as_mut())
+        else {
+            return;
+        };
+        let mut follow_up_branches = false;
+        match update {
+            DraftUpdate::Data {
+                info,
+                projects,
+                names,
+                ..
+            } => {
+                if let Some(info) = info {
+                    draft.home_dir.clone_from(&info.home_dir);
+                    if !info.presets.is_empty() {
+                        draft.set_presets(info.presets);
+                    }
+                }
+                if let Some(projects) = projects {
+                    draft.set_projects(projects, Utc::now());
+                }
+                if !names.is_empty() {
+                    draft.seed_names(names);
+                }
+            }
+            DraftUpdate::Names { names, .. } => {
+                if !names.is_empty() {
+                    draft.extend_names(names);
+                }
+            }
+            DraftUpdate::GitRoot { seq, root, .. } => {
+                draft.resolve_gitroot(seq, root);
+                follow_up_branches = draft.take_branch_load().is_some();
+            }
+            DraftUpdate::Branches { cwd, branches, .. } => {
+                draft.set_branches(&cwd, branches);
+            }
+            DraftUpdate::FastForward { .. } => unreachable!(),
+        }
+        if follow_up_branches {
+            self.spawn_load_branches(tab_idx);
+        }
+    }
+
+    /// Fast-forward spawn (#67): one keystroke, every default resolved, no
+    /// form. The most recent project, its last command (or the first
+    /// non-custom preset), a freshly generated name, worktree on with a new
+    /// branch named after that name. Anything unresolvable — no projects
+    /// known yet, no command, no name — downgrades to a draft pane seeded
+    /// with whatever did resolve.
+    /// Load what the fast path needs without blocking the loop — the same
+    /// reason the draft loaders were moved off it (#67 review): a cold
+    /// `/api/projects` walks all of `$HOME`, and pressing the key must not
+    /// freeze keys, frames and attached panes until it returns.
+    fn spawn_fast_forward(&self) {
+        let (daemon, http, base, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let (info, projects) = tokio::join!(daemon.daemon_info(), daemon.list_projects());
+            let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await;
+            let _ = tx.send(DraftUpdate::FastForward {
+                info: info.ok(),
+                projects: projects.ok(),
+                names,
+            });
+        });
+    }
+
+    async fn fast_forward_spawn(
+        &mut self,
+        info: Option<maestro_protocol::DaemonInfo>,
+        projects: Option<Vec<maestro_protocol::Project>>,
+        names: Vec<String>,
+    ) {
+        // Keep the home dir: without it the pre-filled draft renders
+        // unabbreviated paths and "Other directory…" seeds `/` instead of
+        // home, so the two draft entry points disagreed (#67 review).
+        let home_dir = info
+            .as_ref()
+            .map(|i| i.home_dir.clone())
+            .unwrap_or_default();
+        let presets = match info {
+            Some(info) if !info.presets.is_empty() => info.presets,
+            _ => Vec::new(),
+        };
+        let discovered = projects.unwrap_or_default();
+        let resolved =
+            crate::fast_forward::resolve(&discovered, &presets, names.first().cloned(), Utc::now());
+        if let Some(req) = resolved.build_request() {
+            // Never eat a pane already showing something: the spawn takes a
+            // fresh tab, same as opening a draft over a session would.
+            if self.state.active_tab().pane.is_some() {
+                self.state.new_tab();
+            }
+            self.submit_spawn(req).await;
+            return;
+        }
+        // Unresolved defaults: a draft pre-filled with what did resolve.
+        self.state.open_draft_pane();
+        let Some(PaneRef::Draft(draft)) = self.state.active_tab_mut().pane.as_mut() else {
+            return;
+        };
+        draft.home_dir = home_dir;
+        if !presets.is_empty() {
+            draft.set_presets(presets);
+        }
+        draft.set_projects(discovered, Utc::now());
+        resolved.apply_to_draft(draft);
+        // A missing generated name still arrives here; seeding is a no-op
+        // once apply_to_draft has set a touched name.
+        draft.seed_names(names);
     }
 
     async fn submit_spawn(&mut self, req: CreateSessionRequest) {
@@ -335,7 +650,19 @@ impl App {
                 self.state.complete_spawn(sid);
                 self.attach(sid);
             }
-            Err(e) => self.state.toast(format!("spawn failed: {e}")),
+            Err(e) => {
+                // A failed POST belongs in the form it came from (#64), not a
+                // toast that dismisses on the next keystroke.
+                let message = e
+                    .daemon_message()
+                    .map(String::from)
+                    .unwrap_or_else(|| e.to_string());
+                if let Some(PaneRef::Draft(draft)) = self.state.active_tab_mut().pane.as_mut() {
+                    draft.error = Some(format!("spawn failed: {message}"));
+                } else {
+                    self.state.toast(format!("spawn failed: {e}"));
+                }
+            }
         }
     }
 
@@ -501,20 +828,97 @@ fn render_help_lines(cfg: &TuiConfig) -> Vec<String> {
     lines
 }
 
+/// A completed background load, applied on the event loop.
+#[derive(Debug)]
+enum DraftUpdate {
+    Data {
+        draft: u64,
+        info: Option<maestro_protocol::DaemonInfo>,
+        projects: Option<Vec<maestro_protocol::Project>>,
+        names: Vec<String>,
+    },
+    Names {
+        draft: u64,
+        names: Vec<String>,
+    },
+    GitRoot {
+        draft: u64,
+        seq: u32,
+        root: Option<PathBuf>,
+    },
+    Branches {
+        draft: u64,
+        cwd: PathBuf,
+        branches: Vec<BranchInfo>,
+    },
+    /// A fast-forward's data arrived; resolution and spawn happen on the loop.
+    FastForward {
+        info: Option<maestro_protocol::DaemonInfo>,
+        projects: Option<Vec<maestro_protocol::Project>>,
+        names: Vec<String>,
+    },
+}
+
+/// `GET /api/names?count=N`. Free function: the spawned loaders have no `self`.
+async fn fetch_names(http: &reqwest::Client, base: &str, count: usize) -> Vec<String> {
+    let url = format!(
+        "{}{}",
+        maestro_protocol::routes::normalize_base(base),
+        routes::NAMES
+    );
+    match http
+        .get(url)
+        .query(&[(routes::COUNT_QUERY, count)])
+        .send()
+        .await
+    {
+        Ok(resp) => resp
+            .json::<NameBatch>()
+            .await
+            .map(|batch| batch.names)
+            .unwrap_or_default(),
+        Err(_) => Vec::new(),
+    }
+}
+
+/// `GET /api/branches?path=`. On failure the picker stays empty and "new
+/// branch" mode still works.
+async fn fetch_branches(
+    http: &reqwest::Client,
+    base: &str,
+    path: &std::path::Path,
+) -> Vec<BranchInfo> {
+    let url = format!(
+        "{}{}",
+        maestro_protocol::routes::normalize_base(base),
+        routes::BRANCHES
+    );
+    match http
+        .get(url)
+        .query(&[(routes::PATH_QUERY, path.to_string_lossy().as_ref())])
+        .send()
+        .await
+    {
+        Ok(resp) => resp.json::<Vec<BranchInfo>>().await.unwrap_or_default(),
+        Err(_) => Vec::new(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::action::Action;
+    use crate::draft::DraftField;
     use crate::keymap::Mode;
     use maestro_config::TuiSection;
 
     fn make_app() -> App {
+        make_app_at("http://127.0.0.1:7070")
+    }
+
+    fn make_app_at(base: &str) -> App {
         let cfg = TuiConfig::load(&TuiSection::default()).unwrap();
-        App::new(
-            cfg,
-            CatalogStore::default(),
-            DaemonClient::new("http://127.0.0.1:7070"),
-        )
+        App::new(cfg, CatalogStore::default(), DaemonClient::new(base))
     }
 
     #[test]
@@ -586,6 +990,7 @@ mod tests {
                 cwd: std::path::PathBuf::from("/"),
                 env: Default::default(),
                 metadata: Default::default(),
+                worktree: None,
                 status: SessionStatus::Running,
                 created_at: Utc::now(),
                 foreground: None,
@@ -638,34 +1043,383 @@ mod tests {
         assert!(app.state.overlay().is_none());
     }
 
+    #[test]
+    fn new_draft_pane_schedules_a_data_load() {
+        let mut app = make_app();
+        assert_eq!(
+            app.dispatch(Action::NewDraftPane),
+            vec![Effect::LoadDraft(0)]
+        );
+    }
+
+    /// The fast-forward keystroke itself is side-effect-free until its
+    /// daemon fetches come back.
+    #[test]
+    fn fast_forward_spawn_dispatches_the_fast_forward_effect() {
+        let mut app = make_app();
+        assert_eq!(
+            app.dispatch(Action::FastForwardSpawn),
+            vec![Effect::FastForward]
+        );
+    }
+
+    /// Every default resolves: the POST goes straight out — most recent
+    /// project, its last command, generated name, worktree branch named
+    /// after it (#67).
+    #[tokio::test]
+    async fn fast_forward_spawns_immediately_when_every_default_resolves() {
+        use axum::routing::{get, post};
+        use axum::Json;
+        use serde_json::json;
+        use std::sync::{Arc, Mutex};
+
+        async fn info() -> Json<serde_json::Value> {
+            Json(json!({
+                "hostname": "box", "version": "0.1.0", "home_dir": "/home/u",
+                "presets": [{"id": "claude", "label": "Claude", "command": "claude"}]
+            }))
+        }
+        async fn projects() -> Json<serde_json::Value> {
+            Json(json!([
+                {"path": "/repos/old", "name": "old",
+                 "last_activity": chrono::Utc::now().to_rfc3339(), "last_command": "zsh"},
+                {"path": "/repos/fresh", "name": "fresh", "base_repo": "/repos/fresh",
+                 "last_activity": chrono::Utc::now().to_rfc3339(), "last_command": "aider"}
+            ]))
+        }
+        async fn names() -> Json<serde_json::Value> {
+            Json(json!({"names": ["crimson-otter"]}))
+        }
+        let posted: Arc<Mutex<Vec<serde_json::Value>>> = Arc::default();
+        let seen = posted.clone();
+        async fn spawn_session(
+            axum::extract::State(seen): axum::extract::State<Arc<Mutex<Vec<serde_json::Value>>>>,
+            Json(body): Json<serde_json::Value>,
+        ) -> Json<serde_json::Value> {
+            seen.lock().unwrap().push(body);
+            Json(json!({
+                "id": uuid::Uuid::from_u128(77).to_string(),
+                "cwd": "/repos/fresh", "command": "aider",
+                "status": "Running", "created_at": chrono::Utc::now().to_rfc3339()
+            }))
+        }
+
+        let app_router = axum::Router::new()
+            .route(maestro_protocol::routes::INFO, get(info))
+            .route(maestro_protocol::routes::PROJECTS, get(projects))
+            .route(maestro_protocol::routes::NAMES, get(names))
+            .route(
+                maestro_protocol::routes::SESSIONS,
+                post(spawn_session).with_state(seen),
+            );
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let base = format!("http://{}", listener.local_addr().unwrap());
+        tokio::spawn(async move { axum::serve(listener, app_router).await.unwrap() });
+
+        let mut app = make_app_at(&base);
+        let effects = app.dispatch(Action::FastForwardSpawn);
+        // The fast path loads off the event loop now; the run loop drains the
+        // channel, so do that by hand.
+        app.perform(effects).await;
+        let update = tokio::time::timeout(Duration::from_secs(5), app.draft_rx.recv())
+            .await
+            .expect("load completed")
+            .expect("channel open");
+        app.apply_draft_update(update).await;
+
+        let posts = posted.lock().unwrap();
+        assert_eq!(posts.len(), 1, "one immediate POST, no form shown");
+        let req = &posts[0];
+        assert_eq!(req["cwd"], json!("/repos/fresh"));
+        assert_eq!(req["command"], json!("aider"));
+        assert_eq!(req["metadata"]["name"], json!("crimson-otter"));
+        assert_eq!(req["worktree"]["base_repo"], json!("/repos/fresh"));
+        assert_eq!(req["worktree"]["branch"], json!("crimson-otter"));
+        assert_eq!(req["worktree"]["create_branch"], json!(true));
+    }
+
+    /// No projects known yet: nothing can resolve, so the keystroke opens a
+    /// draft pane (focused, Insert mode) instead of guessing (#67).
+    #[tokio::test]
+    async fn unresolvable_defaults_open_a_prefilled_draft_instead() {
+        use axum::routing::get;
+        use axum::Json;
+        use serde_json::json;
+
+        async fn info() -> Json<serde_json::Value> {
+            Json(json!({
+                "hostname": "box", "version": "0.1.0", "home_dir": "/home/u",
+                "presets": [{"id": "claude", "label": "Claude", "command": "claude"}]
+            }))
+        }
+        async fn projects() -> Json<serde_json::Value> {
+            Json(json!([]))
+        }
+        async fn names() -> Json<serde_json::Value> {
+            Json(json!({"names": ["amber-falcon"]}))
+        }
+
+        let app_router = axum::Router::new()
+            .route(maestro_protocol::routes::INFO, get(info))
+            .route(maestro_protocol::routes::PROJECTS, get(projects))
+            .route(maestro_protocol::routes::NAMES, get(names));
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let base = format!("http://{}", listener.local_addr().unwrap());
+        tokio::spawn(async move { axum::serve(listener, app_router).await.unwrap() });
+
+        let mut app = make_app_at(&base);
+        let effects = app.dispatch(Action::FastForwardSpawn);
+        // The fast path loads off the event loop now; the run loop drains the
+        // channel, so do that by hand.
+        app.perform(effects).await;
+        let update = tokio::time::timeout(Duration::from_secs(5), app.draft_rx.recv())
+            .await
+            .expect("load completed")
+            .expect("channel open");
+        app.apply_draft_update(update).await;
+
+        assert!(
+            matches!(app.state.active_tab().pane, Some(PaneRef::Draft(_))),
+            "the fallback is a draft pane"
+        );
+        assert_eq!(app.state.focus, Focus::Pane);
+        assert_eq!(app.state.mode, Mode::Insert);
+        let PaneRef::Draft(draft) = app.state.active_tab().pane.as_ref().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        // Whatever did resolve (nothing project-side) is seeded; the
+        // generated name still lands so the form is ready to go.
+        assert_eq!(draft.name.value(), "amber-falcon");
+        assert_eq!(draft.command(), "claude");
+    }
+
+    /// A valid form flows through: pick a project (set directly — the picker
+    /// itself is covered in `draft.rs`), select the custom tile, type a
+    /// command, then submit from the Spawn row.
     #[test]
     fn typing_into_the_draft_then_enter_carries_the_typed_fields() {
         let mut app = make_app();
         app.dispatch(Action::NewDraftPane);
+        let PaneRef::Draft(draft) = app.state.active_tab_mut().pane.as_mut().unwrap() else {
+            panic!("expected a draft pane");
+        };
 
-        for c in "/srv/work".chars() {
-            app.handle_draft_input(&InputKey::char(c));
-        }
-        app.handle_draft_input(&InputKey::Tab); // cwd → command
+        draft.picked_cwd = Some(std::path::PathBuf::from("/srv/work"));
+        draft.base_repo = Some(std::path::PathBuf::from("/srv/work"));
+        draft.probed_cwd = Some(std::path::PathBuf::from("/srv/work"));
+        draft.selected_preset = draft.presets.len() - 1; // custom
+        app.handle_draft_input(&InputKey::Tab); // preset → custom command
         for c in "claude".chars() {
             app.handle_draft_input(&InputKey::char(c));
         }
-        app.handle_draft_input(&InputKey::Tab); // command → submit
+        app.handle_draft_input(&InputKey::Tab); // → dir picker
+        app.handle_draft_input(&InputKey::Tab); // → name
+        for c in "crimson-otter".chars() {
+            app.handle_draft_input(&InputKey::char(c));
+        }
+        app.handle_draft_input(&InputKey::Tab); // → worktree toggle
+        app.handle_draft_input(&InputKey::Tab); // → branch mode
+        app.handle_draft_input(&InputKey::Tab); // → new-branch name
+        app.handle_draft_input(&InputKey::Tab); // → submit
 
-        match app.handle_draft_input(&InputKey::Enter) {
-            Some(Effect::Spawn(req)) => {
+        match app.handle_draft_input(&InputKey::Enter).as_slice() {
+            [Effect::Spawn(req)] => {
                 assert_eq!(req.cwd, std::path::PathBuf::from("/srv/work"));
                 assert_eq!(req.command, "claude");
+                assert_eq!(
+                    req.metadata.get("name").and_then(|v| v.as_str()),
+                    Some("crimson-otter"),
+                    "the generated name rides along as metadata.name"
+                );
             }
-            other => panic!("expected a Spawn effect, got {other:?}"),
+            other => panic!("expected a single Spawn effect, got {other:?}"),
         }
     }
 
+    /// Editing the raw path with the worktree toggle on schedules a
+    /// `/api/gitroot` probe so the section learns its base repo (#65).
+    #[test]
+    fn typing_a_raw_path_schedules_a_gitroot_probe() {
+        let mut app = make_app();
+        app.dispatch(Action::NewDraftPane);
+        let PaneRef::Draft(draft) = app.state.active_tab_mut().pane.as_mut().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        draft.cwd_raw_visible = true;
+        draft.focused_field = DraftField::CwdRaw;
+
+        let effects = app.handle_draft_input(&InputKey::char('/'));
+        assert!(
+            matches!(
+                effects.as_slice(),
+                [Effect::ProbeGitRoot { tab: 0, seq: 2, .. }]
+            ),
+            "{effects:?}"
+        );
+    }
+
+    /// Switching the worktree branch source to Existing schedules one
+    /// `/api/branches` load for the current target (#65).
+    #[test]
+    fn switching_to_existing_branch_mode_schedules_a_branch_load() {
+        let mut app = make_app();
+        app.dispatch(Action::NewDraftPane);
+        let PaneRef::Draft(draft) = app.state.active_tab_mut().pane.as_mut().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        draft.picked_cwd = Some(std::path::PathBuf::from("/srv/repo"));
+        draft.base_repo = Some(std::path::PathBuf::from("/srv/repo"));
+        draft.probed_cwd = Some(std::path::PathBuf::from("/srv/repo"));
+        draft.focused_field = DraftField::BranchMode;
+
+        let effects = app.handle_draft_input(&InputKey::Right);
+        assert!(
+            matches!(effects.as_slice(), [Effect::LoadBranches(0)]),
+            "{effects:?}"
+        );
+    }
+
+    /// Submitting with no directory names the missing field inside the form
+    /// and posts nothing (#64).
+    #[test]
+    fn submitting_an_empty_form_reports_the_missing_field_instead_of_posting() {
+        let mut app = make_app();
+        app.dispatch(Action::NewDraftPane);
+        // Walk to Submit without picking anything.
+        for _ in 0..4 {
+            app.handle_draft_input(&InputKey::Tab);
+        }
+        assert!(app.handle_draft_input(&InputKey::Enter).is_empty());
+        let PaneRef::Draft(draft) = app.state.active_tab().pane.as_ref().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        assert_eq!(
+            draft.error.as_deref(),
+            Some("Pick a working directory."),
+            "the refusal shows in the form"
+        );
+
+        // With a directory but an empty custom command, it names the command.
+        let PaneRef::Draft(draft) = app.state.active_tab_mut().pane.as_mut().unwrap() else {
+            panic!();
+        };
+        draft.picked_cwd = Some(std::path::PathBuf::from("/srv/work"));
+        draft.selected_preset = draft.presets.len() - 1; // custom, empty text
+        assert!(app.handle_draft_input(&InputKey::Enter).is_empty());
+        let PaneRef::Draft(draft) = app.state.active_tab().pane.as_ref().unwrap() else {
+            panic!();
+        };
+        assert_eq!(
+            draft.error.as_deref(),
+            Some("Pick a command (or fill the custom command).")
+        );
+    }
+
+    /// A failed POST lands back in the form as an error line (#64), not a
+    /// toast that the next keystroke dismisses.
+    #[tokio::test]
+    async fn a_failed_spawn_shows_the_daemons_error_in_the_form() {
+        use std::time::Duration;
+        let mut app = App::new(
+            TuiConfig::load(&TuiSection::default()).unwrap(),
+            CatalogStore::default(),
+            DaemonClient::with_timeouts(
+                "http://127.0.0.1:9",
+                Duration::from_millis(200),
+                Duration::from_millis(500),
+            ),
+        );
+        app.dispatch(Action::NewDraftPane);
+        let req = CreateSessionRequest {
+            cwd: std::path::PathBuf::from("/srv/work"),
+            command: "bash".into(),
+            env: Default::default(),
+            metadata: Default::default(),
+            worktree: None,
+        };
+        app.submit_spawn(req).await;
+
+        let PaneRef::Draft(draft) = app.state.active_tab().pane.as_ref().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        let error = draft
+            .error
+            .as_deref()
+            .expect("spawn failure must reach the form");
+        assert!(error.starts_with("spawn failed"), "{error}");
+        assert!(
+            matches!(app.state.overlay(), None | Some(OverlayKind::Toast(_))),
+            "no kill-confirm style overlay took over"
+        );
+    }
+
+    /// The full data load against a live daemon stub: presets replace the
+    /// built-ins, projects land sorted, and the first generated name seeds
+    /// the field.
+    #[tokio::test]
+    async fn load_draft_data_fills_presets_projects_and_names() {
+        use axum::routing::get;
+        use axum::Json;
+        use serde_json::json;
+
+        async fn info() -> Json<serde_json::Value> {
+            Json(json!({
+                "hostname": "box",
+                "version": "0.1.0",
+                "home_dir": "/home/u",
+                "presets": [
+                    {"id": "aider", "label": "Aider", "command": "aider"},
+                    {"id": "custom", "label": "Custom…", "command": ""}
+                ]
+            }))
+        }
+        async fn projects() -> Json<serde_json::Value> {
+            Json(json!([
+                {"path": "/repos/maestro", "name": "maestro",
+                 "last_activity": chrono::Utc::now().to_rfc3339(),
+                 "last_command": "claude"}
+            ]))
+        }
+        async fn names() -> Json<serde_json::Value> {
+            Json(json!({"names": ["crimson-otter", "amber-falcon"]}))
+        }
+
+        let app_router = axum::Router::new()
+            .route(maestro_protocol::routes::INFO, get(info))
+            .route(maestro_protocol::routes::PROJECTS, get(projects))
+            .route(maestro_protocol::routes::NAMES, get(names));
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let base = format!("http://{}", listener.local_addr().unwrap());
+        tokio::spawn(async move { axum::serve(listener, app_router).await.unwrap() });
+
+        let mut app = make_app_at(&base);
+        let effects = app.dispatch(Action::NewDraftPane);
+        assert!(matches!(effects.as_slice(), [Effect::LoadDraft(0)]));
+        // `perform` only spawns the load — it must not block the event loop on
+        // the network (#67 review). The result arrives on the draft channel,
+        // which the run loop drains; do that by hand here.
+        app.perform(effects).await;
+        let update = tokio::time::timeout(Duration::from_secs(5), app.draft_rx.recv())
+            .await
+            .expect("load completed")
+            .expect("channel open");
+        app.apply_draft_update(update).await;
+
+        let PaneRef::Draft(draft) = app.state.active_tab().pane.as_ref().unwrap() else {
+            panic!("expected a draft pane");
+        };
+        assert_eq!(draft.command(), "aider");
+        assert_eq!(draft.rows.len(), 1);
+        assert_eq!(draft.rows[0].project.name, "maestro");
+        assert_eq!(draft.home_dir, "/home/u");
+        assert_eq!(draft.name.value(), "crimson-otter");
+    }
+
     /// 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());
+        assert!(app.handle_draft_input(&InputKey::char('x')).is_empty());
     }
 
     /// Regression: `Toast` returned `Pass` and nothing ever cleared it, so a
@@ -742,6 +1496,7 @@ mod tests {
                 cwd: std::path::PathBuf::from("/"),
                 env: Default::default(),
                 metadata: Default::default(),
+                worktree: None,
                 status: SessionStatus::Running,
                 created_at: Utc::now(),
                 foreground: None,

crates/maestro-tui/src/catalog.rs

@@ -188,6 +188,7 @@ mod tests {
             cwd: std::path::PathBuf::from("/tmp"),
             env: Default::default(),
             metadata: Default::default(),
+            worktree: None,
             status: SessionStatus::Running,
             created_at: Utc::now(),
             foreground: None,

crates/maestro-tui/src/config.rs

@@ -46,6 +46,9 @@ const DEFAULT_NORMAL: &[(&str, &str)] = &[
     // Catalog actions
     ("enter", "AttachHighlighted"),
     ("s", "NewDraftPane"),
+    // Fast-forward spawn (#67): the draft-pane key's neighbour does the same
+    // thing with every default resolved and no form.
+    ("S", "FastForwardSpawn"),
     ("x", "KillHighlighted"),
     // Tabs
     ("ctrl-t", "NewTab"),
@@ -159,6 +162,10 @@ mod tests {
             cfg.keymap.resolve(Mode::Normal, "s"),
             Some(Action::NewDraftPane),
         );
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Normal, "S"),
+            Some(Action::FastForwardSpawn),
+        );
     }
 
     #[test]

crates/maestro-tui/src/fast_forward.rs

@@ -0,0 +1,283 @@
+//! Fast-forward spawn (#67): one keystroke, every default resolved, no form.
+//!
+//! The defaults mirror what a draft pane would settle on after the operator
+//! picked the most recent project and kept their hands off everything else:
+//! its last command (or the first non-custom preset), a freshly generated
+//! name, and a worktree with a branch named after that name. Any default
+//! that cannot be resolved — no projects yet, no command, no generated
+//! name — downgrades the keystroke to a draft pane pre-filled with whatever
+//! did resolve ([`FastForwardDefaults::apply_to_draft`]).
+
+use std::path::PathBuf;
+
+use chrono::{DateTime, Utc};
+use maestro_protocol::{CreateSessionRequest, Project, SpawnPreset, WorktreeSpec};
+
+use crate::draft::DraftPane;
+
+/// What one fast-forward keystroke resolved. Every field optional: `None`
+/// anywhere means "open a draft instead of spawning".
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FastForwardDefaults {
+    pub project: Option<Project>,
+    pub command: Option<String>,
+    pub name: Option<String>,
+}
+
+/// Resolve the fast-forward defaults from the daemon's answers. `name` is
+/// `None` when `/api/names` yielded nothing; `presets` may be empty (the
+/// caller falls back to the built-ins it already has).
+pub fn resolve(
+    projects: &[Project],
+    presets: &[SpawnPreset],
+    name: Option<String>,
+    now: DateTime<Utc>,
+) -> FastForwardDefaults {
+    let project = crate::projects::sort_projects(projects.to_vec(), now)
+        .into_iter()
+        .next();
+    let command = project
+        .as_ref()
+        .and_then(|p| p.last_command.clone())
+        .filter(|c| !c.trim().is_empty())
+        .or_else(|| {
+            presets
+                .iter()
+                .find(|p| !p.command.is_empty())
+                .map(|p| p.command.clone())
+        });
+    FastForwardDefaults {
+        project,
+        command,
+        name,
+    }
+}
+
+impl FastForwardDefaults {
+    /// The spawn request when *every* default resolved: worktree on, new
+    /// branch named after the generated session name, base repo from the
+    /// scan (`None` means the project is itself a main checkout).
+    pub fn build_request(&self) -> Option<CreateSessionRequest> {
+        let project = self.project.as_ref()?;
+        let command = self.command.as_deref()?.trim();
+        let name = self.name.as_deref()?;
+        if command.is_empty() || name.is_empty() {
+            return None;
+        }
+        let mut metadata = std::collections::HashMap::new();
+        metadata.insert(
+            "name".to_string(),
+            serde_json::Value::String(name.to_string()),
+        );
+        Some(CreateSessionRequest {
+            cwd: project.path.clone(),
+            command: command.to_string(),
+            env: Default::default(),
+            metadata,
+            worktree: Some(WorktreeSpec {
+                base_repo: project
+                    .base_repo
+                    .clone()
+                    .unwrap_or_else(|| project.path.clone()),
+                branch: name.to_string(),
+                cleanup_on_kill: true,
+                create_branch: true,
+            }),
+        })
+    }
+
+    /// Seed a fresh draft pane with whatever did resolve — the fallback when
+    /// [`Self::build_request`] is `None`. The operator fills in the rest.
+    pub fn apply_to_draft(&self, draft: &mut DraftPane) {
+        if let Some(project) = &self.project {
+            draft.picked_cwd = Some(PathBuf::from(&project.path));
+            // The scan already knows this directory's repo (#61): no probe
+            // round trip needed, exactly like picking the row by hand.
+            draft.base_repo = Some(
+                project
+                    .base_repo
+                    .clone()
+                    .unwrap_or_else(|| project.path.clone()),
+            );
+            draft.probed_cwd = Some(PathBuf::from(&project.path));
+        }
+        if let Some(command) = &self.command {
+            if let Some(idx) = draft.presets.iter().position(|p| &p.command == command) {
+                draft.selected_preset = idx;
+            } else if !command.trim().is_empty() {
+                // A last_command no preset advertises lands in custom free text.
+                draft.selected_preset = draft.presets.len().saturating_sub(1);
+                draft.custom_command = crate::text_input::TextInput::with_value(command);
+            }
+        }
+        if let Some(name) = &self.name {
+            draft.set_name(name.clone());
+            // Seeded, not generated: a later refill must not clobber it.
+            draft.name_touched = true;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::TimeDelta;
+
+    fn project(path: &str, days_ago: i64, cmd: Option<&str>) -> Project {
+        Project {
+            path: PathBuf::from(path),
+            name: path.rsplit('/').next().unwrap_or(path).into(),
+            is_worktree: false,
+            base_repo: None,
+            last_activity: Some(Utc::now() - TimeDelta::days(days_ago)),
+            last_command: cmd.map(String::from),
+        }
+    }
+
+    fn repo_project(path: &str, base: &str, days_ago: i64, cmd: Option<&str>) -> Project {
+        Project {
+            base_repo: Some(PathBuf::from(base)),
+            ..project(path, days_ago, cmd)
+        }
+    }
+
+    fn preset(id: &str, command: &str) -> SpawnPreset {
+        SpawnPreset {
+            id: id.into(),
+            label: id.into(),
+            command: command.into(),
+        }
+    }
+
+    #[test]
+    fn resolves_every_default_from_the_most_recent_project() {
+        let projects = vec![
+            project("/repos/old", 30, Some("zsh")),
+            repo_project("/repos/fresh", "/repos/fresh", 0, Some("claude")),
+        ];
+        let presets = vec![preset("aider", "aider"), preset("custom", "")];
+        let r = resolve(&projects, &presets, Some("amber-falcon".into()), Utc::now());
+        assert_eq!(
+            r.project.as_ref().unwrap().path,
+            PathBuf::from("/repos/fresh")
+        );
+        assert_eq!(r.command.as_deref(), Some("claude"));
+        assert_eq!(r.name.as_deref(), Some("amber-falcon"));
+
+        let req = r.build_request().expect("all defaults resolved");
+        assert_eq!(req.cwd, PathBuf::from("/repos/fresh"));
+        assert_eq!(req.command, "claude");
+        assert_eq!(
+            req.metadata.get("name").and_then(|v| v.as_str()),
+            Some("amber-falcon")
+        );
+        let wt = req.worktree.expect("worktree on");
+        assert_eq!(wt.base_repo, PathBuf::from("/repos/fresh"));
+        assert_eq!(wt.branch, "amber-falcon");
+        assert!(wt.create_branch, "fresh branch named after the session");
+    }
+
+    #[test]
+    fn worktree_of_the_most_recent_project_targets_its_base_repo() {
+        let projects = vec![repo_project("/repos/main/wt-x", "/repos/main", 0, None)];
+        let r = resolve(
+            &projects,
+            &[preset("zsh", "zsh")],
+            Some("s".into()),
+            Utc::now(),
+        );
+        let wt = r.build_request().unwrap().worktree.unwrap();
+        assert_eq!(wt.base_repo, PathBuf::from("/repos/main"));
+    }
+
+    #[test]
+    fn missing_last_command_falls_back_to_the_first_non_custom_preset() {
+        let projects = vec![project("/repos/p", 0, None)];
+        let presets = vec![preset("custom", ""), preset("claude", "claude")];
+        let r = resolve(&projects, &presets, Some("n".into()), Utc::now());
+        assert_eq!(r.command.as_deref(), Some("claude"));
+    }
+
+    #[test]
+    fn an_empty_last_command_is_no_command_at_all() {
+        let projects = vec![project("/repos/p", 0, Some(""))];
+        let presets = vec![preset("custom", "")];
+        let r = resolve(&projects, &presets, Some("n".into()), Utc::now());
+        assert_eq!(r.command, None);
+        assert!(r.build_request().is_none());
+    }
+
+    #[test]
+    fn nothing_resolves_when_no_projects_are_known_yet() {
+        let r = resolve(
+            &[],
+            &[preset("claude", "claude")],
+            Some("n".into()),
+            Utc::now(),
+        );
+        assert_eq!(r.project, None);
+        // No project → no directory → no request, even with command + name.
+        assert!(r.build_request().is_none());
+    }
+
+    #[test]
+    fn a_missing_generated_name_downgrades_to_a_draft() {
+        let projects = vec![project("/repos/p", 0, Some("claude"))];
+        let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now());
+        assert!(r.build_request().is_none(), "no name → no immediate spawn");
+    }
+
+    #[test]
+    fn unresolvable_defaults_still_seed_the_draft_with_what_resolved() {
+        let projects = vec![repo_project("/repos/p", "/repos/p", 0, Some("aider"))];
+        let r = resolve(&projects, &[preset("aider", "aider")], None, Utc::now());
+
+        let mut draft = DraftPane::default();
+        r.apply_to_draft(&mut draft);
+        assert_eq!(draft.cwd(), Some(PathBuf::from("/repos/p")));
+        assert_eq!(draft.base_repo, Some(PathBuf::from("/repos/p")));
+        assert_eq!(draft.command(), "aider");
+        assert!(
+            draft.name.value().is_empty(),
+            "nothing to seed the name with"
+        );
+        assert!(draft.worktree_enabled);
+    }
+
+    #[test]
+    fn a_resolved_name_survives_late_refills_and_tracks_the_branch() {
+        let projects = vec![project("/repos/p", 0, Some("claude"))];
+        let named = resolve(
+            &projects,
+            &[preset("claude", "claude")],
+            Some("amber-falcon".into()),
+            Utc::now(),
+        );
+        let mut draft = DraftPane::default();
+        named.apply_to_draft(&mut draft);
+        // A later batch must not overwrite the name the spawn was seeded with.
+        draft.seed_names(vec!["late-name".into()]);
+        assert_eq!(draft.name.value(), "amber-falcon");
+        assert_eq!(draft.branch.value(), "amber-falcon");
+    }
+
+    #[test]
+    fn an_unresolved_name_still_gets_generated_by_a_later_batch() {
+        let projects = vec![project("/repos/p", 0, Some("claude"))];
+        let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now());
+        let mut draft = DraftPane::default();
+        r.apply_to_draft(&mut draft);
+        draft.seed_names(vec!["late-name".into()]);
+        assert_eq!(draft.name.value(), "late-name");
+    }
+
+    #[test]
+    fn a_last_command_no_preset_advertises_lands_in_custom_text() {
+        let projects = vec![project("/repos/p", 0, Some("nvim -d"))];
+        let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now());
+        let mut draft = DraftPane::default();
+        r.apply_to_draft(&mut draft);
+        assert_eq!(draft.command(), "nvim -d");
+        assert!(draft.is_custom());
+    }
+}

crates/maestro-tui/src/lib.rs

@@ -9,10 +9,12 @@ pub mod cli;
 pub mod config;
 pub mod draft;
 pub mod emulators;
+pub mod fast_forward;
 pub mod input;
 pub mod keymap;
 pub mod overlays;
 pub mod pane;
+pub mod projects;
 pub mod render;
 pub mod session_task;
 pub mod sidebar;

crates/maestro-tui/src/projects.rs

@@ -0,0 +1,216 @@
+//! Pure helpers behind the draft pane's project picker (#64): staleness,
+//! recency ordering, worktree grouping, and free-text filtering. Mirrors
+//! `web/src/projectList.ts` so both clients order and dim identically — the
+//! daemon reports the timestamps; what "stale" means is a client decision
+//! (#54).
+
+use chrono::{DateTime, TimeDelta, Utc};
+use maestro_protocol::Project;
+
+/// Projects whose last activity is older than this are dimmed and sort after
+/// fresh ones — still reachable, visibly stale.
+pub const STALE_AFTER_DAYS: i64 = 7;
+
+/// True when a project has no usable activity timestamp, one in the future,
+/// or its last activity is older than [`STALE_AFTER_DAYS`] days.
+pub fn is_stale(project: &Project, now: DateTime<Utc>) -> bool {
+    match project.last_activity {
+        None => true,
+        Some(t) => {
+            let age = now.signed_duration_since(t);
+            age < TimeDelta::zero() || age > TimeDelta::days(STALE_AFTER_DAYS)
+        }
+    }
+}
+
+fn time_of(project: &Project) -> DateTime<Utc> {
+    project.last_activity.unwrap_or(DateTime::UNIX_EPOCH)
+}
+
+/// Fresh projects first, each block newest-activity-first; unknown or future
+/// timestamps sort as stalest. Ties fall back to name, then path, so the
+/// order is stable.
+pub fn sort_projects(mut projects: Vec<Project>, now: DateTime<Utc>) -> Vec<Project> {
+    projects.sort_by(|a, b| {
+        let stale = is_stale(a, now).cmp(&is_stale(b, now));
+        stale
+            .then_with(|| time_of(b).cmp(&time_of(a)))
+            .then_with(|| a.name.cmp(&b.name))
+            .then_with(|| a.path.cmp(&b.path))
+    });
+    projects
+}
+
+/// Substring filter over project name and full path, case-insensitive.
+pub fn matches_filter(project: &Project, query: &str) -> bool {
+    let q = query.trim().to_lowercase();
+    if q.is_empty() {
+        return true;
+    }
+    project.name.to_lowercase().contains(&q)
+        || project.path.to_string_lossy().to_lowercase().contains(&q)
+}
+
+/// One repository group: the main checkout followed by its linked worktrees.
+/// A group's position follows its freshest member, since a worktree worked on
+/// today should pull its (dormant) base repo up with it.
+#[derive(Debug)]
+pub struct ProjectGroup<'a> {
+    pub main: &'a Project,
+    pub worktrees: Vec<&'a Project>,
+}
+
+/// Group `sorted` projects by their base repository. A worktree nests under
+/// its main checkout even when the main sorts later; a main checkout missing
+/// from the list doesn't drop its worktrees.
+pub fn group_projects(sorted: &[Project]) -> Vec<ProjectGroup<'_>> {
+    let mut members: Vec<(String, Vec<&Project>)> = Vec::new();
+    for p in sorted {
+        let key = p
+            .base_repo
+            .as_ref()
+            .unwrap_or(&p.path)
+            .to_string_lossy()
+            .into_owned();
+        match members.iter_mut().find(|(k, _)| *k == key) {
+            Some((_, list)) => list.push(p),
+            None => members.push((key, vec![p])),
+        }
+    }
+    members
+        .into_iter()
+        .map(|(key, mut list)| {
+            let main_pos = list
+                .iter()
+                .position(|p| p.path.to_string_lossy() == key && !p.is_worktree)
+                .unwrap_or(0);
+            let main = list.remove(main_pos);
+            // Keep the daemon's newest-first order within the group.
+            list.sort_by_key(|p| std::cmp::Reverse(time_of(p)));
+            ProjectGroup {
+                main,
+                worktrees: list,
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    fn days_ago(days: i64) -> DateTime<Utc> {
+        Utc::now() - TimeDelta::days(days)
+    }
+
+    fn project(name: &str, path: &str, last_activity: Option<DateTime<Utc>>) -> Project {
+        Project {
+            path: PathBuf::from(path),
+            name: name.into(),
+            is_worktree: false,
+            base_repo: None,
+            last_activity,
+            last_command: None,
+        }
+    }
+
+    fn worktree(
+        name: &str,
+        path: &str,
+        base: &str,
+        last_activity: Option<DateTime<Utc>>,
+    ) -> Project {
+        Project {
+            is_worktree: true,
+            base_repo: Some(PathBuf::from(base)),
+            ..project(name, path, last_activity)
+        }
+    }
+
+    #[test]
+    fn unknown_and_future_activity_are_stale() {
+        let now = Utc::now();
+        assert!(is_stale(&project("x", "/x", None), now));
+        assert!(is_stale(
+            &project("x", "/x", Some(now + TimeDelta::hours(1))),
+            now
+        ));
+    }
+
+    #[test]
+    fn activity_within_a_week_is_fresh_beyond_is_stale() {
+        let now = Utc::now();
+        assert!(!is_stale(&project("x", "/x", Some(days_ago(6))), now));
+        assert!(is_stale(&project("x", "/x", Some(days_ago(8))), now));
+    }
+
+    #[test]
+    fn fresh_sorts_before_stale_then_newest_first() {
+        let now = Utc::now();
+        let sorted = sort_projects(
+            vec![
+                project("old-fresh", "/a", Some(days_ago(5))),
+                project("stale", "/b", Some(days_ago(30))),
+                project("newest", "/c", Some(days_ago(1))),
+                project("unknown", "/d", None),
+            ],
+            now,
+        );
+        let names: Vec<&str> = sorted.iter().map(|p| p.name.as_str()).collect();
+        assert_eq!(names, ["newest", "old-fresh", "stale", "unknown"]);
+    }
+
+    #[test]
+    fn ties_break_by_name_then_path() {
+        let now = Utc::now();
+        let t = Some(days_ago(2));
+        let sorted = sort_projects(vec![project("b", "/b", t), project("a", "/a", t)], now);
+        let names: Vec<&str> = sorted.iter().map(|p| p.name.as_str()).collect();
+        assert_eq!(names, ["a", "b"]);
+    }
+
+    #[test]
+    fn filter_matches_name_or_path_case_insensitively() {
+        let p = project("Maestro", "/home/u/tea/Maestro", None);
+        assert!(matches_filter(&p, "maes"));
+        assert!(matches_filter(&p, " tea "));
+        assert!(!matches_filter(&p, "zzz"));
+        assert!(matches_filter(&p, ""), "empty query matches everything");
+    }
+
+    #[test]
+    fn worktrees_nest_under_their_main_checkout() {
+        let now = Utc::now();
+        let main = project("maestro", "/repos/maestro", Some(days_ago(10)));
+        let wt = worktree("64-tui", "/repos/wt64", "/repos/maestro", Some(days_ago(1)));
+        let other = project("other", "/repos/other", Some(days_ago(2)));
+        let sorted = sort_projects(vec![main, wt, other], now);
+        let groups = group_projects(&sorted);
+        assert_eq!(groups.len(), 2);
+        assert_eq!(
+            groups[0].main.name, "maestro",
+            "fresh worktree pulls its repo up"
+        );
+        assert_eq!(groups[0].worktrees.len(), 1);
+        assert_eq!(groups[0].worktrees[0].name, "64-tui");
+        assert_eq!(groups[1].main.name, "other");
+    }
+
+    /// A main checkout absent from the scan must not drop its worktrees.
+    #[test]
+    fn worktrees_survive_a_missing_main_checkout() {
+        let now = Utc::now();
+        let wt = worktree(
+            "solo-wt",
+            "/repos/solo-wt",
+            "/repos/solo",
+            Some(days_ago(1)),
+        );
+        let sorted = sort_projects(vec![wt], now);
+        let groups = group_projects(&sorted);
+        assert_eq!(groups.len(), 1);
+        assert_eq!(groups[0].main.name, "solo-wt");
+        assert!(groups[0].worktrees.is_empty());
+    }
+}

crates/maestro-tui/src/render.rs

@@ -315,7 +315,14 @@ mod tests {
             }
             out.push('\n');
         }
-        for s in ["draft", "cwd:", "command:", "[ Spawn ]"] {
+        for s in [
+            "draft",
+            "cmd:",
+            "dir:",
+            "name:",
+            "[ Spawn ]",
+            "Other directory…",
+        ] {
             assert!(out.contains(s), "missing {s:?}:\n{out}");
         }
     }

crates/maestro-tui/src/sidebar.rs

@@ -92,6 +92,7 @@ mod tests {
             cwd: std::path::PathBuf::from("/tmp"),
             env: Default::default(),
             metadata,
+            worktree: None,
             status: SessionStatus::Running,
             created_at: Utc::now(),
             foreground: None,
@@ -179,6 +180,7 @@ mod tests {
             cwd: std::path::PathBuf::from("/tmp"),
             env: Default::default(),
             metadata: HashMap::new(),
+            worktree: None,
             status: SessionStatus::Running,
             created_at: Utc::now(),
             foreground: None,

crates/maestro-tui/src/state.rs

@@ -20,6 +20,9 @@ pub enum Focus {
 }
 
 /// What a tab's pane slot holds: a live session, or an inline draft form.
+// The draft variant dwarfs `Session(Uuid)`; tabs are moved rarely enough
+// that boxing every access costs more than the copy does.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone, PartialEq)]
 pub enum PaneRef {
     Session(Uuid),

docs/WORKTREES.md

@@ -0,0 +1,127 @@
+# Worktrees
+
+Maestro can create a git worktree for a session and is responsible for it from
+that moment until the worktree is removed. This document is the contract for
+that lifetime: where a worktree goes, what ends a session, what survives, and
+what the operator has to do by hand.
+
+It exists because the rules here are not guessable from the code. Every rule
+below was decided once, re-litigated in review, and decided the same way again.
+The reasoning is written down alongside each rule so the next reader does not
+have to reconstruct it.
+
+## Nothing is ever adopted
+
+The daemon only ever removes a worktree it created in this session's lifetime or
+recorded in its retained store. It never takes ownership of a directory it finds
+on disk, whatever that directory looks like.
+
+There is no reliable way to ask "is this worktree mine?". A git worktree carries
+no marker distinguishing one a daemon made from one a human made ten minutes
+earlier, and any heuristic that answers the question will eventually answer it
+wrong — in the direction of deleting somebody's work.
+
+So the daemon does not ask. If the target path is occupied by anything at all, it
+picks a different path.
+
+## Placement
+
+A worktree for branch `<branch>` of repository `<repo>` goes to
+`<repo>/worktrees/<branch>`, where `<repo>` is the main checkout — not whichever
+worktree the request happened to come from.
+
+The branch name is used verbatim as a relative path, so `feature/login` becomes
+`worktrees/feature/login`. A branch name that cannot be a relative path falls
+back to a short hash of the branch.
+
+If that path exists, the daemon appends `-2`, then `-3`, and so on until it finds
+a free one. The suffix names the **directory only**. The branch is whatever was
+requested; a second worktree of the same branch is not what happens here, because
+git refuses to check the same branch out twice and the branch picker already
+marks branches that are checked out elsewhere.
+
+### The `worktree_root` override
+
+`[daemon].worktree_root` moves every worktree out of the repository and under one
+root. The per-repository directory is the repository's basename plus a short
+digest of its full path — the digest is what keeps two repositories with the same
+basename apart. Inside it the layout and the collision suffix are the same.
+
+## What ends a session
+
+`DELETE /api/sessions/:id` is **refused** when the session's worktree holds
+unsaved work, meaning any of:
+
+- uncommitted changes to tracked files
+- untracked files that are not ignored
+- commits on the branch reachable from no remote-tracking ref
+
+Ignored files never block. Every Rust worktree has a `target/`; if ignored files
+counted, no session would ever be killable.
+
+The refusal is a structured error naming what blocked it and how much of it there
+is, so a client can say "3 uncommitted files, 2 unpushed commits". The session
+keeps running and the worktree is untouched.
+
+The point of refusing rather than cleaning up is that the session stays as the
+operator's handle on their own unfinished work. A session that is killed while
+its worktree still matters leaves a directory nobody is looking at.
+
+A consequence, accepted deliberately: a feature branch almost always has unpushed
+commits, so `--force` is the ordinary way to end a session, not an exception.
+That is only safe because force retains.
+
+### `--force`
+
+`--force` overrides the refusal and nothing else. It ends the session and
+**retains** the worktree, which enters the retained store with reason
+`force-killed`. Force never removes a tree that would have blocked.
+
+Ending a session and destroying its work are two separate destructive acts. Each
+is chosen on its own, and the second one — reclaim — is chosen while looking at
+exactly what would be lost.
+
+### Exiting on its own
+
+A session that ends by itself — the command finished, the operator typed `exit` —
+never reaches the kill path. When the watcher notices the tmux session is gone it
+applies the same rule: a pristine worktree is removed, anything else is retained
+with reason `exited-with-unsaved-work`.
+
+Nobody is waiting for an answer here, so there is nothing to refuse; the choice is
+only between removing and retaining. It uses the same predicate as the kill, from
+the same place, so the two paths cannot drift apart.
+
+## The retained store
+
+A `state_dir`-backed record of worktrees the daemon created that no longer have a
+session. For each one: the path, the base repository, the branch, why it was
+retained, and when.
+
+It survives a daemon restart. It is the recovery path for everything above — a
+store that is lost on restart is worse than no store, because the worktrees are
+still on disk with nothing pointing at them.
+
+Entries leave when the worktree is reclaimed, and when the daemon notices the
+directory is gone because somebody removed it by hand.
+
+**It is not an ownership record.** It must never be consulted to decide whether a
+path may be adopted — see the first rule. Its only job is to remember what the
+daemon is holding so that it can be listed and reclaimed.
+
+## Reclaim
+
+`GET /api/worktrees` lists the store: path, base repository, branch, reason, when,
+and what is currently in the way. The in-the-way breakdown is recomputed on read,
+not stored, so a tree whose work has since been pushed says so.
+
+`DELETE /api/worktrees/<id>` reclaims one. It removes the directory and drops the
+store entry. It does **not** consult the guard — reclaim is the deliberate
+destructive act, and the operator chose it while looking at what was in the way.
+
+It never deletes the branch. `git worktree remove` leaves the ref, and reclaiming
+a tree must not throw away commits on it. This is worth saying out loud in every
+client, because "reclaim" otherwise sounds like it takes the commits too.
+
+Nothing is reclaimed automatically. There is no age-based expiry and no bulk
+reclaim.

web/README.md

@@ -20,9 +20,10 @@ src/
   main.ts        # entry point, hash-route dispatch
   api.ts         # daemon HTTP API client
   events.ts      # `/api/events` WebSocket subscriber
-  catalog.ts     # session tree view (groups by working directory)
-  attach.ts      # xterm.js + attach WS view
-  spawn.ts       # spawn-session modal
+   catalog.ts     # session tree view (groups by working directory)
+   attach.ts      # xterm.js + attach WS view
+   multiview.ts   # tabs + split panes; draft panes host the spawn form
+   spawnForm.ts   # shared spawn form (preset tiles, project picker, worktree)
   theme.ts       # dark/light theme toggle + persistence
   types.ts       # mirror of `maestro-protocol` JSON shapes
   styles.css     # design-system tokens + component styles
@@ -40,7 +41,7 @@ follows the OS by default and can be pinned via the header toggle (persisted in
 
 `mock.ts` is a DEV-only fixture (stripped from production builds): visit the dev
 server with `?mock` to seed a representative catalog without a running daemon,
-`?mock&spawn` to open the spawn modal, and `?theme=light|dark` to pin a theme.
+`?mock&spawn` to open a draft pane, and `?theme=light|dark` to pin a theme.
 
 Routing is hash-based:
 - `#/` → catalog

web/src/api.ts

@@ -1,6 +1,7 @@
 import * as routes from "./routes.js";
 import type {
   ApiError,
+  Branches,
   CreateSessionRequest,
   DaemonInfo,
   DirListing,
@@ -89,4 +90,11 @@ export async function fetchNames(count: number): Promise<NameBatch> {
   return jsonOrError(await fetch(url, { credentials: "same-origin" }));
 }
 
+/** One repository's local branches, with worktree occupancy (#55). Empty for
+ * a path outside any repo. Drives the spawn form's existing-branch picker. */
+export async function fetchBranches(path: string): Promise<Branches> {
+  const url = routes.withPathQuery(routes.BRANCHES, path);
+  return jsonOrError(await fetch(url, { credentials: "same-origin" }));
+}
+
 export { eventsWsUrl } from "./routes.js";

web/src/catalog.ts

@@ -6,9 +6,15 @@ import type { Session } from "./types.js";
 import { abbreviateFolderName, sessionName } from "./types.js";
 import type { TreeNode } from "./tree.js";
 import { buildTree } from "./tree.js";
-import { openSpawnModal } from "./spawn.js";
 import { createThemeToggle } from "./theme.js";
 
+/** Ask the shell to open a new draft pane (#62). Handled in main.ts, where the
+ *  multi-view controller lives; dispatched from every Spawn affordance. */
+export const OPEN_SPAWN_EVENT = "catalog-open-spawn";
+export function requestOpenSpawn(): void {
+  document.dispatchEvent(new CustomEvent(OPEN_SPAWN_EVENT));
+}
+
 const collapsed = new Set<string>();
 
 function renderNode(node: TreeNode, depth: number): HTMLElement {
@@ -190,7 +196,9 @@ export function renderTopbar(store: CatalogStore, onToggleSidebar?: () => void):
   spawnBtn.type = "button";
   spawnBtn.className = "btn btn-primary spawn-btn";
   spawnBtn.textContent = "+ Spawn";
-  spawnBtn.addEventListener("click", () => openSpawnModal());
+  // The keyboard pair sits right here in the tooltip (#67).
+  spawnBtn.title = "Draft pane: n — fast-forward spawn: N";
+  spawnBtn.addEventListener("click", () => requestOpenSpawn());
   actions.appendChild(spawnBtn);
   return header;
 }
@@ -342,7 +350,7 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
     treeHost.replaceChildren();
     if (sessions.length === 0) {
       treeHost.appendChild(
-        renderEmpty(filter.trim().length > 0, () => openSpawnModal()),
+        renderEmpty(filter.trim().length > 0, () => requestOpenSpawn()),
       );
       return;
     }
@@ -364,14 +372,8 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
   const rerenderHandler = () => refresh();
   document.addEventListener("catalog-rerender", rerenderHandler);
 
-  // Spawn similar: reopen the spawn modal pre-seeded from a session's dir and
-  // command (matched back to a preset by the form) — but with a freshly
-  // generated name rather than the original's, since it's a new session.
-  const spawnSimilarHandler = (ev: Event) => {
-    const s = (ev as CustomEvent<Session>).detail;
-    openSpawnModal({ cwd: s.cwd, command: s.command });
-  };
-  document.addEventListener("catalog-spawn-similar", spawnSimilarHandler);
+  // "Spawn similar" (#28) is dispatched here and handled in main.ts, where the
+  // multi-view controller can seed a draft pane with the session's dir/command.
 
   const unsubscribe = store.subscribe(refresh);
 
@@ -391,7 +393,6 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
     },
     dispose() {
       document.removeEventListener("catalog-rerender", rerenderHandler);
-      document.removeEventListener("catalog-spawn-similar", spawnSimilarHandler);
       unsubscribe();
     },
   };

web/src/fastForward.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildFastForwardRequest,
+  fastForwardSeed,
+  resolveFastForward,
+} from "./fastForward.js";
+import type { Project, SpawnPreset } from "./types.js";
+
+const presets: SpawnPreset[] = [
+  { id: "custom", label: "Custom…", command: "" },
+  { id: "claude", label: "Claude", command: "claude" },
+];
+
+function project(overrides: Partial<Project>): Project {
+  return {
+    path: "/repos/p",
+    name: "p",
+    last_activity: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("resolveFastForward (#67)", () => {
+  it("resolves every default from the most recent project", () => {
+    const projects = [
+      project({ path: "/repos/old", name: "old", last_activity: "2020-01-01T00:00:00Z" }),
+      project({
+        path: "/repos/fresh",
+        name: "fresh",
+        base_repo: "/repos/fresh",
+        last_command: "aider",
+      }),
+    ];
+    const res = resolveFastForward(projects, presets, "amber-falcon");
+    expect(res.project?.path).toBe("/repos/fresh");
+    expect(res.command).toBe("aider");
+    expect(res.name).toBe("amber-falcon");
+
+    const req = buildFastForwardRequest(res)!;
+    expect(req.cwd).toBe("/repos/fresh");
+    expect(req.command).toBe("aider");
+    expect(req.metadata).toEqual({ name: "amber-falcon" });
+    expect(req.worktree).toEqual({
+      base_repo: "/repos/fresh",
+      branch: "amber-falcon",
+      cleanup_on_kill: true,
+      create_branch: true,
+    });
+  });
+
+  it("falls back to the first non-custom preset when there is no last command", () => {
+    const res = resolveFastForward([project({ last_command: undefined })], presets, "n");
+    expect(res.command).toBe("claude");
+  });
+
+  it("treats an empty last command as no command", () => {
+    const res = resolveFastForward([project({ last_command: "" })], [presets[0]], "n");
+    expect(res.command).toBeUndefined();
+    expect(buildFastForwardRequest(res)).toBeNull();
+  });
+
+  it("resolves nothing when no projects are known yet", () => {
+    const res = resolveFastForward([], presets, "n");
+    expect(res.project).toBeUndefined();
+    expect(buildFastForwardRequest(res)).toBeNull();
+  });
+
+  it("downgrades to a draft when the generated name is missing", () => {
+    const res = resolveFastForward([project({ last_command: "claude" })], presets);
+    expect(res.name).toBeUndefined();
+    expect(buildFastForwardRequest(res)).toBeNull();
+  });
+
+  it("seeds the fallback draft with whatever did resolve", () => {
+    const res = resolveFastForward(
+      [project({ path: "/repos/p", base_repo: "/repos/p", last_command: "aider" })],
+      presets,
+    );
+    expect(fastForwardSeed(res)).toEqual({
+      cwd: "/repos/p",
+      command: "aider",
+      name: "",
+      worktreeEnabled: true,
+      worktreeBranch: undefined,
+    });
+  });
+
+  it("leaves the worktree default alone when not even a project resolved", () => {
+    // Not `false`: the form defaults the toggle on and a false would stick,
+    // so the fallback draft would disagree with a normally-opened draft and
+    // with the TUI's fast path.
+    const seed = fastForwardSeed(resolveFastForward([], presets));
+    expect(seed.worktreeEnabled).toBeUndefined();
+    expect(seed.cwd).toBe("");
+  });
+});

web/src/fastForward.ts

@@ -0,0 +1,66 @@
+// Fast-forward spawn (#67): one keystroke, every default resolved, no form.
+// Pure resolution only — the caller (main.ts) owns the fetches and the POST,
+// and falls back to a seeded draft pane when anything is missing.
+
+import type { CreateSessionRequest, Project, SpawnPreset } from "./types.js";
+import { sortProjects } from "./projectList.js";
+
+/** What one fast-forward keystroke resolved. Anything absent means "open a
+ *  draft pre-filled with the rest instead of spawning". */
+export interface FastForwardResolution {
+  project?: Project;
+  command?: string;
+  name?: string;
+}
+
+/** The defaults: most recent project (fresh-first, same ordering the picker
+ *  shows), its last command falling back to the first non-custom preset, and
+ *  a freshly generated name when the daemon supplied one. */
+export function resolveFastForward(
+  projects: Project[],
+  presets: SpawnPreset[],
+  name?: string,
+): FastForwardResolution {
+  const project = sortProjects(projects, new Date())[0];
+  const lastCommand = project?.last_command?.trim();
+  const command =
+    lastCommand || presets.find((p) => p.command !== "")?.command || undefined;
+  return { project, command, name: name || undefined };
+}
+
+/** The immediate spawn request — worktree on, new branch named after the
+ *  generated session name — or `null` when any default is missing. */
+export function buildFastForwardRequest(
+  res: FastForwardResolution,
+): CreateSessionRequest | null {
+  const { project, command, name } = res;
+  if (!project || !command?.trim() || !name) return null;
+  return {
+    cwd: project.path,
+    command,
+    metadata: { name },
+    worktree: {
+      base_repo: project.base_repo ?? project.path,
+      branch: name,
+      cleanup_on_kill: true,
+      create_branch: true,
+    },
+  };
+}
+
+/** Seed for the fallback draft pane: whatever did resolve goes into the
+ *  form; the rest stays with its own defaults. */
+export function fastForwardSeed(res: FastForwardResolution) {
+  return {
+    cwd: res.project?.path ?? "",
+    command: res.command ?? "",
+    name: res.name ?? "",
+    // Left undefined rather than false when nothing resolved: the form
+    // defaults the toggle on, and `false` would stick, so the fallback draft
+    // would disagree with both a normally-opened draft and the TUI's fast path
+    // (#67 review).
+    worktreeEnabled: res.project ? true : undefined,
+    worktreeBranch:
+      res.project && res.name ? res.name : undefined,
+  };
+}

web/src/html.ts

@@ -1,5 +1,5 @@
-// One HTML escaper. Previously written four times, in catalog.ts, spawn.ts,
-// types.ts and attach.ts.
+// One HTML escaper. Previously written four times, in catalog.ts, types.ts
+// and attach.ts.
 
 export function escapeHtml(s: string): string {
   return s

web/src/kit.css

@@ -102,7 +102,7 @@
   background: color-mix(in oklab, var(--surface) 40%, var(--bg));
 }
 
-.kit-slot .modal-body {
+.kit-slot .spawn-form {
   padding: 0;
   min-width: 200px;
 }

web/src/kit.ts

@@ -135,7 +135,7 @@ export function renderKit(): HTMLElement {
   {
     const { el, body } = section(
       "Buttons — current",
-      "The shipping button styles — now the bracket terminal style, as used across the header, modal, and empty states.",
+      "The shipping button styles — now the bracket terminal style, as used across the header, panes, and empty states.",
     );
     body.append(
       specimen("btn-primary", btn("btn btn-primary", "+ Spawn")),
@@ -170,12 +170,12 @@ export function renderKit(): HTMLElement {
     search.type = "search";
     search.className = "search";
     search.placeholder = "Search sessions…";
-    const text = h("div", "modal-body");
+    const text = h("div", "spawn-form");
     const ti = document.createElement("input");
     ti.type = "text";
     ti.placeholder = "branch-name";
     text.appendChild(ti);
-    const sel = h("div", "modal-body");
+    const sel = h("div", "spawn-form");
     const s = document.createElement("select");
     s.innerHTML = `<option>thinkpad</option><option>tower</option><option>pi</option>`;
     sel.appendChild(s);

web/src/main.ts

@@ -3,13 +3,25 @@ import { ConnectionPool } from "./connections.js";
 import { installHudKeybind } from "./debug.js";
 import { CatalogStore } from "./events.js";
 import { shouldRetryClose } from "./reconnect.js";
+import {
+  createSession,
+  fetchNames,
+  getDaemonInfo,
+  projects as fetchProjects,
+} from "./api.js";
+import {
+  buildFastForwardRequest,
+  fastForwardSeed,
+  resolveFastForward,
+} from "./fastForward.js";
+import { FALLBACK_PRESETS } from "./spawnForm.js";
 import { mountHud, type Hud } from "./hud.js";
 import { emptyLayout, type Layout, openSessions } from "./layout.js";
 import { createMultiView, type MultiView } from "./multiview.js";
 import { loadLayout, saveLayout } from "./persistence.js";
-import { openSpawnModal } from "./spawn.js";
+import { OPEN_SPAWN_EVENT } from "./catalog.js";
 import { initTheme } from "./theme.js";
-import { sessionName } from "./types.js";
+import { sessionName, type Project, type Session, type SpawnPreset } from "./types.js";
 import { installViewportSizing } from "./viewport.js";
 import "./styles.css";
 
@@ -212,7 +224,8 @@ function renderWelcome(): HTMLElement {
   spawn.type = "button";
   spawn.className = "btn btn-primary";
   spawn.textContent = "+ Spawn session";
-  spawn.addEventListener("click", () => openSpawnModal());
+  spawn.title = "Draft pane: n — fast-forward spawn: N";
+  spawn.addEventListener("click", () => requestOpenSpawn());
   (el.querySelector(".empty-actions") as HTMLElement).appendChild(spawn);
   return el;
 }
@@ -251,6 +264,84 @@ function showMultiView(): void {
   updateShellRoute();
 }
 
+// Spawn affordances (#62): the header button, the sidebar's empty state, and
+// `?mock&spawn` all open a draft pane; "Spawn similar" seeds one with the
+// cloned session's dir + command.
+function requestOpenSpawn(): void {
+  showMultiView();
+  mv.openDraft();
+}
+document.addEventListener(OPEN_SPAWN_EVENT, () => requestOpenSpawn());
+document.addEventListener("catalog-spawn-similar", (ev) => {
+  const s = (ev as CustomEvent<Session>).detail;
+  showMultiView();
+  mv.openDraft({ cwd: s.cwd, command: s.command });
+});
+
+// Fast-forward spawn (#67): the draft pane's keystroke neighbour spawns
+// immediately with every default resolved — most recent project, its last
+// command (or the first non-custom preset), a fresh name, worktree on with
+// a new branch named after that name. Anything unresolvable (no projects
+// known yet, no command, no generated name) opens a draft pre-filled with
+// what did resolve instead.
+async function requestFastForward(): Promise<void> {
+  showMultiView();
+  const [discovered, name] = await Promise.all([
+    fetchProjects().catch(() => [] as Project[]),
+    fetchNames(1)
+      .then((batch) => batch.names[0])
+      .catch(() => undefined),
+  ]);
+  let presets: SpawnPreset[] = FALLBACK_PRESETS;
+  try {
+    const info = await getDaemonInfo();
+    if (info.presets?.length) presets = info.presets;
+  } catch {
+    /* keep fallbacks */
+  }
+  const resolved = resolveFastForward(discovered, presets, name);
+  const req = buildFastForwardRequest(resolved);
+  if (req) {
+    try {
+      const session = await createSession(req);
+      // Mount it, the way the TUI's fast path attaches. Without this the
+      // keystroke creates a session and leaves the UI untouched, so it reads
+      // as a dead key (#67 review).
+      mv.openSessionBeside(session.id);
+      updateShellRoute();
+      return;
+    } catch {
+      // A failed POST degrades to the same pre-filled draft as an
+      // unresolvable default — never a silent dead keystroke.
+    }
+  }
+  mv.openDraft(fastForwardSeed(resolved));
+}
+
+// Keyboard pair (#67): `n` opens a draft pane, `N` fast-forwards a spawn.
+// Ignored while typing anywhere (form fields, the terminal's hidden
+// textarea, search) so an attached session's keys are never hijacked.
+document.addEventListener("keydown", (e) => {
+  if (e.ctrlKey || e.altKey || e.metaKey) return;
+  const target = e.target as HTMLElement | null;
+  if (
+    target &&
+    (target.tagName === "INPUT" ||
+      target.tagName === "TEXTAREA" ||
+      target.tagName === "SELECT" ||
+      target.isContentEditable)
+  ) {
+    return;
+  }
+  if (e.key === "n") {
+    e.preventDefault();
+    requestOpenSpawn();
+  } else if (e.key === "N") {
+    e.preventDefault();
+    void requestFastForward();
+  }
+});
+
 type Route =
   | { kind: "catalog" }
   | { kind: "attach"; sessionId: string }

web/src/mock.ts

@@ -135,10 +135,10 @@ export function seedMock(store: CatalogStore): void {
     sessions,
   });
 
-  // `?mock&spawn` auto-opens the spawn modal for visual review, with the spawn
+  // `?mock&spawn` auto-opens a draft pane for visual review, with the spawn
   // backend endpoints stubbed so presets/projects/gitroot all render.
   if (location.search.includes("spawn")) {
     stubSpawnApi();
-    void import("./spawn.js").then((m) => m.openSpawnModal());
+    document.dispatchEvent(new CustomEvent("catalog-open-spawn"));
   }
 }

web/src/multiview.test.ts

@@ -0,0 +1,162 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { emptyLayout, leaves, type Layout } from "./layout.js";
+import { splitLeaf } from "./layout.js";
+import { createMultiView, type MultiView } from "./multiview.js";
+import type { ConnectionPool } from "./connections.js";
+import type { SidebarHandle } from "./catalog.js";
+
+function stubFetch(): void {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      const body = url.includes("/api/info")
+        ? { hostname: "h", version: "0", home_dir: "/home/user", presets: [] }
+        : url.includes("/api/projects")
+          ? []
+          : url.includes("/api/names")
+            ? { names: ["allegro-cello"] }
+            : undefined;
+      return new Response(JSON.stringify(body), { status: 200 });
+    }),
+  );
+}
+
+function fakePool(): ConnectionPool {
+  return {
+    setVisible() {},
+    setFocus() {},
+  } as unknown as ConnectionPool;
+}
+
+function fakeSidebar(): SidebarHandle {
+  return {
+    el: document.createElement("aside"),
+    setActive() {},
+    setHighlights() {},
+    dispose() {},
+  };
+}
+
+function makeMv(layout: Layout): MultiView {
+  return createMultiView({
+    pool: fakePool(),
+    layout,
+    sidebar: fakeSidebar(),
+    infoFor: () => ({ name: "sess", command: "bash" }),
+    onDisconnect: () => {},
+    renderWelcome: () => document.createElement("div"),
+  });
+}
+
+/** Drain the microtask queue so the draft form's async seed application lands. */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 20; i++) await Promise.resolve();
+}
+
+describe("multiview openDraft (#62)", () => {
+  beforeEach(() => {
+    stubFetch();
+    document.body.replaceChildren();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("turns an empty tab into a draft pane", async () => {
+    const layout = emptyLayout();
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+
+    mv.openDraft();
+    await flush();
+
+    const ls = leaves(layout.tabs[0].root);
+    expect(ls).toHaveLength(1);
+    expect(ls[0].sessionId).toBeNull();
+    expect(ls[0].draft).not.toBeNull();
+    expect(mv.el.querySelector(".mv-draft")).toBeTruthy();
+  });
+
+  it("splits the focused session pane into a fresh draft", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    const first = splitLeaf(tab, "", "s1", "row", true);
+    tab.focusedLeafId = first;
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+    mv.render();
+
+    mv.openDraft();
+    await flush();
+
+    const ls = leaves(tab.root);
+    expect(ls).toHaveLength(2);
+    expect(ls[0].sessionId).toBe("s1");
+    const draftLeaf = ls.find((l) => l.sessionId === null)!;
+    expect(draftLeaf.draft).not.toBeNull();
+    expect(tab.focusedLeafId).toBe(draftLeaf.id);
+    expect(mv.el.querySelectorAll(".mv-pane")).toHaveLength(2);
+  });
+
+  it("reuses the focused pane when it is already empty", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    const first = splitLeaf(tab, "", "s1", "row", true);
+    const empty = splitLeaf(tab, first, null, "row", true);
+    tab.focusedLeafId = empty;
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+    mv.render();
+
+    mv.openDraft();
+    await flush();
+
+    const ls = leaves(tab.root);
+    expect(ls).toHaveLength(2);
+    const target = ls.find((l) => l.id === empty)!;
+    expect(target.draft).not.toBeNull();
+    expect(tab.focusedLeafId).toBe(empty);
+  });
+
+  it("keeps the draft form instance when an unrelated session closes (#68)", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    const s1 = splitLeaf(tab, "", "s1", "row", true);
+    const draftLeaf = splitLeaf(tab, s1, null, "row", true);
+    tab.focusedLeafId = draftLeaf;
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+    mv.render();
+    await flush();
+
+    const nameInput = mv.el.querySelector(".mv-draft input[name=name]") as HTMLInputElement;
+    nameInput.value = "wip";
+    nameInput.dispatchEvent(new Event("input"));
+    await flush();
+    expect(leaves(tab.root).find((l) => l.id === draftLeaf)?.draft?.name).toBe("wip");
+
+    const formBefore = mv.el.querySelector(".mv-draft");
+    mv.closeSession("s1");
+    await flush();
+
+    expect(mv.el.querySelector(".mv-draft")).toBe(formBefore);
+    expect((mv.el.querySelector(".mv-draft input[name=name]") as HTMLInputElement).value).toBe("wip");
+  });
+
+  it("seeds a clone's cwd and command into the draft", async () => {
+    const layout = emptyLayout();
+    const mv = makeMv(layout);
+    document.body.appendChild(mv.el);
+
+    mv.openDraft({ cwd: "/home/user/proj", command: "claude" });
+    await flush();
+
+    const leaf = leaves(layout.tabs[0].root)[0];
+    expect(leaf.draft?.cwd).toBe("/home/user/proj");
+    expect(leaf.draft?.command).toBe("claude");
+  });
+});

web/src/multiview.ts

@@ -13,6 +13,7 @@ import {
   closeTab,
   findLeaf,
   type Dir,
+  type Draft,
   type Layout,
   leaves,
   locateSession,
@@ -48,10 +49,15 @@ export interface MultiView {
   /** Bring a session into the layout: focus it if already open, else fill the
    *  focused pane (or open the first pane in an empty tab). */
   openSession: (sessionId: string) => void;
+  openSessionBeside: (sessionId: string) => void;
   /** Drop the pane showing `sessionId` (the session was disconnected/killed). */
   closeSession: (sessionId: string) => void;
   /** Every session currently shown in some pane, across all tabs. */
   openSessions: () => Set<string>;
+  /** Open a draft pane (issue #62): reuse the focused pane if it is already
+   *  empty, otherwise split the focused pane. `seed` pre-fills the form
+   *  ("Spawn similar" clones a session's cwd + command). */
+  openDraft: (seed?: Partial<Draft>) => void;
   /** Start dragging a sidebar session into the canvas (issue #32). The
    *  controller owns drag-vs-tap: a tap lets the row's normal click open it, a
    *  drag shows drop zones to place it. */
@@ -65,9 +71,11 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
   const { pool, layout, sidebar, infoFor, onDisconnect, renderWelcome } = opts;
   const persist = () => opts.onLayoutChange?.();
 
-  // Draft-pane forms (#57) carry global listeners (dir autocomplete), so each
-  // render tears down the previous generation before rebuilding the canvas.
-  const draftForms = new Set<SpawnFormHandle>();
+  // Draft-pane forms (#57) carry global listeners (dir autocomplete), so forms
+  // whose leaves are gone are destroyed on each render. Forms for draft leaves
+  // that survive the render are reused in place (#68): rebuilding one mid-edit
+  // would drop focus, caret and selection, and re-fetch info/projects/names.
+  const draftForms = new Map<string, SpawnFormHandle>();
 
   const el = document.createElement("div");
   el.className = "mv";
@@ -145,29 +153,35 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
       // Draft pane (#57): an empty pane is a spawn form. Values hang off the
       // leaf (never persisted) so each draft keeps its own half-filled state;
       // submitting fills this leaf with the new session in place.
-      const form = createSpawnForm({
-        seed: leaf.draft ?? undefined,
-        class: "mv-draft",
-        onChange: (values) => {
-          leaf.draft = values;
-        },
-        onSuccess: (session) => {
-          // The pane can be closed while the POST is in flight. Mounting the
-          // session onto a leaf no longer in the tree would strand it in no
-          // pane at all, so only claim the leaf while it is still there.
-          const t = activeTab(layout);
-          const attached = leaves(t.root).includes(leaf);
-          if (attached) {
-            leaf.sessionId = session.id;
-            leaf.draft = null;
-            t.focusedLeafId = leaf.id;
-          }
-          render();
-          opts.onOpenSessionsChange?.();
-        },
-      });
-      draftForms.add(form);
-      host.appendChild(form.el);
+      const form = draftForms.get(leaf.id);
+      if (form) {
+        host.appendChild(form.el);
+      } else {
+        const created = createSpawnForm({
+          seed: leaf.draft ?? undefined,
+          class: "mv-draft",
+          onChange: (values) => {
+            leaf.draft = values;
+          },
+          onSuccess: (session) => {
+            // The pane can be closed while the POST is in flight. Mounting the
+            // session onto a leaf no longer in the tree would strand it in no
+            // pane at all, so only claim the leaf while it is still there —
+            // searching every tab, since the operator may have switched tabs
+            // while the request was in flight.
+            const host = layout.tabs.find((t) => leaves(t.root).includes(leaf));
+            if (host) {
+              leaf.sessionId = session.id;
+              leaf.draft = null;
+              host.focusedLeafId = leaf.id;
+            }
+            render();
+            opts.onOpenSessionsChange?.();
+          },
+        });
+        draftForms.set(leaf.id, created);
+        host.appendChild(created.el);
+      }
     }
 
     const tools = document.createElement("div");
@@ -365,11 +379,82 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     render();
   }
 
+  /// Mount a session without evicting one.
+  ///
+  /// `openSession` deliberately replaces the focused pane (VS Code style) for
+  /// a sidebar click, but the fast path must never do that: pressing the key
+  /// while attached would drop the running session out of the layout
+  /// entirely. Follows `openDraft`'s rule instead — reuse an empty pane, else
+  /// split beside the focused one (#67 review).
+  function openSessionBeside(sessionId: string): void {
+    const loc = locateSession(layout, sessionId);
+    if (loc) {
+      layout.activeTabId = loc.tab.id;
+      loc.tab.focusedLeafId = loc.leaf.id;
+      render();
+      return;
+    }
+    const tab = activeTab(layout);
+    if (!tab.root || !tab.focusedLeafId || !findLeaf(tab.root, tab.focusedLeafId)) {
+      tab.focusedLeafId = splitLeaf(tab, "", sessionId, "row", true);
+      render();
+      opts.onOpenSessionsChange?.();
+      return;
+    }
+    const target = findLeaf(tab.root, tab.focusedLeafId)!;
+    if (!target.sessionId) {
+      target.sessionId = sessionId;
+      target.draft = null;
+    } else {
+      tab.focusedLeafId = splitLeaf(tab, target.id, sessionId, "row", true);
+    }
+    render();
+    opts.onOpenSessionsChange?.();
+  }
+
+  function openDraft(seed?: Partial<Draft>): void {
+    const tab = activeTab(layout);
+    const draft = (): Draft => ({ command: "", cwd: "", name: "", ...seed });
+    if (!tab.root || !tab.focusedLeafId || !findLeaf(tab.root, tab.focusedLeafId)) {
+      // Empty tab (or stale focus): the draft becomes the first pane.
+      tab.focusedLeafId = splitLeaf(tab, "", null, "row", true);
+      findLeaf(tab.root!, tab.focusedLeafId)!.draft = draft();
+      render();
+      return;
+    }
+    const target = findLeaf(tab.root, tab.focusedLeafId)!;
+    if (!target.sessionId && !target.draft) {
+      // An already-empty pane becomes the draft in place.
+      target.draft = draft();
+    } else {
+      // Split a fresh draft beside the focused pane.
+      tab.focusedLeafId = splitLeaf(tab, target.id, null, "row", true);
+      findLeaf(tab.root, tab.focusedLeafId)!.draft = draft();
+    }
+    render();
+  }
+
   // ---- top-level render ----
 
+  /** Destroy forms whose leaf is no longer a draft (leaf removed or filled by
+   *  a session). Surviving draft leaves keep their form instance (#68). */
+  function pruneForms(tab: { root: Node | null }): void {
+    const alive = new Set(
+      tab.root
+        ? leaves(tab.root)
+            .filter((l) => !l.sessionId)
+            .map((l) => l.id)
+        : [],
+    );
+    for (const [id, f] of draftForms) {
+      if (!alive.has(id)) {
+        f.destroy();
+        draftForms.delete(id);
+      }
+    }
+  }
+
   function render(): void {
-    for (const f of draftForms) f.destroy();
-    draftForms.clear();
     renderTabs();
     canvas.replaceChildren();
     const tab = activeTab(layout);
@@ -378,6 +463,7 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     el.classList.toggle("mv-mobile-solo", isMobile && layout.tabs.length === 1);
 
     if (!tab.root) {
+      pruneForms(tab);
       pool.setVisible([]);
       pool.setFocus(null);
       canvas.appendChild(renderWelcome());
@@ -393,12 +479,14 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
 
     if (isMobile) {
       renderMobile(tab);
+      pruneForms(tab);
       persist();
       return;
     }
 
     const hosts: { id: string; host: HTMLElement; info?: AttachInfo }[] = [];
     canvas.appendChild(buildTree(tab.root, hosts));
+    pruneForms(tab);
     pool.setVisible(hosts.map((h) => ({ id: h.id, pane: h.host, info: h.info })));
     syncFocus();
     persist();
@@ -639,6 +727,8 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
   return {
     el,
     openSession,
+    openSessionBeside,
+    openDraft,
     closeSession,
     openSessions: () => openSessions(layout),
     beginSessionDrag,

web/src/routes.ts

@@ -12,6 +12,7 @@ export const RECENT_DIRS = "/api/recent-dirs";
 export const PROJECTS = "/api/projects";
 export const GITROOT = "/api/gitroot";
 export const NAMES = "/api/names";
+export const BRANCHES = "/api/branches";
 export const EVENTS = "/api/events";
 
 /** Name of the query parameter `DIRS` and `GITROOT` both take. */

web/src/spawn.ts

@@ -1,68 +0,0 @@
-// The spawn modal (issue #27): bottom-sheet/dialog chrome around the shared
-// spawn form (spawnForm.ts). The modal coexists with the inline draft panes
-// (#57) until a later issue deletes it.
-
-import { createSpawnForm, type SpawnFormSeed } from "./spawnForm.js";
-
-/** Seed values for the spawn form — used by "clone" to reopen the dialog with
- * the same cwd, command, and name as an existing session. */
-export type SpawnPrefill = SpawnFormSeed;
-
-export function openSpawnModal(prefill?: SpawnPrefill): void {
-  const existing = document.getElementById("modal-host");
-  if (existing) existing.remove();
-
-  const host = document.createElement("div");
-  host.id = "modal-host";
-  host.className = "modal-backdrop";
-  host.innerHTML = `
-    <div class="modal spawn-modal" role="dialog" aria-modal="true" aria-labelledby="spawn-title">
-      <header class="modal-header">
-        <h2 id="spawn-title">Spawn session</h2>
-        <button type="button" class="btn btn-icon close" aria-label="Close">✕</button>
-      </header>
-      <div class="form-slot"></div>
-    </div>
-  `;
-  document.body.appendChild(host);
-
-  const formHandle = createSpawnForm({
-    seed: prefill,
-    class: "modal-body",
-    onSuccess(session) {
-      close();
-      location.hash = `#/attach/${encodeURIComponent(session.id)}`;
-    },
-  });
-  (host.querySelector(".form-slot") as HTMLElement).replaceWith(formHandle.el);
-
-  const close = () => {
-    formHandle.destroy();
-    host.remove();
-  };
-  // The modal keeps its Cancel affordance; the shared form ships only Submit.
-  const actions = formHandle.el.querySelector(".form-actions") as HTMLElement;
-  const cancel = document.createElement("button");
-  cancel.type = "button";
-  cancel.className = "btn btn-ghost cancel";
-  cancel.textContent = "Cancel";
-  cancel.addEventListener("click", close);
-  actions.prepend(cancel);
-
-  host.querySelector(".close")?.addEventListener("click", close);
-  host.addEventListener("click", (e) => {
-    if (e.target === host) close();
-  });
-  window.addEventListener(
-    "keydown",
-    (e) => {
-      if (e.key === "Escape") close();
-    },
-    { once: true },
-  );
-
-  // ---- clone seed ------------------------------------------------------
-  if (prefill) {
-    (host.querySelector("#spawn-title") as HTMLElement).textContent = "Clone session";
-  }
-}

web/src/spawnForm.test.ts

@@ -8,6 +8,8 @@ const base: SpawnFormValues = {
   name: "amber-fox",
   worktreeEnabled: false,
   worktreeBranch: "",
+  worktreeBranchMode: "new",
+  worktreeBranchEdited: false,
 };
 
 describe("buildSpawnRequest", () => {
@@ -33,11 +35,50 @@ describe("buildSpawnRequest", () => {
         cwd: base.cwd,
         command: base.command,
         metadata: { name: "amber-fox" },
-        worktree: { base_repo: "/home/user/project", branch: "feat/foo", cleanup_on_kill: true },
+        worktree: {
+          base_repo: "/home/user/project",
+          branch: "feat/foo",
+          cleanup_on_kill: true,
+          create_branch: true,
+        },
       },
     });
   });
 
+  it("checks out an existing branch when the mode is existing (#61)", () => {
+    const res = buildSpawnRequest(
+      {
+        ...base,
+        worktreeEnabled: true,
+        worktreeBranch: "spawn-v2",
+        worktreeBranchMode: "existing",
+      },
+      "/home/user/project",
+    );
+    expect(res).toEqual({
+      req: {
+        cwd: base.cwd,
+        command: base.command,
+        metadata: { name: "amber-fox" },
+        worktree: {
+          base_repo: "/home/user/project",
+          branch: "spawn-v2",
+          cleanup_on_kill: true,
+          create_branch: false,
+        },
+      },
+    });
+  });
+
+  it("rejects an existing-mode worktree with no branch picked", () => {
+    expect(
+      buildSpawnRequest(
+        { ...base, worktreeEnabled: true, worktreeBranch: "", worktreeBranchMode: "existing" },
+        "/repo",
+      ),
+    ).toHaveProperty("error");
+  });
+
   it("rejects a missing working directory", () => {
     expect(buildSpawnRequest({ ...base, cwd: "" }, null)).toHaveProperty("error");
   });

web/src/spawnForm.ts

@@ -1,19 +1,35 @@
 import { escapeHtml } from "./html.js";
-import { createSession, fetchNames, getDaemonInfo, projects as fetchProjects, gitRoot } from "./api.js";
+import {
+  createSession,
+  fetchBranches,
+  fetchNames,
+  getDaemonInfo,
+  projects as fetchProjects,
+  gitRoot,
+} from "./api.js";
 import { attachDirAutocomplete } from "./dirAutocomplete.js";
 import { filterProjects, groupProjects, isStale, sortProjects } from "./projectList.js";
-import type { CreateSessionRequest, Project, Session, SpawnPreset } from "./types.js";
+import type { BranchInfo, CreateSessionRequest, Project, Session, SpawnPreset } from "./types.js";
 import { abbreviateCwd, abbreviateFolderName } from "./types.js";
 
-/** Seed values for the spawn form — used by "clone" to reopen with the same
- * cwd, command, and name as an existing session, and by draft panes to restore
- * their own half-filled state after a re-render. */
+/** Where a worktree's branch comes from: freshly created (default) or picked
+ * from the repository's existing branches (#61). */
+export type WorktreeBranchMode = "new" | "existing";
+
+/** Seed values for the spawn form — used by "clone" to open a draft with the
+ * same cwd, command, and name as an existing session, and by draft panes to
+ * restore their own half-filled state after a re-render. */
 export interface SpawnFormSeed {
   command?: string;
   cwd?: string;
   name?: string;
   worktreeEnabled?: boolean;
   worktreeBranch?: string;
+  /** Whether the operator typed the branch themselves, rather than it having
+   *  been auto-synced from the session name. Carried separately because the
+   *  value alone cannot distinguish the two. */
+  worktreeBranchEdited?: boolean;
+  worktreeBranchMode?: WorktreeBranchMode;
   cwdRawVisible?: boolean;
 }
 
@@ -25,6 +41,9 @@ export interface SpawnFormValues {
   name: string;
   worktreeEnabled: boolean;
   worktreeBranch: string;
+  worktreeBranchEdited: boolean;
+  /** "new" creates the branch; "existing" checks out a picked one (#61). */
+  worktreeBranchMode: WorktreeBranchMode;
   /** Whether the cwd lives in the raw text input (vs a picked recent row). */
   cwdRawVisible?: boolean;
 }
@@ -47,15 +66,21 @@ export function buildSpawnRequest(
   };
 
   if (values.worktreeEnabled) {
+    const mode = values.worktreeBranchMode ?? "new";
     const branch = values.worktreeBranch.trim();
     if (!baseRepo) return { error: "Worktree needs a directory inside a git repository." };
-    if (!branch) return { error: "Worktree requires a branch name." };
+    if (!branch) {
+      return { error: mode === "existing" ? "Pick an existing branch." : "Worktree requires a branch name." };
+    }
     req.worktree = {
       base_repo: baseRepo,
       branch,
       // The daemon always cleans up, guarded against unsaved work (#56);
       // the wire field stays for older daemons.
       cleanup_on_kill: true,
+      // Existing-mode picks must check out as-is; the daemon creates
+      // anything else with `worktree add -b` (#56/#61).
+      create_branch: mode !== "existing",
     };
   }
 
@@ -63,8 +88,9 @@ export function buildSpawnRequest(
 }
 
 /** Built-ins used when the daemon's `/api/info` presets can't be fetched
- * (older daemon, transient error). Mirrors `maestro_config::builtin_presets`. */
-const FALLBACK_PRESETS: SpawnPreset[] = [
+ * (older daemon, transient error). Mirrors `maestro_config::builtin_presets`.
+ * Exported for the fast-forward spawn's preset fallback (#67). */
+export const FALLBACK_PRESETS: SpawnPreset[] = [
   { id: "claude", label: "Claude", command: "claude" },
   { id: "opencode", label: "opencode", command: "opencode" },
   { id: "zsh", label: "Shell", command: "zsh" },
@@ -79,7 +105,7 @@ export interface SpawnFormHandle {
 
 export interface SpawnFormOptions {
   seed?: SpawnFormSeed;
-  /** Extra class(es) for the <form> root (e.g. `modal-body` in the modal). */
+  /** Extra class(es) for the <form> root (e.g. `mv-draft` in a draft pane). */
   class?: string;
   /** Fired whenever any value changes (input, tile pick, checkbox). */
   onChange?: (values: SpawnFormValues) => void;
@@ -88,7 +114,7 @@ export interface SpawnFormOptions {
 }
 
 /** The spawn form itself — preset tiles, project picker, name, worktree.
- * Shared by the modal (`spawn.ts`) and inline draft panes (issue #57). */
+ * Mounted inline by draft panes (issue #57). */
 export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   const prefill = opts.seed ?? {};
 
@@ -128,10 +154,24 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
       <p class="wt-hint" hidden></p>
       <div class="wt-body" hidden>
         <p class="wt-repo"></p>
-        <label>
+        <div class="wt-mode" role="radiogroup" aria-label="Branch source">
+          <label class="row-inline">
+            <input type="radio" name="worktree_branch_mode" value="new" />
+            New branch
+          </label>
+          <label class="row-inline">
+            <input type="radio" name="worktree_branch_mode" value="existing" />
+            Existing branch
+          </label>
+        </div>
+        <label class="wt-new-wrap">
           Branch
           <input name="worktree_branch" type="text" placeholder="feat/foo" autocomplete="off" />
         </label>
+        <label class="wt-exist-wrap" hidden>
+          Branch
+          <select class="branch-select"></select>
+        </label>
       </div>
     </fieldset>
     <p class="form-error" role="alert" aria-live="polite"></p>
@@ -140,7 +180,7 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     </div>
   `;
   // Field queries are scoped to this form instance — several forms can be
-  // mounted at once (modal + draft panes), so ids would collide.
+  // mounted at once (one per draft pane), so ids would collide.
 
   const errEl = form.querySelector(".form-error") as HTMLElement;
   const cmdTiles = form.querySelector(".cmd-tiles") as HTMLElement;
@@ -153,7 +193,13 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   const wtHint = form.querySelector(".wt-hint") as HTMLElement;
   const wtBody = form.querySelector(".wt-body") as HTMLElement;
   const wtRepo = form.querySelector(".wt-repo") as HTMLElement;
+  const modeRadios = [
+    ...form.querySelectorAll<HTMLInputElement>("input[name=worktree_branch_mode]"),
+  ];
+  const newWrap = form.querySelector(".wt-new-wrap") as HTMLElement;
+  const existWrap = form.querySelector(".wt-exist-wrap") as HTMLElement;
   const branchInput = form.querySelector("input[name=worktree_branch]") as HTMLInputElement;
+  const branchSelect = form.querySelector(".branch-select") as HTMLSelectElement;
   const nameInput = form.querySelector("input[name=name]") as HTMLInputElement;
 
   // ---- form state ------------------------------------------------------
@@ -162,11 +208,15 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   let selectedPresetId = "";
   let command = ""; // resolved command (preset's, or the raw custom input)
   let cwd = ""; // chosen working directory
-  let inferredBaseRepo: string | null = null; // from the gitroot probe
+  let inferredBaseRepo: string | null = null; // from the gitroot probe or the project scan
   let probeToken = 0; // guards async gitroot probes against races
   // A seed's cwd, applied once the (async) projects load for the initial host
   // settles — so the fetch can't race past and clobber the seeded directory.
   let seedCwd: string | null = prefill.cwd ?? null;
+  let branchMode: WorktreeBranchMode = prefill.worktreeBranchMode ?? "new";
+  let branchToken = 0; // guards async branch-list loads against races
+  // Branch list for the current cwd — refetched whenever the target changes.
+  let branchCache: { cwd: string; branches: BranchInfo[] } | null = null;
 
   // `emit` stays silent until the initial load settles and goes silent again
   // once the form is destroyed. Construction runs with `cwd === ""` and the
@@ -176,6 +226,7 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   // clobber the live one's leaf (#57 review).
   let ready = false;
   let destroyed = false;
+  const branchValue = () => (branchMode === "existing" ? branchSelect.value : branchInput.value);
   const emit = () => {
     if (!ready || destroyed) return;
     opts.onChange?.({
@@ -183,7 +234,9 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
       cwd,
       name: nameInput.value,
       worktreeEnabled: wtEnabled.checked,
-      worktreeBranch: branchInput.value,
+      worktreeBranch: branchValue(),
+      worktreeBranchEdited: branchEdited,
+      worktreeBranchMode: branchMode,
       cwdRawVisible: !cwdRawWrap.hidden,
     });
   };
@@ -191,10 +244,14 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   // ---- name (also seeds the worktree branch) ---------------------------
   // The worktree branch defaults to the session name — including a clone's
   // prefilled name — and tracks it on reroll/edit until the user types their
-  // own branch.
-  let branchEdited = Boolean(prefill.worktreeBranch);
+  // own branch. Only in "new" mode: an existing-branch pick is not a name.
+  // True only once the operator types their own branch. It cannot be inferred
+  // from the seed: in "new" mode `emit()` publishes the auto-synced session
+  // name, so seeding from it froze the branch after any form rebuild
+  // (#67 review). `worktreeBranchEdited` is carried explicitly instead.
+  let branchEdited = Boolean(prefill.worktreeBranchEdited);
   const syncBranchToName = () => {
-    if (!branchEdited) branchInput.value = nameInput.value;
+    if (!branchEdited && branchMode === "new") branchInput.value = nameInput.value;
   };
   // Handles come from `GET /api/names` in batches (#53): the first one seeds
   // the field, rerolls consume the rest locally so they stay instant, and a
@@ -357,6 +414,7 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
 
   cwdRaw.addEventListener("input", () => {
     cwd = cwdRaw.value.trim();
+    branchCache = null;
     emit();
     if (wtEnabled.checked) probeGitRoot();
   });
@@ -374,11 +432,14 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     cwd = project.path;
     cwdRawWrap.hidden = true;
     markActiveProject(project.path);
+    // The scan already knows this directory is inside a repo (#61): the
+    // toggle defaults back on and no /api/gitroot round trip is needed.
+    wtEnabled.checked = true;
+    applyProjectRepo(project.base_repo ?? project.path);
     emit();
     // Picking a project pre-selects the command it was last used with.
     const match = presets.find((p) => p.command === project.last_command && p.command !== "");
     if (match) selectPreset(match.id);
-    if (wtEnabled.checked) probeGitRoot();
   }
 
   let discovered: Project[] = []; // daemon snapshot, daemon-sorted
@@ -432,7 +493,7 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     }
     // Everything seeded: the form may publish from here on.
     ready = true;
-    if (wtEnabled.checked) void probeGitRoot();
+    resolveBaseRepo();
     emit();
   }
 
@@ -473,7 +534,47 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     return p;
   }
 
-  // ---- worktree (branch-only; base_repo inferred via /gitroot) ----------
+  // ---- worktree (branch-only; base_repo inferred via scan or /gitroot) --
+  // The project scan already reports repo membership, so a picked project
+  // resolves its base repo locally (#61); only the free-text escape hatch
+  // pays for a /api/gitroot probe.
+  function applyProjectRepo(repo: string): void {
+    inferredBaseRepo = repo;
+    branchCache = null;
+    wtHint.hidden = true;
+    wtBody.hidden = false;
+    wtRepo.textContent = `repo: ${repo}`;
+    if (branchMode === "existing") void loadBranches();
+  }
+
+  /** Decide how the worktree section describes the current target. Called
+   * once the initial load has settled `cwd`. */
+  function resolveBaseRepo(): void {
+    // Nothing to resolve when the operator turned the worktree off — the
+    // section would otherwise rebuild expanded under an unchecked box, and
+    // fire a `/api/gitroot` probe for a worktree nobody asked for
+    // (#67 review).
+    if (!wtEnabled.checked) {
+      wtBody.hidden = true;
+      wtHint.hidden = true;
+      inferredBaseRepo = null;
+      return;
+    }
+    if (!cwd) {
+      inferredBaseRepo = null;
+      wtBody.hidden = true;
+      wtHint.hidden = false;
+      wtHint.textContent = "Choose a working directory first.";
+      return;
+    }
+    const project = discovered.find((p) => p.path === cwd);
+    if (project) {
+      applyProjectRepo(project.base_repo ?? project.path);
+      return;
+    }
+    void probeGitRoot();
+  }
+
   async function probeGitRoot(): Promise<void> {
     const token = ++probeToken;
     if (!cwd) {
@@ -494,10 +595,7 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     }
     if (token !== probeToken) return; // a newer probe superseded us
     if (root) {
-      inferredBaseRepo = root;
-      wtHint.hidden = true;
-      wtBody.hidden = false;
-      wtRepo.textContent = `repo: ${root} (inferred)`;
+      applyProjectRepo(root);
     } else {
       inferredBaseRepo = null;
       // Publish the untick too, or the next render seeds the box checked with
@@ -510,10 +608,75 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     }
   }
 
+  // ---- existing-branch picker (#61) -------------------------------------
+  function setBranchMode(mode: WorktreeBranchMode): void {
+    branchMode = mode;
+    for (const radio of modeRadios) radio.checked = radio.value === mode;
+    newWrap.hidden = mode !== "new";
+    existWrap.hidden = mode !== "existing";
+    if (mode === "existing") void loadBranches();
+    emit();
+  }
+
+  /** Fetch the target repo's branches once per cwd. Like every async load in
+   * this form: token-guarded, and nothing touches the DOM (or emits) after
+   * destroy() — a late response into a rebuilt form would corrupt that
+   * form's draft (#57 review). */
+  async function loadBranches(): Promise<void> {
+    if (!cwd || !inferredBaseRepo) return;
+    const token = ++branchToken;
+    if (branchCache?.cwd !== cwd) {
+      const target = cwd;
+      let branches: BranchInfo[];
+      try {
+        branches = await fetchBranches(target);
+      } catch {
+        return; // picker just stays empty; "new" mode still works
+      }
+      if (destroyed || token !== branchToken || cwd !== target) return;
+      branchCache = { cwd: target, branches };
+    }
+    renderBranchOptions();
+  }
+
+  function renderBranchOptions(): void {
+    if (destroyed) return;
+    const branches = branchCache?.cwd === cwd ? branchCache.branches : [];
+    branchSelect.replaceChildren();
+    const opt = (label: string, value: string) => {
+      const o = document.createElement("option");
+      o.textContent = label;
+      o.value = value;
+      return o;
+    };
+    if (branches.length === 0) {
+      branchSelect.appendChild(opt("No local branches found.", ""));
+      return;
+    }
+    for (const b of branches) {
+      // A branch that is already checked out anywhere stays visible but
+      // unpickable — git refuses a second checkout. That includes the main
+      // checkout's own HEAD, which is commonly `main` and would otherwise be
+      // the default pick, making every existing-branch spawn fail (#54 review).
+      const held = b.worktree ?? (b.is_head ? "the main checkout" : null);
+      const o = opt(held ? `${b.name} — held by ${held}` : b.name, b.name);
+      o.disabled = held !== null;
+      o.title = held ?? "";
+      branchSelect.appendChild(o);
+    }
+  }
+
+  for (const radio of modeRadios) {
+    radio.addEventListener("change", () => {
+      if (radio.checked) setBranchMode(radio.value as WorktreeBranchMode);
+    });
+  }
+  branchSelect.addEventListener("change", () => emit());
+
   wtEnabled.addEventListener("change", () => {
     emit();
     if (wtEnabled.checked) {
-      probeGitRoot();
+      resolveBaseRepo();
     } else {
       inferredBaseRepo = null;
       wtBody.hidden = true;
@@ -521,15 +684,11 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
     }
   });
 
-  // A seeded worktree restores its checkbox/body up front; its gitroot probe
-  // waits for loadRecents to apply the seeded cwd.
-  if (prefill.worktreeEnabled || prefill.worktreeBranch) {
-    wtEnabled.checked = Boolean(prefill.worktreeEnabled);
-    if (prefill.worktreeBranch) branchInput.value = prefill.worktreeBranch;
-    wtBody.hidden = !wtEnabled.checked;
-    wtHint.hidden = true;
-    emit();
-  }
+  // The toggle defaults ON (#61): the operator almost always wants a
+  // worktree, and every non-repo target unticks it via the gitroot probe.
+  wtEnabled.checked = prefill.worktreeEnabled ?? true;
+  if (prefill.worktreeBranch) branchInput.value = prefill.worktreeBranch;
+  setBranchMode(branchMode);
 
   // Seed ordering: the raw-cwd application races the async info load (which
   // provides homeDir for the projects' abbreviations), so projects wait for it.
@@ -548,8 +707,10 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
         cwd,
         name: nameInput.value,
         worktreeEnabled: wtEnabled.checked,
-        worktreeBranch: branchInput.value,
-        },
+        worktreeBranch: branchValue(),
+        worktreeBranchEdited: branchEdited,
+        worktreeBranchMode: branchMode,
+      },
       inferredBaseRepo,
     );
     if ("error" in built) {

web/src/spawnFormWorktree.test.ts

@@ -0,0 +1,172 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createSpawnForm, type SpawnFormHandle, type SpawnFormValues } from "./spawnForm.js";
+
+const PROJECTS = [
+  { path: "/home/user/maestro", name: "maestro", last_activity: "2026-08-20T10:00:00Z" },
+];
+
+const BRANCHES = [
+  { name: "main", is_head: true },
+  { name: "spawn-v2", is_head: false, worktree: "/home/user/wt-spawn" },
+  { name: "free-branch", is_head: false },
+];
+
+/** Stub the fetches the form makes. `gateBranches` (when given) holds the
+ * /api/branches response until released, so tests can destroy the form while
+ * its branch list is still in flight. */
+function stubFetch(opts?: {
+  gateBranches?: (release: () => void) => void;
+}): string[] {
+  const urls: string[] = [];
+  const gated = new Promise<void>((resolve) => {
+    if (opts?.gateBranches) opts.gateBranches(resolve);
+    else resolve();
+  });
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      urls.push(url);
+      if (url.includes("/api/names")) {
+        return new Response(JSON.stringify({ names: ["amber-fox"] }), { status: 200 });
+      }
+      if (url.includes("/api/branches")) {
+        await gated;
+        return new Response(JSON.stringify(BRANCHES), { status: 200 });
+      }
+      if (url.includes("/api/projects")) {
+        return new Response(JSON.stringify(PROJECTS), { status: 200 });
+      }
+      return new Response(
+        JSON.stringify({ hostname: "h", version: "0", home_dir: "/home/user", presets: [] }),
+        { status: 200 },
+      );
+    }),
+  );
+  return urls;
+}
+
+describe("spawnForm worktree defaults and branch picker (#61)", () => {
+  let handle: SpawnFormHandle | null = null;
+  let urls: string[];
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    handle?.destroy();
+    handle = null;
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  async function mount(
+    seed?: Parameters<typeof createSpawnForm>[0]["seed"],
+    onChange?: (values: SpawnFormValues) => void,
+  ) {
+    urls = stubFetch();
+    handle = createSpawnForm({ seed, onSuccess() {}, onChange });
+    document.body.appendChild(handle.el);
+    for (let i = 0; i < 40; i++) await Promise.resolve();
+    return handle.el;
+  }
+
+  const drain = async () => {
+    for (let i = 0; i < 40; i++) await Promise.resolve();
+  };
+
+  function pickProject(form: HTMLFormElement): void {
+    form.querySelector<HTMLButtonElement>(".project-row.project-other")!.click();
+    form
+      .querySelectorAll<HTMLButtonElement>(".project-row")
+      .forEach((row) => row.dataset.cwd === "/home/user/maestro" && row.click());
+  }
+
+  it("defaults the worktree toggle on for a picked project with no gitroot probe", async () => {
+    const form = await mount();
+    expect(form.querySelector<HTMLInputElement>("input[name=worktree_enabled]")!.checked).toBe(
+      true,
+    );
+
+    pickProject(form);
+    await drain();
+
+    expect(urls.some((u) => u.includes("/api/gitroot"))).toBe(false);
+    expect(form.querySelector<HTMLElement>(".wt-repo")!.textContent).toContain(
+      "/home/user/maestro",
+    );
+  });
+
+  it("still probes the gitroot for a free-text directory", async () => {
+    const form = await mount();
+
+    // Escape hatch: switch to a free-text dir; only now does /api/gitroot fire.
+    form.querySelector<HTMLElement>(".project-row.project-other")!.click();
+    const raw = form.querySelector<HTMLInputElement>("input[name=cwd_raw]")!;
+    raw.value = "/opt/somewhere";
+    raw.dispatchEvent(new Event("input"));
+    await drain();
+
+    expect(urls.some((u) => u.includes("/api/gitroot"))).toBe(true);
+  });
+
+  it("populates existing branches, disabling ones held by another worktree", async () => {
+    const form = await mount();
+    pickProject(form);
+
+    const radio = form.querySelector<HTMLInputElement>(
+      'input[name=worktree_branch_mode][value="existing"]',
+    )!;
+    radio.click();
+    await drain();
+
+    const select = form.querySelector<HTMLSelectElement>(".branch-select")!;
+    expect(urls.some((u) => u.includes("/api/branches?path="))).toBe(true);
+    const options = [...select.options];
+    expect(options.map((o) => o.value)).toEqual(["main", "spawn-v2", "free-branch"]);
+    const held = options.find((o) => o.value === "spawn-v2")!;
+    expect(held.disabled).toBe(true);
+    expect(held.textContent).toContain("/home/user/wt-spawn");
+    expect(options.find((o) => o.value === "free-branch")!.disabled).toBe(false);
+  });
+
+  it("emits the branch mode as draft state when it changes", async () => {
+    const changes: SpawnFormValues[] = [];
+    const form = await mount(undefined, (v) => changes.push(v));
+    await drain();
+
+    const radio = form.querySelector<HTMLInputElement>(
+      'input[name=worktree_branch_mode][value="existing"]',
+    )!;
+    radio.click();
+    await drain();
+
+    const modes = changes.map((c) => (c as { worktreeBranchMode?: string }).worktreeBranchMode);
+    expect(modes).toContain("new");
+    expect(modes.at(-1)).toBe("existing");
+  });
+
+  it("does not repopulate a destroyed form when the branch list lands late", async () => {
+    const gate: { release?: () => void } = {};
+    urls = stubFetch({ gateBranches: (r) => (gate.release = r) });
+    handle = createSpawnForm({ onSuccess() {} });
+    document.body.appendChild(handle.el);
+    for (let i = 0; i < 40; i++) await Promise.resolve();
+
+    pickProject(handle.el);
+    handle.el
+      .querySelector<HTMLInputElement>('input[name=worktree_branch_mode][value="existing"]')!
+      .click();
+
+    handle.destroy();
+    gate.release?.();
+    await drain();
+
+    expect(
+      handle.el.querySelector<HTMLSelectElement>(".branch-select")!.options.length,
+    ).toBe(0);
+  });
+});

web/src/styles.css

@@ -1205,72 +1205,9 @@ textarea {
   border-color: var(--accent-strong);
 }
 
-/* ---------- modal ---------- */
+/* ---------- forms ---------- */
 
-.modal-backdrop {
-  position: fixed;
-  inset: 0;
-  background: oklch(0.12 0.01 256 / 0.6);
-  backdrop-filter: blur(3px);
-  display: flex;
-  align-items: flex-end;
-  justify-content: center;
-  padding: 0;
-  z-index: var(--z-modal);
-  animation: fade var(--dur) var(--ease-out);
-}
-
-@media (min-width: 600px) {
-  .modal-backdrop {
-    align-items: center;
-    padding: var(--sp-6);
-  }
-}
-
-.modal {
-  background: var(--surface);
-  border-radius: var(--r-3) var(--r-3) 0 0;
-  border: 1px solid var(--border);
-  width: 100%;
-  max-width: 560px;
-  max-height: 92vh;
-  display: flex;
-  flex-direction: column;
-  box-shadow: var(--shadow-2);
-  animation: sheet-up var(--dur-slow) var(--ease-out);
-}
-
-@media (min-width: 600px) {
-  .modal {
-    border-radius: var(--r-3);
-    animation: pop var(--dur) var(--ease-out);
-  }
-}
-
-.modal-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: var(--sp-3);
-  border-bottom: 1px solid var(--border);
-}
-
-.modal-header h2 {
-  margin: 0;
-  font-size: var(--fs-15);
-  font-weight: 600;
-  display: inline-flex;
-  align-items: center;
-  gap: var(--sp-2);
-}
-
-.modal-header h2::before {
-  content: "+";
-  color: var(--accent);
-  font-weight: 700;
-}
-
-.modal-body {
+.spawn-form {
   padding: var(--sp-3);
   overflow: auto;
   display: flex;
@@ -1280,7 +1217,6 @@ textarea {
   scrollbar-color: var(--border-strong) transparent;
 }
 
-.modal-body label,
 .spawn-form label {
   display: flex;
   flex-direction: column;
@@ -1290,7 +1226,6 @@ textarea {
   letter-spacing: 0.01em;
 }
 
-.modal-body label.row-inline,
 .spawn-form label.row-inline {
   flex-direction: row;
   align-items: center;
@@ -1300,10 +1235,9 @@ textarea {
   cursor: pointer;
 }
 
-.modal-body input[type="text"],
-.modal-body input[type="search"],
-.modal-body select,
-.spawn-form input[type="text"] {
+.spawn-form input[type="text"],
+.spawn-form input[type="search"],
+.spawn-form select {
   background: var(--surface-2);
   border: 1px solid var(--border);
   border-radius: var(--r-2);
@@ -1318,23 +1252,20 @@ textarea {
     background var(--dur-fast) var(--ease-out);
 }
 
-.modal-body input[type="text"]:hover,
-.modal-body select:hover,
-.spawn-form input[type="text"]:hover {
+.spawn-form input[type="text"]:hover,
+.spawn-form select:hover {
   border-color: var(--border-strong);
 }
 
-.modal-body input[type="text"]:focus,
-.modal-body input[type="search"]:focus,
-.modal-body select:focus,
-.spawn-form input[type="text"]:focus {
+.spawn-form input[type="text"]:focus,
+.spawn-form input[type="search"]:focus,
+.spawn-form select:focus {
   outline: none;
   border-color: var(--accent);
   background: var(--surface);
   box-shadow: 0 0 0 3px var(--accent-tint);
 }
 
-.modal-body input[type="checkbox"],
 .spawn-form input[type="checkbox"] {
   width: 18px;
   height: 18px;
@@ -1359,13 +1290,6 @@ textarea {
   font-size: var(--fs-13);
 }
 
-.modal-actions {
-  display: flex;
-  gap: var(--sp-2);
-  justify-content: flex-end;
-  margin-top: var(--sp-2);
-}
-
 .form-error {
   color: var(--danger);
   margin: 0;
@@ -1381,7 +1305,6 @@ textarea {
 
 /* ---------- spawn form: tiles + recents picker (#27) ---------- */
 
-.spawn-modal .field,
 .spawn-form .field {
   display: flex;
   flex-direction: column;
@@ -1575,6 +1498,16 @@ textarea {
   color: var(--muted);
 }
 
+/* New-vs-existing branch source (#61). */
+.wt-mode {
+  display: flex;
+  gap: var(--sp-4);
+}
+
+.branch-select {
+  width: 100%;
+}
+
 /* Generated-name field with a reroll button. */
 .name-row {
   display: flex;
@@ -1601,7 +1534,7 @@ textarea {
 
 .dir-ac {
   position: fixed;
-  z-index: var(--z-toast); /* above the modal it completes within */
+  z-index: var(--z-toast); /* above the draft pane it completes within */
   margin: 0;
   padding: var(--sp-1);
   list-style: none;
@@ -1749,26 +1682,6 @@ textarea {
   }
 }
 
-@keyframes fade {
-  from {
-    opacity: 0;
-  }
-}
-
-@keyframes sheet-up {
-  from {
-    transform: translateY(16px);
-    opacity: 0;
-  }
-}
-
-@keyframes pop {
-  from {
-    transform: scale(0.98);
-    opacity: 0;
-  }
-}
-
 /* ---------- responsive ---------- */
 
 @media (max-width: 520px) {
@@ -2109,15 +2022,6 @@ textarea {
   flex: 1;
   min-width: 0;
   min-height: 0;
-  overflow-y: auto;
-  scrollbar-width: thin;
-  scrollbar-color: var(--border-strong) transparent;
-  /* The modal form got its stacking and padding from `.modal-body`; in a pane
-     the form is the host, so it carries them itself. */
-  display: flex;
-  flex-direction: column;
-  gap: var(--sp-2);
-  padding: var(--sp-3);
 }
 
 /* pane tools cluster (disconnect / split / close), top-right corner. The attach

web/src/types.ts

@@ -114,8 +114,25 @@ export interface WorktreeSpec {
   base_repo: string;
   branch: string;
   cleanup_on_kill?: boolean;
+  /** When false, `branch` already exists and is checked out as-is (#61).
+   * Defaults to true (create a new branch) on older daemons. */
+  create_branch?: boolean;
 }
 
+/** One local branch of the enclosing repository, from `GET /api/branches`
+ * (#55). Mirrors `maestro_protocol::BranchInfo`. */
+export interface BranchInfo {
+  /** Short branch name (`main`, `feature/foo`). */
+  name: string;
+  /** Whether this branch is the main checkout's current HEAD. */
+  is_head: boolean;
+  /** Toplevel path of the linked worktree holding this branch, if any. */
+  worktree?: string | null;
+}
+
+/** `GET /api/branches?path=` — the local branches of one repository (#55). */
+export type Branches = BranchInfo[];
+
 export interface CreateSessionRequest {
   cwd: string;
   command: string;