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

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/dirlist.rs

@@ -111,7 +111,6 @@ fn io_error(dir: &Path, e: &std::io::Error) -> ErrorInfo {
     ErrorInfo {
         code: code.into(),
         message: format!("{message}: {}", dir.display()),
-        unsaved_work: None,
     }
 }
 

crates/maestro-daemon/src/lib.rs

@@ -25,6 +25,7 @@ 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 {
@@ -50,6 +53,8 @@ pub fn router(state: LocalApiState) -> Router {
         .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))
@@ -94,8 +99,6 @@ fn session_error_status(code: &str) -> StatusCode {
     match code {
         "not_found" => StatusCode::NOT_FOUND,
         "invalid_env" => StatusCode::BAD_REQUEST,
-        // A guard refusal is the daemon doing its job, not a failure (#79).
-        "kill_guarded" => StatusCode::CONFLICT,
         _ => StatusCode::BAD_GATEWAY,
     }
 }
@@ -170,21 +173,128 @@ async fn create_session(
 /// `kill` already reports a missing session as `SessionError::NotFound`, which
 /// maps to 404. Checking first would only add a window in which the liveness
 /// watcher reaps the session between the two awaits, turning a 404 into a 502.
-///
-/// The full error info is passed through rather than rebuilt from
-/// code + message: a `kill_guarded` refusal (#79) carries the unsaved-work
-/// breakdown clients render as "3 uncommitted files, 2 unpushed commits".
 async fn kill_session(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
     match s.manager.kill(id).await {
         Ok(()) => StatusCode::NO_CONTENT.into_response(),
         Err(e) => {
             let info = e.to_error_info();
-            let status = session_error_status(&info.code);
-            (status, Json(ApiError { error: info })).into_response()
+            error_response(
+                session_error_status(&info.code),
+                info.code.as_str(),
+                info.message.as_str(),
+            )
         }
     }
 }
 
+/// `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()
 }
@@ -200,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,
@@ -207,6 +318,7 @@ pub fn state_for(
         home_dir: Arc::new(home_dir.into()),
         presets: Arc::new(presets),
         projects,
+        retained,
     }
 }
 

crates/maestro-daemon/src/retained_store.rs

@@ -14,6 +14,9 @@
 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)]
@@ -24,20 +27,8 @@ pub enum RetainedStoreError {
     Json(#[from] serde_json::Error),
 }
 
-/// Why a worktree outlived its session. Kebab-case on the wire; new variants
-/// are additive but clients should render unknown reasons generically.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::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,
-}
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct RetainedWorktree {
+pub struct RetainedWorktreeRecord {
     pub id: Uuid,
     pub path: PathBuf,
     pub base_repo: PathBuf,
@@ -71,8 +62,8 @@ impl RetainedStore {
         base_repo: &Path,
         branch: &str,
         reason: RetainedReason,
-    ) -> Result<RetainedWorktree, RetainedStoreError> {
-        let entry = RetainedWorktree {
+    ) -> Result<RetainedWorktreeRecord, RetainedStoreError> {
+        let entry = RetainedWorktreeRecord {
             id: Uuid::new_v4(),
             path: path.to_path_buf(),
             base_repo: base_repo.to_path_buf(),
@@ -85,7 +76,7 @@ impl RetainedStore {
     }
 
     /// Atomically write `entry`. Creates the directory if it does not exist.
-    pub fn overwrite(&self, entry: &RetainedWorktree) -> Result<(), RetainedStoreError> {
+    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));
@@ -108,7 +99,7 @@ impl RetainedStore {
     /// 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<RetainedWorktree>, RetainedStoreError> {
+    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,
@@ -124,7 +115,7 @@ impl RetainedStore {
             let Ok(bytes) = std::fs::read(&path) else {
                 continue;
             };
-            if let Ok(worktree) = serde_json::from_slice::<RetainedWorktree>(&bytes) {
+            if let Ok(worktree) = serde_json::from_slice::<RetainedWorktreeRecord>(&bytes) {
                 out.push(worktree);
             }
         }

crates/maestro-daemon/src/session.rs

@@ -38,8 +38,8 @@ pub const DEFAULT_LIVENESS_INTERVAL: Duration = Duration::from_secs(2);
 pub struct SessionRecord {
     pub session: Session,
     pub fifo_path: PathBuf,
-    /// Worktree we created at spawn time; removed on kill, but only after the
-    /// kill guard (#79) found nothing worth keeping in it.
+    /// Worktree we created at spawn time; removed on kill unless the
+    /// dirty-work guard refuses (#56).
     pub worktree_path: Option<PathBuf>,
     /// `base_repo` from the original `WorktreeSpec`. Needed because `git
     /// worktree remove` is invoked from the base repo.
@@ -61,11 +61,6 @@ pub enum SessionError {
     NotFound(Uuid),
     #[error("invalid environment variable name: {0:?}")]
     InvalidEnv(String),
-    /// The kill was refused (#79): the session's worktree holds unsaved work.
-    /// Nothing happened — the session keeps running and the tree is untouched,
-    /// so it stays the operator's handle on their own unfinished work.
-    #[error("kill refused: the session's worktree holds unsaved work ({0})")]
-    KillGuarded(maestro_protocol::UnsavedWork),
 }
 
 impl SessionError {
@@ -77,16 +72,10 @@ impl SessionError {
             SessionError::Io(_) => "io_failed",
             SessionError::NotFound(_) => "not_found",
             SessionError::InvalidEnv(_) => "invalid_env",
-            SessionError::KillGuarded(_) => "kill_guarded",
-        };
-        let unsaved_work = match self {
-            SessionError::KillGuarded(b) => Some(*b),
-            _ => None,
         };
         ErrorInfo {
             code: code.into(),
             message: self.to_string(),
-            unsaved_work,
         }
     }
 }
@@ -381,48 +370,20 @@ impl SessionManager {
         }
     }
 
-    /// Kill a session and remove its on-disk artifacts.
-    ///
-    /// Refused (#79) when the session's worktree holds unsaved work —
-    /// uncommitted tracked changes, untracked non-ignored files, or commits
-    /// reachable from no remote-tracking ref. Nothing is killed and nothing
-    /// is removed; the error names what blocked it and how much of it there
-    /// is. The session stays as the operator's handle on their own unfinished
-    /// work, so ending a session that still matters becomes a deliberate
-    /// `--force`, which retains rather than destroys (WORKTREES.md).
+    /// Kill a session and remove its on-disk artifacts. The worktree is
+    /// always pruned -- unless it holds uncommitted changes or commits not on
+    /// any other ref, in which case the guard leaves it on disk (#56).
     ///
     /// This is also how an already-dead session is dismissed. tmux is only
     /// asked to kill something it still has — calling `kill-session` on a
     /// session tmux already lost fails, and that failure is not interesting.
     pub async fn kill(&self, id: Uuid) -> Result<(), SessionError> {
-        let (worktree, alive) = {
-            let sessions = self.inner.sessions.lock().await;
-            match sessions.get(&id) {
-                None => return Err(SessionError::NotFound(id)),
-                Some(record) => (
-                    record
-                        .worktree_base_repo
-                        .clone()
-                        .zip(record.worktree_path.clone()),
-                    record.session.status == SessionStatus::Running,
-                ),
-            }
-        };
-        // The guard runs before anything is torn down: refusing must leave the
-        // session running, exactly as the operator left it.
-        if let Some((_, path)) = worktree {
-            let probe = tmux_blocking(move || crate::worktree::unsaved_work(&path))
-                .await
-                .map_err(SessionError::Worktree)?;
-            if !probe.is_empty() {
-                return Err(SessionError::KillGuarded(probe));
-            }
-        }
         let removed = {
             let mut sessions = self.inner.sessions.lock().await;
             sessions.remove(&id)
         };
         let record = removed.ok_or(SessionError::NotFound(id))?;
+        let alive = record.session.status == SessionStatus::Running;
         cleanup_record(&self.inner, id, record, alive).await;
         Ok(())
     }
@@ -759,9 +720,10 @@ async fn cleanup_record(inner: &Arc<Inner>, id: Uuid, record: SessionRecord, kil
     if let Err(e) = inner.sidecar.delete(id) {
         tracing::warn!(error = ?e, %id, "cleanup: failed to delete sidecar");
     }
-    // The kill already passed the unsaved-work guard (#79), so this removal
-    // is unconditional; the manager's own nested-worktree refusal is all that
-    // can still leave a tree on disk, and it says where.
+    // Cleanup is unconditional now (#56): `cleanup_on_kill` is no longer a
+    // user-facing choice. The manager's guard is what protects unsaved work --
+    // when it refuses, leave the tree on disk and say where it is so the
+    // operator can find it.
     if let (Some(base), Some(path)) = (&record.worktree_base_repo, &record.worktree_path) {
         if let Err(e) = inner.worktree_mgr.remove(base, path) {
             tracing::warn!(

crates/maestro-daemon/src/worktree.rs

@@ -10,9 +10,7 @@ pub enum WorktreeError {
     Spawn(#[from] std::io::Error),
     #[error("git exited with code {code}: {stderr}")]
     NonZero { code: i32, stderr: String },
-    /// A registered worktree lives under the tree about to be removed; git
-    /// hides its contents from `git status`, so removal would delete its
-    /// uncommitted work unseen (#54 review).
+    /// The worktree holds unsaved work; removal was refused (#56).
     #[error("left {} on disk: {}", .path.display(), .reason)]
     Guarded { path: PathBuf, reason: String },
 }
@@ -128,13 +126,12 @@ impl WorktreeManager {
         Ok(path)
     }
 
-    /// `git -C <base_repo> worktree remove <path>`.
-    ///
-    /// Unconditional (#79): the guard moved off the worktree and onto the
-    /// kill, so by the time removal runs the caller has already chosen to
-    /// destroy the tree — the kill only gets here after
-    /// [`unsaved_work`] came back empty. Still refused for a tree holding a
-    /// nested registered worktree, which `git status` cannot see.
+    /// `git -C <base_repo> worktree remove <path>` — but only when the
+    /// worktree holds nothing unique (#56). A worktree with uncommitted
+    /// changes, or with commits reachable from no other ref, is refused and
+    /// left on disk so the operator can rescue it; cleanup is unconditional,
+    /// which makes this guard the only thing standing between a stray kill
+    /// and destroyed work.
     pub fn remove(&self, base_repo: &Path, path: &Path) -> Result<(), WorktreeError> {
         // Gone from disk already (operator `rm -rf`, or a create that failed
         // half-way). Probing it with git would fail and be misread as unsaved
@@ -150,6 +147,12 @@ impl WorktreeManager {
                 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(),
+                reason,
+            });
+        }
         let out = Command::new("git")
             .arg("-C")
             .arg(base_repo)
@@ -248,49 +251,22 @@ fn branch_relpath(branch: &str) -> Option<PathBuf> {
     Some(candidate.to_path_buf())
 }
 
-/// The unsaved-work probe (#79): what would be lost if `path` were deleted.
+/// `Some(reason)` when deleting `path` would destroy work.
 ///
-/// One function, three answers, shared by every caller that must make the
-/// same decision — the kill guard refuses on any non-empty result and the
-/// natural-exit classifier (#82) retains on it — so the two paths cannot
-/// drift. A worktree whose directory is already gone holds nothing to save.
-pub fn unsaved_work(path: &Path) -> Result<maestro_protocol::UnsavedWork, WorktreeError> {
-    if std::fs::symlink_metadata(path).is_err() {
-        return Ok(maestro_protocol::UnsavedWork::default());
+/// Only an unclean working tree qualifies. `git worktree remove` deletes the
+/// checkout but keeps `refs/heads/<branch>`, so committed work — pushed or
+/// not — stays reachable and is never at risk. Guarding on "commits on no
+/// other ref" instead would refuse every ordinary unpushed feature branch,
+/// and because the path is deterministic that branch could then never be
+/// spawned again (#56 review).
+fn unsafe_to_remove(path: &Path) -> Result<Option<String>, WorktreeError> {
+    // `--ignored=no` keeps build output out of it; untracked sources count,
+    // since removal would delete them.
+    let status = run_git(path, ["status", "--porcelain", "--ignored=no"])?;
+    if !status.stdout.is_empty() {
+        return Ok(Some("has uncommitted changes".into()));
     }
-    // `--ignored=no` keeps build output out of it; ignored files never block
-    // (#79), or no Rust checkout would ever be killable.
-    let out = run_git(path, &["status", "--porcelain", "--ignored=no"])?;
-    let status = String::from_utf8_lossy(&out.stdout);
-    let mut dirty = 0u32;
-    let mut untracked = 0u32;
-    for line in status.lines() {
-        if line.starts_with("??") {
-            untracked += 1;
-        } else {
-            dirty += 1;
-        }
-    }
-
-    // Detached HEAD has no branch; the tip itself still works as a starting
-    // point for the reachability query below.
-    let head = run_git(path, &["rev-parse", "--abbrev-ref", "HEAD"])?;
-    let branch = String::from_utf8_lossy(&head.stdout).trim().to_string();
-    let tip: &str = if branch == "HEAD" { "HEAD" } else { &branch };
-    let count = run_git(path, &["rev-list", "--count", tip, "--not", "--remotes"])?;
-    let unpushed: u32 = String::from_utf8_lossy(&count.stdout)
-        .trim()
-        .parse()
-        .map_err(|e| WorktreeError::NonZero {
-            code: 0,
-            stderr: format!("unparseable rev-list count: {e}"),
-        })?;
-
-    Ok(maestro_protocol::UnsavedWork {
-        dirty_tracked_files: dirty,
-        untracked_files: untracked,
-        unpushed_commits: unpushed,
-    })
+    Ok(None)
 }
 
 /// `git -C <base_repo> worktree prune` — drops registrations whose directory
@@ -304,7 +280,10 @@ fn prune(base_repo: &Path) -> Result<(), WorktreeError> {
     check(out)
 }
 
-fn run_git(dir: &Path, args: &[&str]) -> Result<Output, WorktreeError> {
+fn run_git(
+    dir: &Path,
+    args: impl IntoIterator<Item = &'static str>,
+) -> Result<Output, WorktreeError> {
     let mut cmd = Command::new("git");
     cmd.arg("-C").arg(dir).args(args);
     let out = cmd.output()?;

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

@@ -27,6 +27,7 @@ async fn spawn() -> Harness {
         "/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

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

@@ -93,38 +93,6 @@ fn run(cmd: &mut Command) {
     );
 }
 
-/// An empty bare repository at `dir`, usable as a push target (#79).
-pub fn init_bare_repo(dir: &Path) {
-    run(Command::new("git")
-        .arg("init")
-        .arg("-q")
-        .arg("--bare")
-        .arg(dir.to_str().expect("non-utf8 bare repo path")));
-}
-
-/// Push every branch of `repo` to `origin`, creating remote-tracking refs.
-///
-/// The unsaved-work probe (#79) counts commits reachable from no
-/// remote-tracking ref as unpushed, so tests that want a killable worktree
-/// must give its branch one. Safe to call again: re-adding an existing
-/// remote is ignored.
-pub fn push_all_to_origin(repo: &Path, origin: &Path) {
-    let _ = Command::new("git")
-        .arg("-C")
-        .arg(repo)
-        .args([
-            "remote",
-            "add",
-            "origin",
-            origin.to_str().expect("non-utf8 origin path"),
-        ])
-        .status();
-    run(Command::new("git")
-        .arg("-C")
-        .arg(repo)
-        .args(["push", "-q", "--all", "origin"]));
-}
-
 /// Async polling sibling of [`wait_for`] for tokio tests.
 pub async fn wait_for_async<F, Fut>(timeout: Duration, mut cond: F)
 where
@@ -195,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

@@ -9,7 +9,7 @@ use std::time::Duration;
 use common::DaemonFixture;
 use futures_util::{SinkExt, StreamExt};
 use maestro_daemon::local_api;
-use maestro_protocol::{ApiError, CreateSessionRequest, Session, WorktreeSpec};
+use maestro_protocol::{CreateSessionRequest, Session};
 use tokio::net::TcpListener;
 use tokio::sync::oneshot;
 use tokio_tungstenite::tungstenite::Message as WsMessage;
@@ -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
@@ -338,53 +339,6 @@ async fn delete_owned_session_kills_it() {
     assert!(!h.manager.has(session.id).await);
 }
 
-/// The kill guard on the wire (#79): `DELETE /api/sessions/:id` answers 409
-/// with the structured breakdown, and the session keeps running.
-#[tokio::test]
-async fn delete_a_session_whose_worktree_holds_unsaved_work_returns_409_with_the_breakdown() {
-    let h = spawn("naps-laptop").await;
-    let repo = tempfile::TempDir::new().unwrap();
-    common::init_repo(repo.path());
-    let session = h
-        .manager
-        .create(CreateSessionRequest {
-            cwd: repo.path().to_path_buf(),
-            command: "sleep 60".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: Some(WorktreeSpec {
-                base_repo: repo.path().to_path_buf(),
-                branch: "feat/guarded".into(),
-                cleanup_on_kill: true,
-                create_branch: true,
-            }),
-        })
-        .await
-        .unwrap();
-    std::fs::write(
-        repo.path()
-            .join("worktrees")
-            .join("feat")
-            .join("guarded")
-            .join("README"),
-        b"unsaved edits\n",
-    )
-    .unwrap();
-
-    let resp = reqwest::Client::new()
-        .delete(url(h.addr, &format!("/api/sessions/{}", session.id)))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(resp.status(), reqwest::StatusCode::CONFLICT);
-    let body: ApiError = resp.json().await.unwrap();
-    assert_eq!(body.error.code, "kill_guarded");
-    let breakdown = body.error.unsaved_work.expect("breakdown on the wire");
-    assert_eq!(breakdown.dirty_tracked_files, 1);
-
-    assert!(h.manager.has(session.id).await, "the session keeps running");
-}
-
 #[tokio::test]
 async fn attach_ws_streams_pty_bytes() {
     let h = spawn("naps-laptop").await;
@@ -539,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

@@ -4,12 +4,10 @@ mod common;
 
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::process::Command;
 use std::sync::Arc;
 use std::time::Duration;
 
-use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
-use maestro_daemon::SessionError;
+use common::{init_repo, wait_for_async, DaemonFixture};
 use maestro_protocol::CreateSessionRequest;
 use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
 use tempfile::TempDir;
@@ -365,9 +363,8 @@ async fn liveness_watcher_marks_dead_sessions_and_keeps_them_until_dismissed() {
     assert!(!fx.fifo_dir().join(format!("{}.fifo", s.id)).exists());
 }
 
-/// Cleanup on kill is unconditional once the guard passes (#79): even a spec
-/// that says "don't clean up" loses its worktree — the branch was pushed, so
-/// nothing in the tree is unique and removal goes ahead.
+/// Cleanup is unconditional (#56): even a spec that says "don't clean up"
+/// loses its worktree on kill — the guard, not the flag, protects work.
 #[tokio::test]
 async fn kill_removes_worktree_even_when_spec_says_keep() {
     let fx = DaemonFixture::new();
@@ -393,21 +390,14 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
         .expect("create");
     assert!(wt_path.exists());
 
-    // Push the branch so its commits are reachable from a remote-tracking ref.
-    let origin = TempDir::new().unwrap();
-    init_bare_repo(origin.path());
-    push_all_to_origin(repo.path(), origin.path());
-
     fx.manager.kill(s.id).await.expect("kill");
     assert!(!wt_path.exists(), "worktree must be removed on kill");
 }
 
-/// The kill guard (#79): a worktree holding uncommitted changes refuses the
-/// kill outright. Nothing happens — the session keeps running as the
-/// operator's handle on their unfinished work, and the tree is untouched.
-/// The refusal names what blocked it and how much of it there is.
+/// The guard (#56): a worktree holding uncommitted changes survives the kill,
+/// left on disk where the operator can find it.
 #[tokio::test]
-async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
+async fn kill_leaves_worktree_with_unsaved_work_on_disk() {
     let fx = DaemonFixture::new();
     let repo = TempDir::new().unwrap();
     init_repo(repo.path());
@@ -430,138 +420,13 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
         .await
         .expect("create");
     std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
-    std::fs::write(wt_path.join("notes.txt"), b"untracked\n").unwrap();
 
-    let err = fx.manager.kill(s.id).await.expect_err("kill must refuse");
-    let SessionError::KillGuarded(breakdown) = err else {
-        panic!("expected KillGuarded, got {err:?}");
-    };
-    assert_eq!(breakdown.dirty_tracked_files, 1);
-    assert_eq!(breakdown.untracked_files, 1);
+    fx.manager.kill(s.id).await.expect("kill");
     assert!(
-        breakdown.unpushed_commits >= 1,
-        "a fresh branch has no remote-tracking ref"
-    );
-    let message = breakdown.to_string();
-    assert!(message.contains("1 uncommitted file"), "{message}");
-    assert!(message.contains("1 untracked file"), "{message}");
-
-    // Nothing happened: the session survives and so does the tree.
-    assert!(fx.manager.has(s.id).await, "the session must keep running");
-    assert!(wt_path.exists(), "the worktree must be untouched");
-
-    // A second kill after the work is saved goes through.
-    run_git_in(&wt_path, &["add", "."]);
-    run_git_in(&wt_path, &["commit", "-q", "-m", "saved"]);
-    let origin = TempDir::new().unwrap();
-    init_bare_repo(origin.path());
-    push_all_to_origin(repo.path(), origin.path());
-    fx.manager.kill(s.id).await.expect("kill after saving");
-    assert!(!fx.manager.has(s.id).await);
-}
-
-/// Unpushed commits alone block the kill (#79): a feature branch almost
-/// always has them, which is why `--force` (which retains) is the ordinary
-/// way to end such a session.
-#[tokio::test]
-async fn killing_refuses_until_the_branch_is_pushed() {
-    let fx = DaemonFixture::new();
-    let repo = TempDir::new().unwrap();
-    init_repo(repo.path());
-    let wt_path = repo.path().join("worktrees").join("feat").join("pushed");
-
-    let s = fx
-        .manager
-        .create(CreateSessionRequest {
-            cwd: repo.path().to_path_buf(),
-            command: "sleep 30".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: Some(WorktreeSpec {
-                base_repo: repo.path().to_path_buf(),
-                branch: "feat/pushed".into(),
-                cleanup_on_kill: true,
-                create_branch: true,
-            }),
-        })
-        .await
-        .expect("create");
-
-    let err = fx.manager.kill(s.id).await.expect_err("unpushed blocks");
-    let SessionError::KillGuarded(breakdown) = err else {
-        panic!("expected KillGuarded, got {err:?}");
-    };
-    assert_eq!(breakdown.dirty_tracked_files, 0);
-    assert_eq!(breakdown.untracked_files, 0);
-    assert!(breakdown.unpushed_commits >= 1);
-
-    let origin = TempDir::new().unwrap();
-    init_bare_repo(origin.path());
-    push_all_to_origin(repo.path(), origin.path());
-
-    fx.manager.kill(s.id).await.expect("pushed branch kills");
-    assert!(!wt_path.exists());
-    assert!(!fx.manager.has(s.id).await);
-}
-
-/// Ignored files NEVER block (#79): build output like `target/` exists in
-/// every Rust checkout, and an ignored-only worktree stays killable.
-#[tokio::test]
-async fn killing_an_ignored_only_worktree_succeeds() {
-    let fx = DaemonFixture::new();
-    let repo = TempDir::new().unwrap();
-    init_repo(repo.path());
-    // .gitignore must be committed before the worktree branches off, or it
-    // would itself read as an untracked file.
-    std::fs::write(repo.path().join(".gitignore"), b"/target\n").unwrap();
-    run_git_in(repo.path(), &["add", ".gitignore"]);
-    run_git_in(repo.path(), &["commit", "-q", "-m", "ignore target"]);
-    let origin = TempDir::new().unwrap();
-    init_bare_repo(origin.path());
-
-    let wt_path = repo.path().join("worktrees").join("feat").join("rusty");
-    let s = fx
-        .manager
-        .create(CreateSessionRequest {
-            cwd: repo.path().to_path_buf(),
-            command: "sleep 30".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: Some(WorktreeSpec {
-                base_repo: repo.path().to_path_buf(),
-                branch: "feat/rusty".into(),
-                cleanup_on_kill: true,
-                create_branch: true,
-            }),
-        })
-        .await
-        .expect("create");
-    std::fs::create_dir_all(wt_path.join("target")).unwrap();
-    std::fs::write(wt_path.join("target").join("app.o"), b"binary\n").unwrap();
-
-    // Branch pushed; the only dirt is ignored output.
-    push_all_to_origin(repo.path(), origin.path());
-
-    fx.manager
-        .kill(s.id)
-        .await
-        .expect("ignored files never block");
-    assert!(!wt_path.exists());
-    assert!(!fx.manager.has(s.id).await);
-}
-
-fn run_git_in(dir: &std::path::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)
+        wt_path.exists(),
+        "dirty worktree must be left on disk, not destroyed"
     );
+    assert!(fx.manager.snapshot().await.is_empty());
 }
 
 #[tokio::test]

crates/maestro-daemon/tests/worktree.rs

@@ -6,8 +6,8 @@ mod common;
 use std::path::PathBuf;
 use std::process::Command;
 
-use common::{init_bare_repo, init_repo, push_all_to_origin};
-use maestro_daemon::worktree::{unsaved_work, WorktreeManager};
+use common::init_repo;
+use maestro_daemon::worktree::WorktreeManager;
 use tempfile::TempDir;
 
 fn worktree_branches(repo: &PathBuf) -> Vec<String> {
@@ -134,123 +134,6 @@ fn add_twice_generates_distinct_paths() {
     assert!(p2.exists());
 }
 
-/// The unsaved-work probe (#79) counts uncommitted tracked changes.
-#[test]
-fn the_probe_counts_uncommitted_tracked_changes() {
-    let repo_dir = TempDir::new().unwrap();
-    let repo = repo_dir.path().to_path_buf();
-    init_repo(&repo);
-
-    let mgr = WorktreeManager::new(None);
-    let path = mgr.add_new(&repo, "feat/dirty").expect("add");
-    std::fs::write(path.join("README"), b"unsaved edits\n").unwrap();
-
-    let w = unsaved_work(&path).expect("probe");
-    assert_eq!(w.dirty_tracked_files, 1);
-    assert_eq!(w.untracked_files, 0);
-}
-
-/// Untracked sources count; a staged new file is also unsaved tracked work.
-#[test]
-fn the_probe_counts_untracked_files() {
-    let repo_dir = TempDir::new().unwrap();
-    let repo = repo_dir.path().to_path_buf();
-    init_repo(&repo);
-
-    let mgr = WorktreeManager::new(None);
-    let path = mgr.add_new(&repo, "feat/untracked").expect("add");
-    std::fs::write(path.join("notes.txt"), b"wip\n").unwrap();
-    std::fs::write(path.join("more.txt"), b"also wip\n").unwrap();
-
-    let w = unsaved_work(&path).expect("probe");
-    assert_eq!(w.untracked_files, 2);
-    assert_eq!(w.dirty_tracked_files, 0);
-
-    run_git(&path, &["add", "notes.txt"]);
-    let w = unsaved_work(&path).expect("probe");
-    assert_eq!(w.dirty_tracked_files, 1, "staged counts as uncommitted");
-    assert_eq!(w.untracked_files, 1);
-}
-
-/// Ignored files NEVER block: every Rust checkout has a `target/`, and
-/// counting ignored output would leave no session killable (#79).
-#[test]
-fn the_probe_ignores_ignored_files() {
-    let repo_dir = TempDir::new().unwrap();
-    let repo = repo_dir.path().to_path_buf();
-    init_repo(&repo);
-
-    // .gitignore must be committed, or it would itself read as untracked.
-    std::fs::write(repo.join(".gitignore"), b"/target\n").unwrap();
-    run_git(&repo, &["add", ".gitignore"]);
-    run_git(&repo, &["commit", "-q", "-m", "ignore target"]);
-
-    let mgr = WorktreeManager::new(None);
-    let path = mgr.add_new(&repo, "feat/builds").expect("add");
-    std::fs::create_dir_all(path.join("target")).unwrap();
-    std::fs::write(path.join("target").join("app.o"), b"binary\n").unwrap();
-
-    let w = unsaved_work(&path).expect("probe");
-    assert_eq!(w.dirty_tracked_files, 0);
-    assert_eq!(w.untracked_files, 0);
-
-    // With the branch pushed too, an ignored-only tree reads fully clean.
-    let origin_dir = TempDir::new().unwrap();
-    init_bare_repo(origin_dir.path());
-    push_all_to_origin(&repo, origin_dir.path());
-    let w = unsaved_work(&path).expect("probe after push");
-    assert!(w.is_empty(), "ignored-only worktree must read clean: {w:?}");
-}
-
-/// Commits reachable from no remote-tracking ref block; pushing the branch
-/// clears them. With no remote at all every commit is unreachable from one,
-/// which is exactly why feature branches almost always refuse (#79).
-#[test]
-fn the_probe_counts_unpushed_commits_until_the_branch_is_pushed() {
-    let repo_dir = TempDir::new().unwrap();
-    let repo = repo_dir.path().to_path_buf();
-    init_repo(&repo);
-
-    let mgr = WorktreeManager::new(None);
-    let path = mgr.add_new(&repo, "feat/branch").expect("add");
-
-    let w = unsaved_work(&path).expect("probe");
-    assert!(
-        w.unpushed_commits >= 1,
-        "a fresh branch has no remote-tracking ref: {w:?}"
-    );
-
-    let origin_dir = TempDir::new().unwrap();
-    init_bare_repo(origin_dir.path());
-    push_all_to_origin(&repo, origin_dir.path());
-
-    let w = unsaved_work(&path).expect("probe after push");
-    assert_eq!(w.unpushed_commits, 0, "{w:?}");
-    assert!(w.is_empty(), "pushed and clean must be empty: {w:?}");
-}
-
-/// The full breakdown names each blocker with its count.
-#[test]
-fn the_probe_reports_every_blocker_at_once() {
-    let repo_dir = TempDir::new().unwrap();
-    let repo = repo_dir.path().to_path_buf();
-    init_repo(&repo);
-
-    let mgr = WorktreeManager::new(None);
-    let path = mgr.add_new(&repo, "feat/mixed").expect("add");
-    std::fs::write(path.join("README"), b"edited\n").unwrap();
-    std::fs::write(path.join("scratch.txt"), b"untracked\n").unwrap();
-
-    let w = unsaved_work(&path).expect("probe");
-    assert_eq!(w.dirty_tracked_files, 1);
-    assert_eq!(w.untracked_files, 1);
-    assert!(w.unpushed_commits >= 1);
-    let summary = w.to_string();
-    assert!(summary.contains("1 uncommitted file"), "{summary}");
-    assert!(summary.contains("1 untracked file"), "{summary}");
-    assert!(summary.contains("unpushed commit"), "{summary}");
-}
-
 #[test]
 fn remove_prunes_worktree() {
     let repo_dir = TempDir::new().unwrap();
@@ -328,14 +211,8 @@ fn add_existing_checks_out_branch_without_creating_it() {
     );
 }
 
-/// Removal is guarded upstream now (#79): the kill refuses unsaved work
-/// before anything is torn down, so by the time `remove` runs the tree is
-/// clean. Git still refuses a dirty tree on its own — this asserts that last
-/// line of defense — and committed-but-unpushed work does not block removal,
-/// because `worktree remove` keeps `refs/heads/<branch>` and the commits stay
-/// reachable.
 #[test]
-fn remove_still_relies_on_git_refusing_a_dirty_tree() {
+fn remove_refuses_worktree_with_uncommitted_changes() {
     let repo_dir = TempDir::new().unwrap();
     let repo = repo_dir.path().to_path_buf();
     init_repo(&repo);
@@ -348,6 +225,10 @@ fn remove_still_relies_on_git_refusing_a_dirty_tree() {
         .expect_err("dirty worktree must be refused");
     assert!(path.exists(), "guarded worktree must stay on disk");
 
+    // Committing it makes removal safe: `worktree remove` keeps
+    // `refs/heads/feat/dirty`, so the work is still reachable. Refusing here
+    // instead would make every unpushed branch a one-shot, since the path is
+    // deterministic and the leftover tree blocks the next spawn (#56 review).
     run_git(&path, &["add", "."]);
     run_git(&path, &["commit", "-q", "-m", "saved"]);
 
@@ -529,8 +410,7 @@ fn a_guarded_leftover_is_never_adopted() {
     let first = mgr.add_new(&repo, "feat/resume").expect("add");
     std::fs::write(first.join("notes.txt"), b"unsaved\n").unwrap();
 
-    // Removal is refused — git itself refuses a dirty tree — leaving it on
-    // disk; the daemon-side guard lives on the kill (#79).
+    // The guard refuses, leaving it on disk.
     mgr.remove(&repo, &first)
         .expect_err("dirty tree is guarded");
 

crates/maestro-e2e/tests/e2e.rs

@@ -160,7 +160,6 @@ async fn kill_removes_clean_worktree() {
         "expected a worktree for feature/e2e under <repo>/worktrees, got: {worktrees:?}"
     );
 
-    push_to_throwaway_origin(base.path());
     client.kill_session(s.id).await.expect("kill");
 
     // Give the daemon a moment to remove the worktree, then verify.
@@ -178,12 +177,11 @@ async fn kill_removes_clean_worktree() {
     );
 }
 
-/// The kill guard (#79): killing a session whose worktree holds uncommitted
-/// changes is refused outright. Nothing happens — the session keeps running
-/// as the operator's handle on their unfinished work, the tree stays on disk,
-/// and the refusal names what blocked it and how much.
+/// The guard (#56): killing a session whose worktree holds uncommitted
+/// changes must leave the tree on disk — cleanup is unconditional, so this
+/// guard is what keeps a stray kill from destroying work.
 #[tokio::test(flavor = "multi_thread")]
-async fn kill_refuses_worktree_with_uncommitted_changes() {
+async fn kill_spares_worktree_with_uncommitted_changes() {
     let (_daemon, client) = bring_up().await;
 
     let base = TempDir::new().unwrap();
@@ -211,25 +209,17 @@ async fn kill_refuses_worktree_with_uncommitted_changes() {
     assert!(wt_path.exists());
     std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
 
-    let err = client
-        .kill_session(s.id)
-        .await
-        .expect_err("kill must refuse");
-    match err {
-        maestro_e2e::ClientError::Api(maestro_protocol::ClientError::Api { info, .. }) => {
-            assert_eq!(info.code, "kill_guarded", "{info:?}");
-            let breakdown = info.unsaved_work.expect("breakdown on the wire");
-            assert_eq!(breakdown.dirty_tracked_files, 1);
-        }
-        other => panic!("expected a kill_guarded refusal, got {other:?}"),
-    }
+    client.kill_session(s.id).await.expect("kill");
 
-    // The session survives and the dirty worktree stays findable on disk.
-    let sessions = client.list_sessions().await.unwrap_or_default();
-    assert!(
-        sessions.iter().any(|x| x.id == s.id),
-        "a refused kill must keep the session alive"
-    );
+    // The session is gone but the dirty worktree stays findable on disk.
+    let deadline = Instant::now() + Duration::from_secs(5);
+    while Instant::now() < deadline {
+        let sessions = client.list_sessions().await.unwrap_or_default();
+        if sessions.is_empty() {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
     assert!(
         wt_path.exists(),
         "guarded worktree must be left on disk after kill"
@@ -280,7 +270,6 @@ async fn spawn_on_existing_branch_checks_it_out() {
         "expected a worktree checked out at feature/existing, got: {worktrees:?}"
     );
 
-    push_to_throwaway_origin(base.path());
     client.kill_session(s.id).await.expect("kill");
 }
 
@@ -328,7 +317,6 @@ async fn spawn_new_branch_creates_worktree_and_runs_in_it() {
     )
     .await;
 
-    push_to_throwaway_origin(base.path());
     client.kill_session(s.id).await.expect("kill");
 }
 
@@ -376,7 +364,6 @@ async fn second_spawn_on_same_branch_is_rejected() {
         "original worktree must be untouched"
     );
 
-    push_to_throwaway_origin(base.path());
     client.kill_session(first.id).await.expect("kill");
 }
 
@@ -419,7 +406,6 @@ async fn spawn_from_linked_worktree_places_in_main_checkout() {
         "worktrees must never nest inside another worktree"
     );
 
-    push_to_throwaway_origin(base.path());
     client.kill_session(s.id).await.expect("kill");
 }
 
@@ -788,24 +774,6 @@ fn git_worktree_list(dir: &std::path::Path) -> Vec<String> {
         .collect()
 }
 
-/// Push every branch of `repo` to a throwaway bare remote, so its commits are
-/// reachable from remote-tracking refs. Without one the kill guard (#79)
-/// reads every commit as unpushed, and any worktree session refuses to die.
-fn push_to_throwaway_origin(repo: &std::path::Path) {
-    let origin = tempfile::TempDir::new().unwrap();
-    run_git(
-        &["init", "-q", "--bare", origin.path().to_str().unwrap()],
-        repo,
-    );
-    let _ = Command::new("git")
-        .arg("-C")
-        .arg(repo)
-        .args(["remote", "add", "origin", origin.path().to_str().unwrap()])
-        .output()
-        .expect("git remote add");
-    run_git(&["push", "-q", "--all", "origin"], repo);
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn daemon_events_ws_streams_snapshot_then_session_added() {
     // NAP-248: subscribe to the daemon's WS /api/events, expect an initial

crates/maestro-protocol/src/lib.rs

@@ -143,60 +143,56 @@ pub struct SessionWorktree {
     pub base_repo: PathBuf,
 }
 
-// ---------------------------------------------------------------------------
-// Unsaved-work breakdown (#79)
-// ---------------------------------------------------------------------------
+/// 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 worktree holds that would be lost if its directory were destroyed.
-///
-/// The kill guard refuses `DELETE /api/sessions/:id` with this breakdown, and
-/// natural exits (#82) classify with the same daemon-side probe, so the two
-/// paths cannot drift. Ignored files never count: every Rust checkout has a
-/// `target/`, and counting those would leave no session killable.
+/// 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 UnsavedWork {
-    /// Tracked files with uncommitted modifications or staged changes.
+pub struct InTheWay {
+    /// Tracked files with uncommitted modifications.
     #[serde(default)]
-    pub dirty_tracked_files: u32,
-    /// Untracked files that are not ignored.
+    pub uncommitted_files: usize,
+    /// Untracked files that are not ignored (ignored files never block).
     #[serde(default)]
-    pub untracked_files: u32,
+    pub untracked_files: usize,
     /// Commits on the branch reachable from no remote-tracking ref.
     #[serde(default)]
-    pub unpushed_commits: u32,
+    pub unpushed_commits: usize,
 }
 
-impl UnsavedWork {
-    pub fn is_empty(&self) -> bool {
-        self.dirty_tracked_files == 0 && self.untracked_files == 0 && self.unpushed_commits == 0
+impl InTheWay {
+    /// Nothing blocks any more — the work has since been committed and pushed.
+    pub fn is_clear(&self) -> bool {
+        *self == Self::default()
     }
 }
 
-impl std::fmt::Display for UnsavedWork {
-    /// "3 uncommitted files, 2 untracked files, 2 unpushed commits" — zero
-    /// parts are omitted; all-zero renders "no unsaved work".
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let parts = [
-            (self.dirty_tracked_files, "uncommitted file"),
-            (self.untracked_files, "untracked file"),
-            (self.unpushed_commits, "unpushed commit"),
-        ];
-        let said: Vec<String> = parts
-            .into_iter()
-            .filter(|(n, _)| *n > 0)
-            .map(|(n, unit)| {
-                if n == 1 {
-                    format!("1 {unit}")
-                } else {
-                    format!("{n} {unit}s")
-                }
-            })
-            .collect();
-        if said.is_empty() {
-            return write!(f, "no unsaved work");
-        }
-        write!(f, "{}", said.join(", "))
-    }
+/// 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.
@@ -304,10 +300,6 @@ pub struct BranchInfo {
 pub struct ErrorInfo {
     pub code: String,
     pub message: String,
-    /// Set only by the kill guard (#79): the unsaved work that blocked
-    /// `DELETE /api/sessions/:id`, so a client can render counts directly.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub unsaved_work: Option<UnsavedWork>,
 }
 
 /// The envelope every `/api/*` failure is wrapped in: `{"error": {…}}`.
@@ -328,7 +320,6 @@ impl ApiError {
             error: ErrorInfo {
                 code: code.into(),
                 message: message.into(),
-                unsaved_work: None,
             },
         }
     }
@@ -600,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();
@@ -639,7 +684,6 @@ mod tests {
             ClientControl::Error(ErrorInfo {
                 code: "bad_frame".into(),
                 message: "decode failed".into(),
-                unsaved_work: None,
             }),
             resize,
         ] {

crates/maestro-protocol/src/routes.rs

@@ -26,6 +26,9 @@ 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";
 
@@ -40,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}")
@@ -50,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.
@@ -160,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"
@@ -178,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]
@@ -191,6 +208,7 @@ mod tests {
             GITROOT,
             BRANCHES,
             NAMES,
+            WORKTREES,
             EVENTS,
         ] {
             assert!(path.starts_with(API_PREFIX), "{path} escapes {API_PREFIX}");