refactor(maestro): drop cleanup_on_kill from the wire and the CLI

Nothing has honoured WorktreeSpec.cleanup_on_kill since #56, and after
#79 and #81 survival is decided by what is in a worktree, not by what
the spawn asked for. A field that lies is worse than a missing one.

Removes the field from the protocol, the --cleanup-on-kill flag from
the CLI, and the tests asserting its default.

crates/maestro-cli/src/cli.rs

@@ -102,11 +102,6 @@ pub struct SpawnArgs {
     /// there.
     #[arg(long)]
     pub existing_branch: bool,
-    /// Remove the worktree when the session is killed. Kept for wire
-    /// compatibility (#56): the daemon now always cleans up on kill, guarded
-    /// against unsaved work.
-    #[arg(long, default_value_t = true)]
-    pub cleanup_on_kill: bool,
     /// After spawning, attach immediately.
     #[arg(long, short = 'a')]
     pub attach: bool,
@@ -125,6 +120,11 @@ pub struct AttachArgs {
 pub struct KillArgs {
     /// Session ID to kill.
     pub session_id: Uuid,
+    /// End the session even when its worktree holds unsaved work (#81). The
+    /// worktree is retained — never removed — and enters the retained store;
+    /// the output says where the work went.
+    #[arg(long)]
+    pub force: bool,
 }
 
 fn parse_kv(s: &str) -> Result<(String, String), String> {
@@ -163,7 +163,6 @@ mod tests {
             "/repos/foo",
             "--branch",
             "feat/x",
-            "--cleanup-on-kill",
             "-e",
             "FOO=bar",
             "-e",
@@ -174,7 +173,6 @@ mod tests {
             Command::Spawn(a) => {
                 assert_eq!(a.command, "bash");
                 assert_eq!(a.branch.as_deref(), Some("feat/x"));
-                assert!(a.cleanup_on_kill);
                 assert_eq!(
                     a.env,
                     vec![("FOO".into(), "bar".into()), ("BAZ".into(), "qux".into()),]
@@ -184,27 +182,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn cleanup_on_kill_defaults_true_for_the_wire() {
-        let cli = Cli::try_parse_from([
-            "maestro",
-            "spawn",
-            "--cwd",
-            "/tmp",
-            "--command",
-            "bash",
-            "--worktree-from",
-            "/repos/foo",
-            "--branch",
-            "feat/x",
-        ])
-        .unwrap();
-        match cli.command {
-            Command::Spawn(a) => assert!(a.cleanup_on_kill),
-            _ => panic!("wrong subcommand"),
-        }
-    }
-
     /// Review fix: without a flag the CLI always sent `create_branch: true`,
     /// so the daemon's existing-branch path was unreachable and spawning onto
     /// a branch that already existed just failed.
@@ -256,6 +233,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn parses_kill_with_force() {
+        let id = "01234567-89ab-cdef-0123-456789abcdef";
+        let cli = Cli::try_parse_from(["maestro", "kill", "--force", id]).unwrap();
+        match cli.command {
+            Command::Kill(a) => {
+                assert!(a.force);
+                assert_eq!(a.session_id.to_string(), id);
+            }
+            _ => panic!("wrong subcommand"),
+        }
+    }
+
+    #[test]
+    fn kill_force_defaults_false() {
+        let id = "01234567-89ab-cdef-0123-456789abcdef";
+        let cli = Cli::try_parse_from(["maestro", "kill", id]).unwrap();
+        match cli.command {
+            Command::Kill(a) => {
+                assert!(!a.force);
+                assert_eq!(a.session_id.to_string(), id);
+            }
+            _ => panic!("wrong subcommand"),
+        }
+    }
+
     #[test]
     fn rejects_env_without_equals() {
         let err = Cli::try_parse_from([

crates/maestro-cli/src/dispatch.rs

@@ -62,8 +62,15 @@ pub async fn dispatch(
             run_attach_url(&daemon.attach_url(args.session_id)?, detach).await?;
         }
         Command::Kill(args) => {
-            run_kill(&daemon, &args).await?;
+            let outcome = run_kill(&daemon, &args).await?;
             println!("killed {}", args.session_id);
+            if let Some(w) = outcome.retained {
+                println!(
+                    "worktree retained at {} (branch {}, force-killed)",
+                    w.path.display(),
+                    w.branch
+                );
+            }
         }
         Command::Worktrees(args) => match args.command {
             WorktreesCommand::List(list_args) => {

crates/maestro-cli/src/sessions.rs

@@ -43,7 +43,6 @@ pub async fn run_spawn(client: &DaemonClient, args: SpawnArgs) -> Result<Session
         (Some(repo), Some(branch)) => Some(WorktreeSpec {
             base_repo: repo.clone(),
             branch: branch.clone(),
-            cleanup_on_kill: args.cleanup_on_kill,
             create_branch: !args.existing_branch,
         }),
         _ => None,
@@ -59,9 +58,14 @@ pub async fn run_spawn(client: &DaemonClient, args: SpawnArgs) -> Result<Session
     client.create_session(&body).await
 }
 
-/// `maestro kill`
-pub async fn run_kill(client: &DaemonClient, args: &KillArgs) -> Result<(), ClientError> {
-    client.kill_session(args.session_id).await
+/// `maestro kill`. A forced kill (#81) retains the guarded worktree instead
+/// of removing it; the outcome names what was kept so dispatch can say where
+/// the work went.
+pub async fn run_kill(
+    client: &DaemonClient,
+    args: &KillArgs,
+) -> Result<maestro_protocol::KillOutcome, ClientError> {
+    client.kill_session(args.session_id, args.force).await
 }
 
 #[allow(clippy::write_literal)]

crates/maestro-cli/tests/against_mock_daemon.rs

@@ -76,7 +76,7 @@ async fn killing_an_unknown_session_reports_the_daemon_reason() {
 
     let err = mock
         .client()
-        .kill_session(Uuid::new_v4())
+        .kill_session(Uuid::new_v4(), false)
         .await
         .expect_err("should fail");
 
@@ -102,6 +102,9 @@ async fn spawn_round_trips_through_the_daemon() {
     assert_eq!(created.command, "bash");
     assert_eq!(mock.session_count(), 1);
 
-    mock.client().kill_session(created.id).await.expect("kill");
+    mock.client()
+        .kill_session(created.id, false)
+        .await
+        .expect("kill");
     assert_eq!(mock.session_count(), 0);
 }

crates/maestro-daemon/src/cli.rs

@@ -56,6 +56,9 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
         Some(p) => Tmux::new().with_tmpdir(p),
         None => Tmux::new(),
     };
+    let retained = std::sync::Arc::new(crate::retained_store::RetainedStore::new(
+        config.retained_worktree_dir(),
+    ));
     let manager = SessionManager::new_with_replay(
         std::sync::Arc::new(tmux),
         sidecar,
@@ -66,7 +69,10 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     .with_spawn_history(crate::spawn_history::SpawnHistory::new(
         config.spawn_history_path(),
         config.spawn_history_days,
-    ));
+    ))
+    // One store instance shared with the API handlers: forced kills (#81)
+    // record here, `GET /api/worktrees` (#80) reads back from here.
+    .with_retained_store((*retained).clone());
 
     let recovered = manager.recover().await?;
     tracing::info!(recovered, "adopted existing tmux sessions");
@@ -85,9 +91,7 @@ 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(),
-        )),
+        retained,
     ));
 
     let listener = TcpListener::bind(config.bind_addr).await?;

crates/maestro-daemon/src/local_api.rs

@@ -101,6 +101,8 @@ fn session_error_status(code: &str) -> StatusCode {
         "invalid_env" => StatusCode::BAD_REQUEST,
         // A guard refusal is the daemon doing its job, not a failure (#79).
         "kill_guarded" => StatusCode::CONFLICT,
+        // The retention record failed before anything was torn down (#81).
+        "retain_failed" => StatusCode::INTERNAL_SERVER_ERROR,
         _ => StatusCode::BAD_GATEWAY,
     }
 }
@@ -179,9 +181,29 @@ async fn create_session(
 /// 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(),
+///
+/// With `force=true` (#81) the refusal is overridden and the worktree
+/// retained; the answer is `200` with a [`KillOutcome`] naming what was kept.
+/// Without it the historical `204` stands.
+#[derive(Debug, Deserialize)]
+struct KillQuery {
+    #[serde(default)]
+    force: bool,
+}
+
+async fn kill_session(
+    State(s): State<LocalApiState>,
+    Path(id): Path<Uuid>,
+    Query(q): Query<KillQuery>,
+) -> Response {
+    match s.manager.kill(id, q.force).await {
+        Ok(outcome) => {
+            if q.force {
+                (StatusCode::OK, Json(outcome)).into_response()
+            } else {
+                StatusCode::NO_CONTENT.into_response()
+            }
+        }
         Err(e) => {
             let info = e.to_error_info();
             let status = session_error_status(&info.code);

crates/maestro-daemon/src/session.rs

@@ -12,8 +12,8 @@ use std::time::Duration;
 
 use chrono::Utc;
 use maestro_protocol::{
-    ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, Session, SessionStatus,
-    WorktreeSpec,
+    ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, KillOutcome, RetainedReason,
+    RetainedWorktree, Session, SessionStatus, WorktreeSpec,
 };
 use tokio::sync::{broadcast, Mutex};
 use uuid::Uuid;
@@ -44,6 +44,11 @@ pub struct SessionRecord {
     /// `base_repo` from the original `WorktreeSpec`. Needed because `git
     /// worktree remove` is invoked from the base repo.
     pub worktree_base_repo: Option<PathBuf>,
+    /// Branch the worktree was created for, recorded at spawn time so a
+    /// forced kill (#81) can name it in the retained store without asking
+    /// git. Sessions adopted from a sidecar have no branch on record and
+    /// fall back to a probe.
+    pub worktree_branch: Option<String>,
     pub bridge: PtyBridge,
 }
 
@@ -66,6 +71,11 @@ pub enum SessionError {
     /// 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::InTheWay),
+    /// A forced kill (#81) records the retained worktree *before* tearing
+    /// anything down; if that write fails nothing was destroyed, and the
+    /// error says so rather than silently dropping unrecorded work.
+    #[error("could not record the retained worktree: {0}")]
+    RetainFailed(String),
 }
 
 impl SessionError {
@@ -78,6 +88,7 @@ impl SessionError {
             SessionError::NotFound(_) => "not_found",
             SessionError::InvalidEnv(_) => "invalid_env",
             SessionError::KillGuarded(_) => "kill_guarded",
+            SessionError::RetainFailed(_) => "retain_failed",
         };
         let unsaved_work = match self {
             SessionError::KillGuarded(b) => Some(*b),
@@ -110,6 +121,9 @@ struct Inner {
     /// `None` when not wired (tests, or before `with_spawn_history`); a present
     /// but disabled (`0`-day) history no-ops internally.
     spawn_history: Option<SpawnHistory>,
+    /// Retained-worktree store (#78). `None` when not wired (tests); a forced
+    /// kill (#81) without one fails rather than destroying unrecorded work.
+    retained: Option<crate::retained_store::RetainedStore>,
     sessions: Mutex<HashMap<Uuid, SessionRecord>>,
     events: broadcast::Sender<CatalogEvent>,
 }
@@ -148,6 +162,7 @@ impl SessionManager {
                 fifo_dir,
                 replay_bytes,
                 spawn_history: None,
+                retained: None,
                 sessions: Mutex::new(HashMap::new()),
                 events,
             }),
@@ -170,6 +185,16 @@ impl SessionManager {
         self
     }
 
+    /// Attach the retained-worktree store (#78). A forced kill (#81) needs it
+    /// to record what it retained; without one, forcing a guarded kill fails
+    /// instead of destroying unrecorded work.
+    pub fn with_retained_store(mut self, store: crate::retained_store::RetainedStore) -> Self {
+        let inner = Arc::get_mut(&mut self.inner)
+            .expect("with_retained_store must be called before the SessionManager is cloned");
+        inner.retained = Some(store);
+        self
+    }
+
     /// Recent working dirs for the spawn form's picker (#24), newest-first and
     /// deduped by dir. Empty when no history is wired or it's disabled.
     pub fn recent_dirs(&self) -> Vec<RecentDir> {
@@ -340,6 +365,7 @@ impl SessionManager {
                     fifo_path,
                     worktree_path,
                     worktree_base_repo,
+                    worktree_branch: req.worktree.as_ref().map(|w| w.branch.clone()),
                     bridge,
                 },
             );
@@ -391,11 +417,17 @@ impl SessionManager {
     /// work, so ending a session that still matters becomes a deliberate
     /// `--force`, which retains rather than destroys (WORKTREES.md).
     ///
+    /// With `force` (#81) the refusal — and nothing else — is overridden:
+    /// the session ends and the guarded worktree is retained into the store
+    /// with reason `force-killed`, never removed. The outcome names what was
+    /// kept so a client can say where the work went. A tree whose guard is
+    /// clear never needed the override; force removes it as usual.
+    ///
     /// 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) = {
+    pub async fn kill(&self, id: Uuid, force: bool) -> Result<KillOutcome, SessionError> {
+        let (worktree, alive, known_branch) = {
             let sessions = self.inner.sessions.lock().await;
             match sessions.get(&id) {
                 None => return Err(SessionError::NotFound(id)),
@@ -405,26 +437,75 @@ impl SessionManager {
                         .clone()
                         .zip(record.worktree_path.clone()),
                     record.session.status == SessionStatus::Running,
+                    record.worktree_branch.clone(),
                 ),
             }
         };
-        // 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_probe::in_the_way(&path))
-                .await
-                .map_err(|e| SessionError::Worktree(crate::worktree::WorktreeError::from(e)))?;
-            if !probe.is_clear() {
-                return Err(SessionError::KillGuarded(probe));
+        // The probe runs before anything is torn down: both refusing (#79)
+        // and recording the retention (#81) must see the tree as it stands,
+        // and a refused kill leaves the session running as the operator left
+        // it.
+        let probe = match &worktree {
+            Some((_, path)) => {
+                let path = path.clone();
+                Some(
+                    tmux_blocking(move || crate::worktree_probe::in_the_way(&path))
+                        .await
+                        .map_err(|e| {
+                            SessionError::Worktree(crate::worktree::WorktreeError::from(e))
+                        })?,
+                )
             }
+            None => None,
+        };
+        let guarded = probe.as_ref().is_some_and(|p| !p.is_clear());
+        if guarded && !force {
+            return Err(SessionError::KillGuarded(probe.expect("guarded ⇒ probed")));
         }
+
+        // Record the retention BEFORE tearing down: a failed store write then
+        // leaves the session running and every artifact untouched, instead of
+        // ending a session whose work outlives it unrecorded.
+        let mut retained = None;
+        if guarded {
+            let store =
+                self.inner.retained.clone().ok_or_else(|| {
+                    SessionError::RetainFailed("no retained store is wired".into())
+                })?;
+            let (base_repo, path) = worktree.as_ref().expect("guarded ⇒ worktree");
+            let branch = known_branch
+                .or_else(|| crate::worktree_probe::current_branch(path))
+                .unwrap_or_default();
+            let entry = {
+                let store = store.clone();
+                let base_repo = base_repo.clone();
+                let path = path.clone();
+                tmux_blocking(move || {
+                    store.retain(&path, &base_repo, &branch, RetainedReason::ForceKilled)
+                })
+                .await
+                .map_err(|e| SessionError::RetainFailed(e.to_string()))?
+            };
+            retained = Some((entry, probe.expect("guarded ⇒ probed")));
+        }
+
         let removed = {
             let mut sessions = self.inner.sessions.lock().await;
             sessions.remove(&id)
         };
         let record = removed.ok_or(SessionError::NotFound(id))?;
-        cleanup_record(&self.inner, id, record, alive).await;
-        Ok(())
+        cleanup_record(&self.inner, id, record, alive, retained.is_some()).await;
+        Ok(KillOutcome {
+            retained: retained.map(|(entry, in_the_way)| RetainedWorktree {
+                id: entry.id,
+                path: entry.path,
+                base_repo: entry.base_repo,
+                branch: entry.branch,
+                reason: entry.reason,
+                retained_at: entry.retained_at,
+                in_the_way,
+            }),
+        })
     }
 
     /// Spawn a background task that polls tmux every `interval` and reaps any
@@ -511,6 +592,9 @@ impl SessionManager {
                     // 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()),
+                    // The sidecar carries no branch; a forced kill of a
+                    // recovered session probes git for it at retain time.
+                    worktree_branch: None,
                     bridge,
                 },
             );
@@ -750,7 +834,17 @@ async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
 /// gone from the authoritative in-memory map, so a stray FIFO or sidecar can't
 /// resurrect it. `kill_tmux` is `true` for an explicit kill and `false` for the
 /// liveness reaper (tmux already lost the session).
-async fn cleanup_record(inner: &Arc<Inner>, id: Uuid, record: SessionRecord, kill_tmux: bool) {
+///
+/// `retain_worktree` is `true` for a forced kill (#81) that retained the
+/// worktree instead of removing it: the store entry is already written, so
+/// only the removal is skipped.
+async fn cleanup_record(
+    inner: &Arc<Inner>,
+    id: Uuid,
+    record: SessionRecord,
+    kill_tmux: bool,
+    retain_worktree: bool,
+) {
     if kill_tmux {
         let tmux = inner.tmux.clone();
         let _ = tmux_blocking(move || tmux.kill_session(id)).await;
@@ -759,11 +853,18 @@ 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.
     if let (Some(base), Some(path)) = (&record.worktree_base_repo, &record.worktree_path) {
-        if let Err(e) = inner.worktree_mgr.remove(base, path) {
+        if retain_worktree {
+            tracing::info!(
+                %id,
+                path = %path.display(),
+                "forced kill: worktree retained in the store"
+            );
+        } else if let Err(e) = inner.worktree_mgr.remove(base, path) {
+            // 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.
             tracing::warn!(
                 %id,
                 path = %path.display(),

crates/maestro-daemon/src/worktree_probe.rs

@@ -90,6 +90,14 @@ pub fn reclaim(base_repo: &Path, path: &Path) -> Result<(), ProbeError> {
     .map(|_| ())
 }
 
+/// Branch checked out at `path`. Sessions adopted from a sidecar carry no
+/// branch on record, so a forced kill (#81) asks the tree itself when it
+/// needs one for the retained store. `None` when git cannot answer.
+pub fn current_branch(path: &Path) -> Option<String> {
+    let out = run_git(path, ["rev-parse", "--abbrev-ref", "HEAD"]).ok()?;
+    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
+}
+
 fn run_git<I, S>(dir: &Path, args: I) -> Result<std::process::Output, ProbeError>
 where
     I: IntoIterator<Item = S>,

crates/maestro-daemon/tests/attach.rs

@@ -122,7 +122,7 @@ async fn pty_round_trip_through_real_tmux() {
         "marker not seen in {} bytes",
         got.len()
     );
-    let _ = h.manager.kill(id).await;
+    let _ = h.manager.kill(id, false).await;
 }
 
 #[tokio::test]
@@ -170,7 +170,7 @@ async fn multi_attach_broadcasts_to_every_client() {
         "client B missed marker"
     );
 
-    let _ = h.manager.kill(id).await;
+    let _ = h.manager.kill(id, false).await;
 }
 
 #[tokio::test]
@@ -219,7 +219,7 @@ async fn sends_close_frame_when_session_is_killed() {
     // give the broadcast subscriber a moment to register before killing.
     tokio::time::sleep(Duration::from_millis(100)).await;
 
-    h.manager.kill(id).await.unwrap();
+    h.manager.kill(id, false).await.unwrap();
 
     let mut saw_close = false;
     let deadline = std::time::Instant::now() + Duration::from_secs(2);
@@ -267,7 +267,7 @@ async fn ping_text_frame_gets_pong() {
         }
     }
     assert!(saw_pong, "no Pong frame received");
-    let _ = h.manager.kill(id).await;
+    let _ = h.manager.kill(id, false).await;
 }
 
 #[tokio::test]

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

@@ -176,6 +176,11 @@ impl DaemonFixture {
             manager =
                 manager.with_spawn_history(SpawnHistory::new(Self::history_path(&state_dir), days));
         }
+        // Same wiring as production: the manager records retained worktrees
+        // into the same dir the API reads back from (#78/#81).
+        let retained =
+            maestro_daemon::retained_store::RetainedStore::new(Self::retained_path(&state_dir));
+        manager = manager.with_retained_store(retained.clone());
         Self {
             tmux,
             manager,
@@ -187,6 +192,10 @@ impl DaemonFixture {
         state_dir.path().join("spawn-history.jsonl")
     }
 
+    fn retained_path(state_dir: &TempDir) -> PathBuf {
+        state_dir.path().join("retained-worktrees")
+    }
+
     pub fn spawn_history_path(&self) -> PathBuf {
         Self::history_path(&self.state_dir)
     }

crates/maestro-daemon/tests/local_api.rs

@@ -25,6 +25,13 @@ struct Harness {
     _fx: DaemonFixture,
 }
 
+impl Harness {
+    /// Store over the same dir the manager records into.
+    fn fx_retained(&self) -> maestro_daemon::retained_store::RetainedStore {
+        self._fx.retained_store()
+    }
+}
+
 async fn spawn(hostname: &str) -> Harness {
     spawn_with(
         hostname,
@@ -356,7 +363,6 @@ async fn delete_a_session_whose_worktree_holds_unsaved_work_returns_409_with_the
             worktree: Some(WorktreeSpec {
                 base_repo: repo.path().to_path_buf(),
                 branch: "feat/guarded".into(),
-                cleanup_on_kill: true,
                 create_branch: true,
             }),
         })
@@ -386,6 +392,61 @@ async fn delete_a_session_whose_worktree_holds_unsaved_work_returns_409_with_the
     assert!(h.manager.has(session.id).await, "the session keeps running");
 }
 
+/// `?force=true` on the wire (#81): the refusal is overridden, the session
+/// ends, and the answer is 200 with the retained worktree named — path,
+/// branch, reason — while the directory survives on disk.
+#[tokio::test]
+async fn delete_with_force_ends_the_session_and_answers_what_was_retained() {
+    let h = spawn("naps-laptop").await;
+    let repo = tempfile::TempDir::new().unwrap();
+    common::init_repo(repo.path());
+    let wt_path = repo
+        .path()
+        .join("worktrees")
+        .join("feat")
+        .join("guarded")
+        .to_path_buf();
+    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(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .unwrap();
+    std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
+
+    let resp = reqwest::Client::new()
+        .delete(url(h.addr, &format!("/api/sessions/{}", session.id)))
+        .query(&[("force", "true")])
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::OK);
+    let body: maestro_protocol::KillOutcome = resp.json().await.unwrap();
+    let retained = body.retained.expect("force names what was kept");
+    assert_eq!(retained.path, wt_path);
+    assert_eq!(retained.branch, "feat/guarded");
+    assert_eq!(
+        retained.reason,
+        maestro_protocol::RetainedReason::ForceKilled
+    );
+
+    // The tree would have blocked; force must not have removed it.
+    assert!(wt_path.exists(), "a forced kill never removes the worktree");
+    // And the store entry exists, so reclaim can find it (#80).
+    let all = h.fx_retained().load_all().unwrap();
+    assert_eq!(all.len(), 1);
+    assert_eq!(all[0].id, retained.id);
+}
+
 #[tokio::test]
 async fn attach_ws_streams_pty_bytes() {
     let h = spawn("naps-laptop").await;
@@ -476,7 +537,7 @@ async fn events_ws_sends_a_snapshot_then_streams_deltas() {
         other => panic!("expected SessionAdded, got {other:?}"),
     }
 
-    h.manager.kill(created.id).await.expect("kill");
+    h.manager.kill(created.id, false).await.expect("kill");
 
     // Activity ticks may interleave; the removal is what we are waiting for.
     let deadline = tokio::time::Instant::now() + Duration::from_secs(5);

crates/maestro-daemon/tests/session_decisions.rs

@@ -211,7 +211,7 @@ async fn killing_a_dead_session_dismisses_it_without_touching_tmux() {
     fx.manager.start_liveness_watcher(Duration::from_millis(25));
     wait_for_status(&fx.manager, s.id, SessionStatus::Dead).await;
 
-    fx.manager.kill(s.id).await.expect("dismiss");
+    fx.manager.kill(s.id, false).await.expect("dismiss");
 
     assert!(fx.manager.snapshot().await.is_empty());
     assert!(
@@ -371,7 +371,7 @@ async fn killing_an_unknown_session_is_reported_as_not_found() {
     let fx = Fx::new();
     let err = fx
         .manager
-        .kill(uuid::Uuid::new_v4())
+        .kill(uuid::Uuid::new_v4(), false)
         .await
         .expect_err("should fail");
     assert_eq!(err.to_error_info().code, "not_found");

crates/maestro-daemon/tests/session_manager.rs

@@ -44,7 +44,7 @@ async fn create_then_kill_round_trip() {
     // FIFO should also exist
     assert!(fx.fifo_dir().join(format!("{}.fifo", session.id)).exists());
 
-    fx.manager.kill(session.id).await.expect("kill");
+    fx.manager.kill(session.id, false).await.expect("kill");
     assert!(!fx.manager.has(session.id).await);
     assert!(!fx
         .sidecar_dir()
@@ -79,7 +79,7 @@ async fn create_appends_to_spawn_history() {
     assert_eq!(recents[0].cwd, cwd.path());
     assert_eq!(recents[0].last_command, "sleep 30");
 
-    fx.manager.kill(session.id).await.expect("kill");
+    fx.manager.kill(session.id, false).await.expect("kill");
     // History is durable — it survives the kill that deletes the sidecar.
     assert_eq!(fx.manager.recent_dirs().len(), 1);
 }
@@ -185,7 +185,7 @@ async fn create_captures_initial_output_in_replay_buffer() {
         "first-line marker never reached the replay buffer — pipe-pane raced past the child's initial output",
     );
 
-    fx.manager.kill(s.id).await.unwrap();
+    fx.manager.kill(s.id, false).await.unwrap();
 }
 
 /// Regression for NAP-228: after `recover`, PTY output must reach new
@@ -251,7 +251,7 @@ async fn recover_re_pipes_pane_so_output_reaches_subscribers() {
         String::from_utf8_lossy(&buf),
     );
 
-    revived.kill(s.id).await.unwrap();
+    revived.kill(s.id, false).await.unwrap();
 }
 
 #[tokio::test]
@@ -300,7 +300,7 @@ async fn pty_broadcast_delivers_bytes_to_subscribers() {
     assert!(buf_a.windows(want.len()).any(|w| w == want), "A missed");
     assert!(buf_b.windows(want.len()).any(|w| w == want), "B missed");
 
-    fx.manager.kill(s.id).await.unwrap();
+    fx.manager.kill(s.id, false).await.unwrap();
     let _ = (cwd, PathBuf::from("/"));
 }
 
@@ -359,7 +359,7 @@ async fn liveness_watcher_marks_dead_sessions_and_keeps_them_until_dismissed() {
     );
 
     // Dismissing it is what finally releases the artifacts.
-    fx.manager.kill(s.id).await.expect("dismiss");
+    fx.manager.kill(s.id, false).await.expect("dismiss");
     assert!(!fx.manager.has(s.id).await);
     assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
     assert!(!fx.fifo_dir().join(format!("{}.fifo", s.id)).exists());
@@ -385,7 +385,6 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
             worktree: Some(WorktreeSpec {
                 base_repo: repo.path().to_path_buf(),
                 branch: "feat/keep".into(),
-                cleanup_on_kill: false,
                 create_branch: true,
             }),
         })
@@ -398,7 +397,7 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
     init_bare_repo(origin.path());
     push_all_to_origin(repo.path(), origin.path());
 
-    fx.manager.kill(s.id).await.expect("kill");
+    fx.manager.kill(s.id, false).await.expect("kill");
     assert!(!wt_path.exists(), "worktree must be removed on kill");
 }
 
@@ -423,7 +422,6 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
             worktree: Some(WorktreeSpec {
                 base_repo: repo.path().to_path_buf(),
                 branch: "feat/guarded".into(),
-                cleanup_on_kill: true,
                 create_branch: true,
             }),
         })
@@ -432,7 +430,11 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
     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 err = fx
+        .manager
+        .kill(s.id, false)
+        .await
+        .expect_err("kill must refuse");
     let SessionError::KillGuarded(breakdown) = err else {
         panic!("expected KillGuarded, got {err:?}");
     };
@@ -456,7 +458,10 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
     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");
+    fx.manager
+        .kill(s.id, false)
+        .await
+        .expect("kill after saving");
     assert!(!fx.manager.has(s.id).await);
 }
 
@@ -480,14 +485,17 @@ async fn killing_refuses_until_the_branch_is_pushed() {
             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 err = fx
+        .manager
+        .kill(s.id, false)
+        .await
+        .expect_err("unpushed blocks");
     let SessionError::KillGuarded(breakdown) = err else {
         panic!("expected KillGuarded, got {err:?}");
     };
@@ -499,11 +507,116 @@ async fn killing_refuses_until_the_branch_is_pushed() {
     init_bare_repo(origin.path());
     push_all_to_origin(repo.path(), origin.path());
 
-    fx.manager.kill(s.id).await.expect("pushed branch kills");
+    fx.manager
+        .kill(s.id, false)
+        .await
+        .expect("pushed branch kills");
     assert!(!wt_path.exists());
     assert!(!fx.manager.has(s.id).await);
 }
 
+/// `--force` overrides the refusal and nothing else (#81): the session ends,
+/// but the guarded worktree is RETAINED — never removed — and enters the
+/// retained store with reason `force-killed`. The outcome names what was
+/// kept, so a client can say where the work went.
+#[tokio::test]
+async fn force_killing_a_guarded_worktree_retains_it_in_the_store() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    init_repo(repo.path());
+    let wt_path = repo.path().join("worktrees").join("feat").join("forced");
+
+    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/forced".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+    std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
+
+    // Without force the same kill is refused (#79).
+    assert!(fx.manager.kill(s.id, false).await.is_err());
+
+    let outcome = fx
+        .manager
+        .kill(s.id, true)
+        .await
+        .expect("force overrides the refusal");
+
+    // The tree would have blocked, so force must NOT have removed it...
+    assert!(
+        wt_path.exists(),
+        "a forced kill never removes a tree that would have blocked"
+    );
+    // ...but the session itself still ends.
+    assert!(!fx.manager.has(s.id).await);
+    assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+
+    let retained = outcome.retained.expect("the outcome names what was kept");
+    assert_eq!(retained.path, wt_path);
+    assert_eq!(retained.branch, "feat/forced");
+    assert_eq!(
+        retained.reason,
+        maestro_protocol::RetainedReason::ForceKilled
+    );
+    assert!(
+        retained.in_the_way.uncommitted_files >= 1,
+        "the outcome carries what blocked the unforced kill"
+    );
+
+    // The store holds the same entry, so reclaim can find it later (#80).
+    let all = fx.retained_store().load_all().expect("load_all");
+    assert_eq!(all.len(), 1);
+    assert_eq!(all[0].id, retained.id);
+    assert_eq!(all[0].path, wt_path);
+    assert_eq!(all[0].branch, "feat/forced");
+}
+
+/// Force overrides the *refusal*, not ordinary cleanup (#81): a tree whose
+/// guard is clear never needed the override, so a forced kill removes it as
+/// usual and retains nothing.
+#[tokio::test]
+async fn force_on_a_clear_worktree_removes_it_as_usual() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    init_repo(repo.path());
+    let wt_path = repo.path().join("worktrees").join("feat").join("clear");
+
+    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/clear".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+
+    let origin = TempDir::new().unwrap();
+    init_bare_repo(origin.path());
+    push_all_to_origin(repo.path(), origin.path());
+
+    let outcome = fx.manager.kill(s.id, true).await.expect("kill");
+    assert!(!wt_path.exists(), "a clear tree needs no override");
+    assert_eq!(outcome.retained, None);
+    assert!(fx.retained_store().load_all().unwrap().is_empty());
+}
+
 /// Ignored files NEVER block (#79): build output like `target/` exists in
 /// every Rust checkout, and an ignored-only worktree stays killable.
 #[tokio::test]
@@ -530,7 +643,6 @@ async fn killing_an_ignored_only_worktree_succeeds() {
             worktree: Some(WorktreeSpec {
                 base_repo: repo.path().to_path_buf(),
                 branch: "feat/rusty".into(),
-                cleanup_on_kill: true,
                 create_branch: true,
             }),
         })
@@ -543,7 +655,7 @@ async fn killing_an_ignored_only_worktree_succeeds() {
     push_all_to_origin(repo.path(), origin.path());
 
     fx.manager
-        .kill(s.id)
+        .kill(s.id, false)
         .await
         .expect("ignored files never block");
     assert!(!wt_path.exists());
@@ -587,5 +699,5 @@ async fn liveness_watcher_leaves_running_sessions_alone() {
     tokio::time::sleep(Duration::from_millis(400)).await;
     assert!(fx.manager.has(s.id).await, "live session got reaped");
 
-    fx.manager.kill(s.id).await.unwrap();
+    fx.manager.kill(s.id, false).await.unwrap();
 }

crates/maestro-e2e/src/client.rs

@@ -61,7 +61,7 @@ impl TestClient {
     }
 
     pub async fn kill_session(&self, id: Uuid) -> Result<(), ClientError> {
-        Ok(self.daemon.kill_session(id).await?)
+        Ok(self.daemon.kill_session(id, false).await.map(|_| ())?)
     }
 
     pub async fn list_projects(&self) -> Result<Vec<Project>, ClientError> {

crates/maestro-protocol/src/client.rs

@@ -16,7 +16,7 @@ use uuid::Uuid;
 use crate::routes::{self, UrlError};
 use crate::{
     ApiError, BranchInfo, CreateSessionRequest, DaemonInfo, DirListing, ErrorInfo, GitRoot,
-    Project, RecentDirs, RetainedWorktree, Session,
+    KillOutcome, Project, RecentDirs, RetainedWorktree, Session,
 };
 
 /// Time budget for establishing a TCP connection to the daemon.
@@ -114,12 +114,24 @@ impl DaemonClient {
         self.post(routes::SESSIONS, req).await
     }
 
-    pub async fn kill_session(&self, id: Uuid) -> Result<(), ClientError> {
+    /// Kill a session. With `force`, the daemon overrides the kill refusal
+    /// (#79) and retains the worktree instead of removing it (#81); the
+    /// outcome then names what was kept and where.
+    pub async fn kill_session(&self, id: Uuid, force: bool) -> Result<KillOutcome, ClientError> {
+        let query: &[(&str, &str)] = if force {
+            &[(routes::FORCE_QUERY, "true")]
+        } else {
+            &[]
+        };
         let resp = self
-            .send(Method::DELETE, &routes::session(id), &[], None::<&()>)
+            .send(Method::DELETE, &routes::session(id), query, None::<&()>)
             .await?;
-        check(resp).await?;
-        Ok(())
+        let resp = check(resp).await?;
+        // An unforced kill keeps its historical `204 No Content`.
+        if resp.status() == reqwest::StatusCode::NO_CONTENT {
+            return Ok(KillOutcome { retained: None });
+        }
+        json(resp).await
     }
 
     pub async fn daemon_info(&self) -> Result<DaemonInfo, ClientError> {

crates/maestro-protocol/src/lib.rs

@@ -119,11 +119,6 @@ pub enum ActivityState {
 pub struct WorktreeSpec {
     pub base_repo: PathBuf,
     pub branch: String,
-    /// Kept on the wire for CLI compatibility (#56) but no longer a
-    /// user-facing choice: the daemon always cleans up on kill, guarded
-    /// against unsaved work. Defaults to `true`.
-    #[serde(default = "default_true")]
-    pub cleanup_on_kill: bool,
     /// When false, `branch` must already exist and is checked out as-is
     /// (#56); when true (the default, and what every payload meant before
     /// the field existed) the daemon creates it with `worktree add -b`.
@@ -195,6 +190,19 @@ pub struct RetainedWorktree {
     pub in_the_way: InTheWay,
 }
 
+/// Body of a successful forced `DELETE /api/sessions/:id?force=true` (#81).
+/// A forced kill ends the session and retains its worktree instead of
+/// removing it; this names what was kept, where, and why, so a client can say
+/// where the work went rather than leaving the operator to wonder.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct KillOutcome {
+    /// Set when the worktree was retained with reason `force-killed`; `None`
+    /// when there was nothing to retain — no worktree at all, or one whose
+    /// guard was clear, which a forced kill removes as usual.
+    #[serde(default)]
+    pub retained: Option<RetainedWorktree>,
+}
+
 impl std::fmt::Display for InTheWay {
     /// "3 uncommitted files, 2 unpushed commits" — zero parts are omitted;
     /// all-zero renders "no unsaved work". This is the phrasing every client
@@ -581,7 +589,6 @@ mod tests {
             worktree: Some(WorktreeSpec {
                 base_repo: PathBuf::from("/home/naps62/projects/maestro"),
                 branch: "feat/foo".into(),
-                cleanup_on_kill: true,
                 create_branch: true,
             }),
         };
@@ -611,7 +618,6 @@ mod tests {
         });
         let spec: WorktreeSpec = serde_json::from_value(json).unwrap();
         assert!(spec.create_branch);
-        assert!(spec.cleanup_on_kill);
     }
 
     #[test]
@@ -619,7 +625,6 @@ mod tests {
         let spec = WorktreeSpec {
             base_repo: PathBuf::from("/work"),
             branch: "feat/foo".into(),
-            cleanup_on_kill: true,
             create_branch: false,
         };
         assert_eq!(spec, round_trip(&spec));
@@ -679,6 +684,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn kill_outcome_round_trips_a_retained_worktree() {
+        let outcome = KillOutcome {
+            retained: Some(sample_retained_worktree()),
+        };
+        assert_eq!(outcome, round_trip(&outcome));
+    }
+
+    /// A kill with nothing to retain — no worktree, or a clean one removed as
+    /// usual — decodes from an absent field.
+    #[test]
+    fn kill_outcome_defaults_to_nothing_retained() {
+        let outcome: KillOutcome = serde_json::from_value(serde_json::json!({})).unwrap();
+        assert_eq!(outcome.retained, None);
+    }
+
     #[test]
     fn catalog_event_round_trips_and_tags() {
         let session = sample_session();

crates/maestro-protocol/src/routes.rs

@@ -38,6 +38,10 @@ pub const PATH_QUERY: &str = "path";
 /// Name of the query parameter [`NAMES`] takes.
 pub const COUNT_QUERY: &str = "count";
 
+/// Name of the boolean query parameter `DELETE /api/sessions/:id` takes (#81).
+/// `force=true` overrides the kill refusal and retains the worktree.
+pub const FORCE_QUERY: &str = "force";
+
 /// `DELETE /api/sessions/:id`.
 pub fn session(id: Uuid) -> String {
     format!("{SESSIONS}/{id}")

crates/maestro-tui/src/action.rs

@@ -43,6 +43,8 @@ pub enum Action {
     /// resolved; unresolvable defaults open a pre-filled draft instead.
     FastForwardSpawn,
     KillHighlighted,
+    /// Open the retained-worktrees view (#85).
+    ShowWorktrees,
 
     // Tabs
     NewTab,
@@ -84,6 +86,7 @@ impl Action {
             "NewDraftPane" => return Ok(Action::NewDraftPane),
             "FastForwardSpawn" => return Ok(Action::FastForwardSpawn),
             "KillHighlighted" => return Ok(Action::KillHighlighted),
+            "ShowWorktrees" => return Ok(Action::ShowWorktrees),
             "NewTab" => return Ok(Action::NewTab),
             "CloseTab" => return Ok(Action::CloseTab),
             "NextTab" => return Ok(Action::NextTab),

crates/maestro-tui/src/app.rs

@@ -18,7 +18,9 @@ use std::time::Duration;
 use chrono::Utc;
 use crossterm::event::{Event as CtEvent, EventStream};
 use futures_util::StreamExt;
-use maestro_protocol::{routes, BranchInfo, CreateSessionRequest, DaemonClient, NameBatch};
+use maestro_protocol::{
+    routes, BranchInfo, CreateSessionRequest, DaemonClient, NameBatch, RetainedWorktree,
+};
 use ratatui::backend::CrosstermBackend;
 use ratatui::Terminal;
 use uuid::Uuid;
@@ -37,6 +39,7 @@ use crate::session_task::{SessionInput, SessionTask};
 use crate::sidebar::Sidebar;
 use crate::state::{AppState, Focus, OverlayKind, PaneRef};
 use crate::tabs::TabBar;
+use crate::worktrees::WorktreesView;
 use crate::TuiError;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -55,7 +58,8 @@ pub struct App {
     help: HelpOverlay,
     chord: ChordState,
     daemon: DaemonClient,
-    /// Results of draft data loads, delivered back to the event loop.
+    /// Results of draft data loads (and the worktrees view fetch, #85),
+    /// 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
@@ -66,6 +70,9 @@ pub struct App {
     /// Direct HTTP for the one endpoint [`DaemonClient`] doesn't cover yet:
     /// `GET /api/names` (#64).
     http: reqwest::Client,
+    /// Entries of the retained-worktrees view (#85). Daemon data, kept here
+    /// rather than in `AppState` so the overlay kind stays payload-free.
+    worktrees: WorktreesView,
     region: RegionMap,
     last_sent_size: HashMap<Uuid, (u16, u16)>,
     clicks: ClickTracker,
@@ -109,6 +116,11 @@ pub enum Effect {
     },
     /// Fetch the draft target's branches from `/api/branches` (#65).
     LoadBranches(usize),
+    /// Fetch `/api/worktrees` for the retained-worktrees view (#85).
+    LoadWorktrees,
+    /// Reclaim one retained worktree (#85) — removes its directory; the
+    /// branch is never deleted.
+    ReclaimWorktree(Uuid),
 }
 
 impl App {
@@ -132,6 +144,7 @@ impl App {
             chord: ChordState::new(chord_timeout),
             daemon,
             http,
+            worktrees: WorktreesView::default(),
             draft_tx,
             draft_rx,
             region: RegionMap::default(),
@@ -225,6 +238,8 @@ impl App {
                     self.spawn_probe_git_root(tab, seq, path)
                 }
                 Effect::LoadBranches(tab) => self.spawn_load_branches(tab),
+                Effect::LoadWorktrees => self.spawn_load_worktrees(),
+                Effect::ReclaimWorktree(id) => self.submit_reclaim(id).await,
                 Effect::Forward { id, bytes } => {
                     if let Some(handle) = self.emulators.get(id) {
                         let _ = handle.tx.send(SessionInput::Bytes(bytes)).await;
@@ -247,6 +262,44 @@ impl App {
                 }
                 _ => (OverlayDecision::Consumed, Vec::new()),
             },
+            Some(OverlayKind::Worktrees) => match key {
+                InputKey::Char { c: 'j', .. } | InputKey::Down => {
+                    self.worktrees.move_highlight(1);
+                    (OverlayDecision::Consumed, Vec::new())
+                }
+                InputKey::Char { c: 'k', .. } | InputKey::Up => {
+                    self.worktrees.move_highlight(-1);
+                    (OverlayDecision::Consumed, Vec::new())
+                }
+                InputKey::Char { c: 'r', .. } => {
+                    if let Some(wt) = self.worktrees.selected() {
+                        self.state.show_overlay(OverlayKind::ReclaimConfirm {
+                            id: wt.id,
+                            branch: wt.branch.clone(),
+                            // Shared phrasing: InTheWay's Display impl is what
+                            // the kill refusal and the web client use too.
+                            blockers: wt.in_the_way.to_string(),
+                        });
+                    }
+                    (OverlayDecision::Consumed, Vec::new())
+                }
+                InputKey::Char { c: 'q', .. } | InputKey::Esc => {
+                    self.state.dismiss_overlay();
+                    (OverlayDecision::Consumed, Vec::new())
+                }
+                _ => (OverlayDecision::Consumed, Vec::new()),
+            },
+            Some(OverlayKind::ReclaimConfirm { id, .. }) => match key {
+                InputKey::Char { c: 'y', .. } => {
+                    self.state.dismiss_overlay();
+                    (OverlayDecision::Consumed, vec![Effect::ReclaimWorktree(id)])
+                }
+                InputKey::Char { c: 'n', .. } | InputKey::Esc => {
+                    self.state.show_overlay(OverlayKind::Worktrees);
+                    (OverlayDecision::Consumed, Vec::new())
+                }
+                _ => (OverlayDecision::Consumed, Vec::new()),
+            },
             Some(OverlayKind::Help) => {
                 self.state.dismiss_overlay();
                 (OverlayDecision::Consumed, Vec::new())
@@ -317,6 +370,10 @@ impl App {
                     self.state.show_overlay(OverlayKind::KillConfirm(sid));
                 }
             }
+            Action::ShowWorktrees => {
+                self.state.show_overlay(OverlayKind::Worktrees);
+                effects.push(Effect::LoadWorktrees);
+            }
         }
         effects
     }
@@ -505,13 +562,22 @@ impl App {
             self.fast_forward_spawn(info, projects, names).await;
             return;
         }
+        if let DraftUpdate::WorktreesLoaded {
+            worktrees,
+            home_dir,
+        } = update
+        {
+            self.worktrees.apply(worktrees);
+            self.worktrees.home_dir = home_dir;
+            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!(),
+            DraftUpdate::FastForward { .. } | DraftUpdate::WorktreesLoaded { .. } => 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
@@ -566,7 +632,7 @@ impl App {
             DraftUpdate::Branches { cwd, branches, .. } => {
                 draft.set_branches(&cwd, branches);
             }
-            DraftUpdate::FastForward { .. } => unreachable!(),
+            DraftUpdate::FastForward { .. } | DraftUpdate::WorktreesLoaded { .. } => unreachable!(),
         }
         if follow_up_branches {
             self.spawn_load_branches(tab_idx);
@@ -667,12 +733,50 @@ impl App {
     }
 
     async fn submit_kill(&mut self, sid: Uuid) {
-        match self.daemon.kill_session(sid).await {
-            Ok(()) => self.release_session(sid),
+        match self.daemon.kill_session(sid, false).await {
+            Ok(outcome) => {
+                if let Some(w) = outcome.retained {
+                    self.state
+                        .toast(format!("worktree retained: {}", w.path.display()));
+                }
+                self.release_session(sid)
+            }
             Err(e) => self.state.toast(format!("kill failed: {e}")),
         }
     }
 
+    /// Fetch the retained-worktree store without blocking the loop (#85) —
+    /// same off-loop pattern as the draft loaders.
+    fn spawn_load_worktrees(&self) {
+        let (daemon, _, _, tx) = self.loader_handles();
+        tokio::spawn(async move {
+            let (worktrees, info) = tokio::join!(daemon.list_worktrees(), daemon.daemon_info());
+            let _ = tx.send(DraftUpdate::WorktreesLoaded {
+                worktrees: worktrees.unwrap_or_default(),
+                home_dir: info.map(|i| i.home_dir).unwrap_or_default(),
+            });
+        });
+    }
+
+    /// Reclaim one retained worktree (#85): the directory goes, the branch
+    /// never does. The open view drops the entry so the list tells the truth
+    /// without waiting for a re-fetch.
+    async fn submit_reclaim(&mut self, id: Uuid) {
+        match self.daemon.reclaim_worktree(id).await {
+            Ok(()) => {
+                self.worktrees.remove(id);
+                self.state.toast("worktree reclaimed; branch kept");
+            }
+            Err(e) => {
+                let message = e
+                    .daemon_message()
+                    .map(String::from)
+                    .unwrap_or_else(|| e.to_string());
+                self.state.toast(format!("reclaim failed: {message}"));
+            }
+        }
+    }
+
     fn redraw(
         &mut self,
         terminal: &mut Terminal<CrosstermBackend<Stdout>>,
@@ -713,6 +817,7 @@ impl App {
             state: &self.state,
             draft,
             help: &self.help,
+            worktrees: Some(&self.worktrees),
         };
 
         let mut new_region = RegionMap::default();
@@ -857,6 +962,11 @@ enum DraftUpdate {
         projects: Option<Vec<maestro_protocol::Project>>,
         names: Vec<String>,
     },
+    /// The retained-worktree store arrived for the worktrees view (#85).
+    WorktreesLoaded {
+        worktrees: Vec<RetainedWorktree>,
+        home_dir: String,
+    },
 }
 
 /// `GET /api/names?count=N`. Free function: the spawned loaders have no `self`.
@@ -1509,4 +1619,162 @@ mod tests {
         app.dispatch(Action::KillHighlighted);
         assert!(matches!(app.state.overlay(), Some(OverlayKind::KillConfirm(s)) if *s == sid));
     }
+
+    // -- retained worktrees (#85) -------------------------------------------
+
+    fn sample_worktree(id: u128) -> maestro_protocol::RetainedWorktree {
+        use chrono::TimeZone;
+        maestro_protocol::RetainedWorktree {
+            id: Uuid::from_u128(id),
+            path: "/home/naps/tea/maestro/worktrees/feat/login".into(),
+            base_repo: "/home/naps/tea/maestro".into(),
+            branch: "feat/login".into(),
+            reason: maestro_protocol::RetainedReason::ForceKilled,
+            retained_at: chrono::Utc.with_ymd_and_hms(2026, 8, 24, 10, 0, 0).unwrap(),
+            in_the_way: maestro_protocol::InTheWay {
+                uncommitted_files: 2,
+                untracked_files: 1,
+                unpushed_commits: 3,
+            },
+        }
+    }
+
+    fn app_with_one_retained_worktree() -> App {
+        let mut app = make_app();
+        app.worktrees.home_dir = "/home/naps".into();
+        app.worktrees.apply(vec![sample_worktree(42)]);
+        app.state.show_overlay(OverlayKind::Worktrees);
+        app
+    }
+
+    #[test]
+    fn show_worktrees_opens_the_view_and_fetches() {
+        let mut app = make_app();
+        assert_eq!(
+            app.dispatch(Action::ShowWorktrees),
+            vec![Effect::LoadWorktrees]
+        );
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::Worktrees));
+    }
+
+    #[test]
+    fn r_over_the_highlighted_worktree_asks_for_a_confirmation() {
+        let mut app = app_with_one_retained_worktree();
+
+        let (decision, effects) = app.handle_overlay_input(&InputKey::char('r'));
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert!(effects.is_empty());
+        match app.state.overlay() {
+            Some(OverlayKind::ReclaimConfirm { id, branch, .. }) => {
+                assert_eq!(*id, Uuid::from_u128(42));
+                assert_eq!(branch, "feat/login");
+            }
+            other => panic!("expected a reclaim confirm, got {other:?}"),
+        }
+    }
+
+    /// The confirmation names what is in the way using the shared phrasing,
+    /// so the confirm step cannot drift from the list or the CLI.
+    #[test]
+    fn the_reclaim_confirmation_carries_the_shared_in_the_way_phrasing() {
+        let mut app = app_with_one_retained_worktree();
+        app.handle_overlay_input(&InputKey::char('r'));
+        match app.state.overlay() {
+            Some(OverlayKind::ReclaimConfirm { blockers, .. }) => {
+                assert_eq!(
+                    blockers,
+                    "2 uncommitted files, 1 untracked file, 3 unpushed commits"
+                );
+            }
+            other => panic!("expected a reclaim confirm, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn confirming_a_reclaim_asks_for_the_reclaim() {
+        let mut app = app_with_one_retained_worktree();
+        app.handle_overlay_input(&InputKey::char('r'));
+
+        let (decision, effects) = app.handle_overlay_input(&InputKey::char('y'));
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert_eq!(effects, vec![Effect::ReclaimWorktree(Uuid::from_u128(42))]);
+        assert!(app.state.overlay().is_none());
+    }
+
+    #[test]
+    fn declining_a_reclaim_returns_to_the_list() {
+        let mut app = app_with_one_retained_worktree();
+        app.handle_overlay_input(&InputKey::char('r'));
+
+        let (decision, effects) = app.handle_overlay_input(&InputKey::char('n'));
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert!(effects.is_empty());
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::Worktrees));
+    }
+
+    #[test]
+    fn j_and_k_move_the_highlight_inside_the_view() {
+        let mut app = make_app();
+        app.worktrees
+            .apply(vec![sample_worktree(1), sample_worktree(2)]);
+        // Distinct ids so movement is observable.
+        app.worktrees.items[1].branch = "other".into();
+        app.state.show_overlay(OverlayKind::Worktrees);
+
+        app.handle_overlay_input(&InputKey::char('j'));
+        assert_eq!(app.worktrees.selected().unwrap().branch, "other");
+        app.handle_overlay_input(&InputKey::char('k'));
+        assert_eq!(app.worktrees.selected().unwrap().branch, "feat/login");
+    }
+
+    #[tokio::test]
+    async fn loading_worktrees_fills_the_view_from_the_daemon() {
+        use axum::routing::{delete, 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/naps"}))
+        }
+        async fn worktrees() -> Json<serde_json::Value> {
+            Json(json!([{
+                "id": Uuid::from_u128(42).to_string(),
+                "path": "/home/naps/tea/maestro/worktrees/feat/login",
+                "base_repo": "/home/naps/tea/maestro",
+                "branch": "feat/login",
+                "reason": "force-killed",
+                "retained_at": "2026-08-24T10:00:00Z",
+                "in_the_way": {"uncommitted_files": 2, "untracked_files": 1, "unpushed_commits": 3},
+            }]))
+        }
+        async fn reclaim() -> Json<serde_json::Value> {
+            Json(json!(null))
+        }
+
+        let app_router = axum::Router::new()
+            .route(maestro_protocol::routes::INFO, get(info))
+            .route(maestro_protocol::routes::WORKTREES, get(worktrees))
+            .route("/api/worktrees/:id", delete(reclaim));
+        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::ShowWorktrees);
+        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_eq!(app.state.overlay(), Some(&OverlayKind::Worktrees));
+        assert_eq!(app.worktrees.items.len(), 1);
+        assert_eq!(app.worktrees.items[0].branch, "feat/login");
+        assert_eq!(app.worktrees.home_dir, "/home/naps");
+
+        // Reclaiming drops the entry from the open view.
+        app.submit_reclaim(Uuid::from_u128(42)).await;
+        assert!(app.worktrees.items.is_empty());
+    }
 }

crates/maestro-tui/src/config.rs

@@ -50,6 +50,7 @@ const DEFAULT_NORMAL: &[(&str, &str)] = &[
     // thing with every default resolved and no form.
     ("S", "FastForwardSpawn"),
     ("x", "KillHighlighted"),
+    ("w", "ShowWorktrees"),
     // Tabs
     ("ctrl-t", "NewTab"),
     ("g t", "NextTab"),
@@ -166,6 +167,10 @@ mod tests {
             cfg.keymap.resolve(Mode::Normal, "S"),
             Some(Action::FastForwardSpawn),
         );
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Normal, "w"),
+            Some(Action::ShowWorktrees),
+        );
     }
 
     #[test]

crates/maestro-tui/src/draft.rs

@@ -549,7 +549,6 @@ impl DraftPane {
                 WorktreeSpec {
                     base_repo,
                     branch: branch.to_string(),
-                    cleanup_on_kill: true,
                     create_branch: true,
                 }
             }
@@ -562,7 +561,6 @@ impl DraftPane {
                 WorktreeSpec {
                     base_repo,
                     branch: name,
-                    cleanup_on_kill: true,
                     create_branch: false,
                 }
             }
@@ -1186,7 +1184,7 @@ fn draw_text_field(
 /// `~` abbreviation plus leading-segment collapsing, matching the web UI's
 /// `abbreviateCwd` + `abbreviateFolderName`: `/home/u/tea/Maestro` renders as
 /// `/h/u/t/Maestro` given home `/home/u`.
-fn abbreviate_path(path: &Path, home: &str) -> String {
+pub(crate) fn abbreviate_path(path: &Path, home: &str) -> String {
     let raw = path.to_string_lossy();
     let abbreviated = if !home.is_empty() {
         if raw == home {
@@ -1689,7 +1687,6 @@ mod tests {
         assert_eq!(wt.base_repo, PathBuf::from("/repos/maestro"));
         assert_eq!(wt.branch, "crimson-otter", "branch defaults to the name");
         assert!(wt.create_branch);
-        assert!(wt.cleanup_on_kill);
     }
 
     #[test]

crates/maestro-tui/src/fast_forward.rs

@@ -80,7 +80,6 @@ impl FastForwardDefaults {
                     .clone()
                     .unwrap_or_else(|| project.path.clone()),
                 branch: name.to_string(),
-                cleanup_on_kill: true,
                 create_branch: true,
             }),
         })

crates/maestro-tui/src/lib.rs

@@ -22,6 +22,7 @@ pub mod state;
 pub mod tabs;
 pub mod terminal;
 pub mod text_input;
+pub mod worktrees;
 
 use std::path::PathBuf;
 use std::time::Duration;

crates/maestro-tui/src/overlays.rs

@@ -82,7 +82,7 @@ impl Toast {
     }
 }
 
-fn centered(parent: Rect, w: u16, h: u16) -> Rect {
+pub(crate) fn centered(parent: Rect, w: u16, h: u16) -> Rect {
     let w = w.min(parent.width);
     let h = h.min(parent.height);
     Rect {

crates/maestro-tui/src/render.rs

@@ -15,6 +15,7 @@ use crate::pane::Pane;
 use crate::sidebar::Sidebar;
 use crate::state::{AppState, Focus, OverlayKind};
 use crate::tabs::TabBar;
+use crate::worktrees::{ReclaimConfirm, WorktreesView};
 
 /// Tagged regions for mouse hit-testing. The input router resolves a mouse
 /// coordinate to one of these via [`RegionMap::region_at`].
@@ -67,6 +68,8 @@ pub struct RenderInputs<'a> {
     pub draft: Option<&'a crate::draft::DraftPane>,
     pub state: &'a AppState,
     pub help: &'a HelpOverlay,
+    /// Retained-worktree entries for the worktrees view (#85).
+    pub worktrees: Option<&'a WorktreesView>,
 }
 
 /// Draw one frame. Returns the `RegionMap` the input router will consult for
@@ -153,6 +156,22 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
             inputs.help.render(f, area);
             map.modal = Some(area);
         }
+        Some(OverlayKind::Worktrees) => {
+            if let Some(view) = inputs.worktrees {
+                view.render(f, area);
+                map.modal = Some(area);
+            }
+        }
+        Some(OverlayKind::ReclaimConfirm {
+            branch, blockers, ..
+        }) => {
+            let rc = ReclaimConfirm {
+                branch: branch.clone(),
+                blockers: blockers.clone(),
+            };
+            rc.render(f, area);
+            map.modal = Some(area);
+        }
         Some(OverlayKind::Toast(text)) => {
             let t = Toast { text: text.clone() };
             t.render(f, area);
@@ -298,6 +317,7 @@ mod tests {
             draft: Some(draft),
             state: &state,
             help: &help,
+            worktrees: None,
         };
 
         let backend = ratatui::backend::TestBackend::new(80, 24);

crates/maestro-tui/src/state.rs

@@ -50,6 +50,17 @@ pub enum OverlayKind {
     KillConfirm(Uuid),
     Help,
     Toast(String),
+    /// The retained-worktrees view (#85); its entries live on `App` because
+    /// they are daemon data, not UI state.
+    Worktrees,
+    /// Reclaim confirmation for the worktree with this id (#85), guarding
+    /// the destructive key like [`OverlayKind::KillConfirm`] does.
+    ReclaimConfirm {
+        id: Uuid,
+        branch: String,
+        /// [`maestro_protocol::InTheWay`] as of when the confirm was opened.
+        blockers: String,
+    },
 }
 
 #[derive(Debug)]

crates/maestro-tui/src/worktrees.rs

@@ -0,0 +1,259 @@
+//! Retained-worktrees view (#85): an overlay listing every retained worktree
+//! — branch, abbreviated path, reason, what is in the way — with j/k to move,
+//! `r` to reclaim behind a confirmation, esc to close.
+//!
+//! The in-the-way summary comes straight from [`InTheWay`]'s `Display` impl,
+//! the same source the kill refusal and the web client use, so no two clients
+//! can describe the same tree differently.
+
+use ratatui::layout::Rect;
+use ratatui::text::Line;
+use ratatui::widgets::{Block, Borders, Clear, Paragraph};
+use ratatui::Frame;
+
+use maestro_protocol::{RetainedReason, RetainedWorktree};
+
+use crate::draft::abbreviate_path;
+
+/// The open worktrees overlay: its entries and which one is highlighted.
+#[derive(Debug, Clone, Default)]
+pub struct WorktreesView {
+    pub items: Vec<RetainedWorktree>,
+    pub highlight: usize,
+    /// Daemon-reported home dir, for `~` abbreviation of paths.
+    pub home_dir: String,
+}
+
+impl WorktreesView {
+    /// Replace the listing and keep the highlight pointing at something real.
+    pub fn apply(&mut self, items: Vec<RetainedWorktree>) {
+        self.items = items;
+        if !self.items.is_empty() {
+            self.highlight = self.highlight.min(self.items.len() - 1);
+        } else {
+            self.highlight = 0;
+        }
+    }
+
+    pub fn remove(&mut self, id: uuid::Uuid) {
+        let idx = self.items.iter().position(|w| w.id == id);
+        self.items.retain(|w| w.id != id);
+        if let Some(i) = idx {
+            self.highlight = self.highlight.min(self.items.len().saturating_sub(1));
+            let _ = i;
+        }
+    }
+
+    /// Move the highlight by `delta` (positive = down). Wraps. No-op on empty.
+    pub fn move_highlight(&mut self, delta: i32) {
+        if self.items.is_empty() {
+            return;
+        }
+        let len = self.items.len() as i32;
+        let next = (self.highlight as i32 + delta).rem_euclid(len);
+        self.highlight = next as usize;
+    }
+
+    pub fn selected(&self) -> Option<&RetainedWorktree> {
+        self.items.get(self.highlight)
+    }
+
+    pub fn render(&self, f: &mut Frame, parent: Rect) {
+        let h = (self.items.len() as u16 + 6).clamp(4, parent.height);
+        let area = super::overlays::centered(parent, parent.width.saturating_sub(4), h);
+        f.render_widget(Clear, area);
+        let block = Block::default()
+            .title(" retained worktrees ")
+            .borders(Borders::ALL);
+        let inner = block.inner(area);
+        f.render_widget(block, area);
+
+        let mut lines: Vec<Line> = Vec::new();
+        if self.items.is_empty() {
+            // A drained store is the normal state — say so plainly, not like
+            // something went wrong.
+            lines.push(Line::from("no retained worktrees"));
+        } else {
+            lines.push(Line::from(format!(
+                "  {:<26}  {:<34}  {:<24}  IN THE WAY",
+                "BRANCH", "PATH", "REASON"
+            )));
+            for (i, w) in self.items.iter().enumerate() {
+                let marker = if i == self.highlight { ">" } else { " " };
+                lines.push(Line::from(format!(
+                    "{marker} {:<25}  {:<34}  {:<24}  {}",
+                    w.branch,
+                    abbreviate_path(&w.path, &self.home_dir),
+                    reason_label(w.reason),
+                    w.in_the_way,
+                )));
+            }
+        }
+        lines.push(Line::from(""));
+        lines.push(Line::from("j/k: select  r: reclaim  esc: close"));
+        f.render_widget(Paragraph::new(lines), inner);
+    }
+}
+
+/// The confirmation guarding reclaim, mirroring [`super::overlays::KillConfirm`].
+/// It names the branch and says out loud what reclaim does not take with it —
+/// docs/WORKTREES.md: "reclaim" otherwise sounds like it takes the commits too.
+#[derive(Debug, Clone)]
+pub struct ReclaimConfirm {
+    pub branch: String,
+    /// [`maestro_protocol::InTheWay`] rendered via its `Display` impl.
+    pub blockers: String,
+}
+
+impl ReclaimConfirm {
+    pub fn render(&self, f: &mut Frame, parent: Rect) {
+        let area = super::overlays::centered(parent, 70, 7);
+        f.render_widget(Clear, area);
+        let block = Block::default().title(" reclaim ").borders(Borders::ALL);
+        let inner = block.inner(area);
+        f.render_widget(block, area);
+        f.render_widget(
+            ratatui::widgets::Paragraph::new(vec![
+                Line::from(format!("Reclaim worktree {}?", self.branch)),
+                Line::from(format!("Currently in the way: {}", self.blockers)),
+                Line::from("The directory is removed; the branch is never deleted."),
+                Line::from(""),
+                Line::from("[y] yes   [n] no"),
+            ]),
+            inner,
+        );
+    }
+}
+
+fn reason_label(reason: RetainedReason) -> &'static str {
+    match reason {
+        RetainedReason::ForceKilled => "force-killed",
+        RetainedReason::ExitedWithUnsavedWork => "exited-with-unsaved-work",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::{TimeZone, Utc};
+    use maestro_protocol::{InTheWay, RetainedReason};
+    use ratatui::backend::TestBackend;
+    use ratatui::Terminal;
+
+    fn render_to_string<F>(w: u16, h: u16, draw: F) -> String
+    where
+        F: FnOnce(&mut Frame),
+    {
+        let backend = TestBackend::new(w, h);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal.draw(draw).unwrap();
+        let buf = terminal.backend().buffer().clone();
+        let mut out = String::new();
+        for y in 0..buf.area.height {
+            for x in 0..buf.area.width {
+                out.push_str(buf[(x, y)].symbol());
+            }
+            out.push('\n');
+        }
+        out
+    }
+
+    fn worktree(branch: &str, path: &str, id: u128) -> RetainedWorktree {
+        RetainedWorktree {
+            id: uuid::Uuid::from_u128(id),
+            path: path.into(),
+            base_repo: "/home/naps/tea/maestro".into(),
+            branch: branch.into(),
+            reason: RetainedReason::ForceKilled,
+            retained_at: Utc.with_ymd_and_hms(2026, 8, 24, 10, 0, 0).unwrap(),
+            in_the_way: InTheWay::default(),
+        }
+    }
+
+    #[test]
+    fn view_lists_branch_path_reason_and_what_is_in_the_way() {
+        let mut view = WorktreesView {
+            home_dir: "/home/naps".into(),
+            ..Default::default()
+        };
+        let mut wt = worktree(
+            "feat/login",
+            "/home/naps/tea/maestro/worktrees/feat/login",
+            1,
+        );
+        wt.in_the_way = InTheWay {
+            uncommitted_files: 2,
+            untracked_files: 1,
+            unpushed_commits: 3,
+        };
+        view.apply(vec![wt]);
+
+        let rendered = render_to_string(160, 20, |f| view.render(f, f.area()));
+        assert!(rendered.contains("feat/login"), "{rendered}");
+        // Path abbreviated against the daemon's home dir, same helper as the
+        // draft pane's project list.
+        assert!(rendered.contains("~/t/m/w/f/login"), "{rendered}");
+        assert!(rendered.contains("force-killed"), "{rendered}");
+        // Phrasing comes from InTheWay's Display impl — shared with the kill
+        // refusal and the web client.
+        assert!(
+            rendered.contains("2 uncommitted files, 1 untracked file, 3 unpushed commits"),
+            "{rendered}"
+        );
+    }
+
+    #[test]
+    fn empty_store_looks_like_a_normal_state_not_an_error() {
+        let view = WorktreesView::default();
+        let rendered = render_to_string(80, 12, |f| view.render(f, f.area()));
+        assert!(rendered.contains("no retained worktrees"), "{rendered}");
+        assert!(!rendered.contains("error"), "{rendered}");
+        assert!(!rendered.contains("failed"), "{rendered}");
+    }
+
+    #[test]
+    fn highlight_moves_and_wraps() {
+        let mut view = WorktreesView::default();
+        view.apply(vec![
+            worktree("a", "/r/a", 1),
+            worktree("b", "/r/b", 2),
+            worktree("c", "/r/c", 3),
+        ]);
+        assert_eq!(view.selected().unwrap().branch, "a");
+        view.move_highlight(1);
+        assert_eq!(view.selected().unwrap().branch, "b");
+        view.move_highlight(-1);
+        assert_eq!(view.selected().unwrap().branch, "a");
+        view.move_highlight(-1);
+        // Wraps backward to the last entry.
+        assert_eq!(view.selected().unwrap().branch, "c");
+        view.move_highlight(1);
+        assert_eq!(view.selected().unwrap().branch, "a");
+    }
+
+    #[test]
+    fn apply_clamps_a_stale_highlight() {
+        let mut view = WorktreesView::default();
+        view.apply(vec![worktree("a", "/r/a", 1), worktree("b", "/r/b", 2)]);
+        view.move_highlight(1);
+        view.apply(vec![worktree("c", "/r/c", 3)]);
+        assert_eq!(view.selected().unwrap().branch, "c");
+    }
+
+    #[test]
+    fn reclaim_confirm_names_the_branch_and_says_it_survives() {
+        let confirm = ReclaimConfirm {
+            branch: "feat/login".into(),
+            blockers: "2 uncommitted files".into(),
+        };
+        let rendered = render_to_string(80, 14, |f| confirm.render(f, f.area()));
+        assert!(
+            rendered.contains("Reclaim worktree feat/login?"),
+            "{rendered}"
+        );
+        assert!(rendered.contains("2 uncommitted files"), "{rendered}");
+        assert!(rendered.contains("never deleted"), "{rendered}");
+        assert!(rendered.contains("yes"), "{rendered}");
+        assert!(rendered.contains("no"), "{rendered}");
+    }
+}

docs/WORKTREES.md

@@ -75,11 +75,16 @@ That is only safe because force retains.
 
 `--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.
+`force-killed`. Force never removes a tree that would have blocked. A tree
+whose guard is clear never needed the override, so a forced kill removes it as
+usual — force changes what happens to blocked work, not ordinary cleanup.
 
-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.
+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.
+
+A forced kill answers with what was retained and why, so a client can say where
+the work went rather than leaving the operator to wonder.
 
 ### Exiting on its own
 

web/src/api.ts

@@ -9,6 +9,7 @@ import type {
   NameBatch,
   Projects,
   RecentDirs,
+  RetainedWorktree,
   Session,
   Uuid,
 } from "./types.js";
@@ -97,4 +98,22 @@ export async function fetchBranches(path: string): Promise<Branches> {
   return jsonOrError(await fetch(url, { credentials: "same-origin" }));
 }
 
+/** The daemon's retained worktrees (#80): trees kept after a session ended
+ * with unsaved work, with what is currently in the way. Drives the
+ * retained-worktrees view (#84). */
+export async function listWorktrees(): Promise<RetainedWorktree[]> {
+  return jsonOrError(await fetch(routes.WORKTREES, { credentials: "same-origin" }));
+}
+
+/** Reclaim a retained worktree: removes its directory and drops the store
+ * entry. Never deletes the branch (docs/WORKTREES.md). */
+export async function reclaimWorktree(id: Uuid): Promise<void> {
+  await jsonOrError(
+    await fetch(routes.worktree(id), {
+      method: "DELETE",
+      credentials: "same-origin",
+    }),
+  );
+}
+
 export { eventsWsUrl } from "./routes.js";

web/src/catalog.ts

@@ -180,6 +180,15 @@ export function renderTopbar(store: CatalogStore, onToggleSidebar?: () => void):
   renderStatus();
 
   const actions = header.querySelector(".app-actions") as HTMLElement;
+  // Retained worktrees (#84): a section reachable from the header, not a
+  // sidebar fixture — PRODUCT.md's scan is the product, so this must not
+  // compete with the session catalog for attention.
+  const worktreesLink = document.createElement("a");
+  worktreesLink.className = "btn btn-ghost";
+  worktreesLink.href = "#/worktrees";
+  worktreesLink.textContent = "worktrees";
+  worktreesLink.title = "Retained worktrees";
+  actions.appendChild(worktreesLink);
   // DEV-only shortcut to the standalone design kit (?kit). Lets you reach it by
   // clicking inside a proxied preview (e.g. crit live) that has no address bar.
   if (import.meta.env.DEV) {

web/src/fastForward.test.ts

@@ -43,7 +43,6 @@ describe("resolveFastForward (#67)", () => {
     expect(req.worktree).toEqual({
       base_repo: "/repos/fresh",
       branch: "amber-falcon",
-      cleanup_on_kill: true,
       create_branch: true,
     });
   });

web/src/fastForward.ts

@@ -42,7 +42,6 @@ export function buildFastForwardRequest(
     worktree: {
       base_repo: project.base_repo ?? project.path,
       branch: name,
-      cleanup_on_kill: true,
       create_branch: true,
     },
   };

web/src/main.ts

@@ -7,7 +7,9 @@ import {
   createSession,
   fetchNames,
   getDaemonInfo,
+  listWorktrees,
   projects as fetchProjects,
+  reclaimWorktree,
 } from "./api.js";
 import {
   buildFastForwardRequest,
@@ -22,6 +24,7 @@ import { loadLayout, saveLayout } from "./persistence.js";
 import { OPEN_SPAWN_EVENT } from "./catalog.js";
 import { initTheme } from "./theme.js";
 import { sessionName, type Project, type Session, type SpawnPreset } from "./types.js";
+import { createWorktreesView, type WorktreesViewHandle } from "./worktreesView.js";
 import { installViewportSizing } from "./viewport.js";
 import "./styles.css";
 
@@ -345,16 +348,47 @@ document.addEventListener("keydown", (e) => {
 type Route =
   | { kind: "catalog" }
   | { kind: "attach"; sessionId: string }
+  | { kind: "worktrees" }
   | { kind: "not-found"; raw: string };
 
 function parseRoute(): Route {
   const hash = location.hash.replace(/^#/, "");
   if (hash === "" || hash === "/") return { kind: "catalog" };
+  if (hash === "/worktrees") return { kind: "worktrees" };
   const m = hash.match(/^\/attach\/([^/?#]+)$/);
   if (m) return { kind: "attach", sessionId: decodeURIComponent(m[1]) };
   return { kind: "not-found", raw: hash };
 }
 
+// Retained worktrees (#84): built lazily on first visit, then kept so a
+// revisit re-enters instantly. The daemon's home dir abbreviates paths once
+// `/api/info` answers.
+let worktreesView: WorktreesViewHandle | undefined;
+let homeDir: string | undefined;
+void getDaemonInfo()
+  .then((info) => {
+    homeDir = info.home_dir;
+  })
+  .catch(() => {
+    /* absolute paths are a fine fallback */
+  });
+
+function showWorktrees(): void {
+  pool.setVisible([]);
+  pool.setFocus(null);
+  contentShowsMv = false;
+  if (!worktreesView) {
+    worktreesView = createWorktreesView({
+      load: listWorktrees,
+      reclaim: reclaimWorktree,
+      homeDir: () => homeDir,
+    });
+  }
+  content.replaceChildren(worktreesView.el);
+  shellEl.dataset.route = "worktrees";
+  void worktreesView.refresh();
+}
+
 function dispatch(): void {
   const route = parseRoute();
   switch (route.kind) {
@@ -376,6 +410,9 @@ function dispatch(): void {
       // tears panes down.
       showMultiView();
       return;
+    case "worktrees":
+      showWorktrees();
+      return;
   }
 }
 

web/src/routes.ts

@@ -13,6 +13,7 @@ export const PROJECTS = "/api/projects";
 export const GITROOT = "/api/gitroot";
 export const NAMES = "/api/names";
 export const BRANCHES = "/api/branches";
+export const WORKTREES = "/api/worktrees";
 export const EVENTS = "/api/events";
 
 /** Name of the query parameter `DIRS` and `GITROOT` both take. */
@@ -29,6 +30,11 @@ export function attach(id: Uuid): string {
   return `${API_PREFIX}/attach/${encodeURIComponent(id)}`;
 }
 
+/** `DELETE /api/worktrees/:id` — reclaim one retained worktree (#80). */
+export function worktree(id: Uuid): string {
+  return `${WORKTREES}/${encodeURIComponent(id)}`;
+}
+
 /** Append the `path` query parameter `DIRS` and `GITROOT` accept. */
 export function withPathQuery(route: string, value: string): string {
   return `${route}?${PATH_QUERY}=${encodeURIComponent(value)}`;

web/src/spawnForm.test.ts

@@ -38,7 +38,6 @@ describe("buildSpawnRequest", () => {
         worktree: {
           base_repo: "/home/user/project",
           branch: "feat/foo",
-          cleanup_on_kill: true,
           create_branch: true,
         },
       },
@@ -63,7 +62,6 @@ describe("buildSpawnRequest", () => {
         worktree: {
           base_repo: "/home/user/project",
           branch: "spawn-v2",
-          cleanup_on_kill: true,
           create_branch: false,
         },
       },

web/src/spawnForm.ts

@@ -75,9 +75,6 @@ export function buildSpawnRequest(
     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",

web/src/styles.css

@@ -2225,3 +2225,148 @@ textarea {
     background: oklch(0 0 0 / 0.5);
   }
 }
+
+/* ---------- retained worktrees (#84) ---------- */
+
+.worktrees {
+  padding: var(--sp-4);
+  max-width: 960px;
+  margin: 0 auto;
+}
+
+.wt-head {
+  margin-bottom: var(--sp-4);
+}
+
+.wt-title {
+  font-family: var(--font-mono);
+  font-size: var(--fs-15);
+  font-weight: 600;
+  color: var(--ink);
+  margin: 0 0 var(--sp-1);
+}
+
+.wt-sub {
+  color: var(--muted);
+  font-size: var(--fs-13);
+  margin: 0;
+}
+
+.wt-row {
+  display: flex;
+  align-items: baseline;
+  gap: var(--sp-3);
+  padding: var(--sp-2) var(--sp-2);
+  border-bottom: 1px solid var(--surface-2);
+  font-family: var(--font-mono);
+  font-size: var(--fs-13);
+  flex-wrap: wrap;
+}
+
+.wt-branch {
+  color: var(--ink);
+  font-weight: 600;
+}
+
+.wt-path {
+  color: var(--muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.wt-reason {
+  color: var(--faint);
+}
+
+/* Status never rides on color alone: the label itself says what blocks. */
+.wt-way[data-clear] {
+  color: var(--faint);
+}
+
+.wt-way:not([data-clear]) {
+  color: var(--warn);
+}
+
+.wt-row .wt-reclaim-btn {
+  margin-left: auto;
+}
+
+.wt-row .wt-reclaim-btn::before {
+  content: "[";
+  color: var(--danger);
+}
+
+.wt-row .wt-reclaim-btn::after {
+  content: "]";
+  color: var(--danger);
+}
+
+.wt-row .wt-reclaim-btn:hover {
+  color: var(--danger);
+  background: var(--danger-tint);
+}
+
+.btn-danger {
+  color: var(--danger);
+  font-weight: 600;
+}
+
+.btn-danger:hover {
+  background: var(--danger-tint);
+}
+
+/* The destructive confirmation, centered over the section. */
+.wt-confirm {
+  position: fixed;
+  inset: 0;
+  z-index: var(--z-backdrop);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: oklch(0 0 0 / 0.5);
+  padding: var(--sp-4);
+}
+
+.wt-confirm[hidden] {
+  display: none;
+}
+
+.wt-confirm-panel {
+  pointer-events: auto;
+  background: var(--bg);
+  border: 1px solid var(--surface-2);
+  padding: var(--sp-4);
+  max-width: 480px;
+  font-family: var(--font-sans);
+  display: flex;
+  flex-direction: column;
+  gap: var(--sp-2);
+}
+
+.wt-confirm-q {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-weight: 600;
+  color: var(--ink);
+}
+
+.wt-confirm-way {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: var(--fs-13);
+  color: var(--warn);
+}
+
+.wt-confirm-note {
+  margin: 0;
+  font-size: var(--fs-13);
+  color: var(--muted);
+}
+
+.wt-confirm-actions {
+  display: flex;
+  gap: var(--sp-2);
+  justify-content: flex-end;
+  margin-top: var(--sp-2);
+}

web/src/types.ts

@@ -113,7 +113,6 @@ export type Projects = Project[];
 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;
@@ -133,6 +132,54 @@ export interface BranchInfo {
 /** `GET /api/branches?path=` — the local branches of one repository (#55). */
 export type Branches = BranchInfo[];
 
+/** Why a retained worktree outlived its session (#80). New values are
+ * additive; unknown reasons render generically. */
+export type RetainedReason = "force-killed" | "exited-with-unsaved-work";
+
+/** What currently blocks an unforced kill of a worktree's session (#80),
+ * recomputed by the daemon on every read. All counts default to 0 on the
+ * wire for older daemons. */
+export interface InTheWay {
+  uncommitted_files?: number;
+  untracked_files?: number;
+  unpushed_commits?: number;
+}
+
+/** One entry of `GET /api/worktrees` (#80): a retained worktree with its
+ * in-the-way state as of this read. Reclaiming it removes the directory but
+ * never the branch. Mirrors `maestro_protocol::RetainedWorktree`. */
+export interface RetainedWorktree {
+  id: Uuid;
+  path: string;
+  base_repo: string;
+  branch: string;
+  reason: RetainedReason;
+  retained_at: IsoTimestamp;
+  in_the_way?: InTheWay;
+}
+
+/** The phrasing `maestro_protocol::InTheWay`'s Display impl uses — shared by
+ * the kill refusal, the TUI and this client, so no two clients can describe
+ * the same tree differently. Zero parts are omitted; all-zero renders
+ * "no unsaved work". */
+export function formatInTheWay(w: InTheWay): string {
+  const parts: string[] = [];
+  const push = (n: number | undefined, unit: string): void => {
+    if (!n || n <= 0) return;
+    parts.push(n === 1 ? `1 ${unit}` : `${n} ${unit}s`);
+  };
+  push(w.uncommitted_files, "uncommitted file");
+  push(w.untracked_files, "untracked file");
+  push(w.unpushed_commits, "unpushed commit");
+  return parts.length > 0 ? parts.join(", ") : "no unsaved work";
+}
+
+/** Same reason labels the CLI table and the TUI overlay use; unknown future
+ * reasons render their raw wire value. */
+export function reasonLabel(reason: RetainedReason): string {
+  return reason;
+}
+
 export interface CreateSessionRequest {
   cwd: string;
   command: string;

web/src/worktrees.test.ts

@@ -0,0 +1,114 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+
+import { createWorktreesView } from "./worktreesView.js";
+import type { RetainedWorktree } from "./types.js";
+
+function worktree(overrides: Partial<RetainedWorktree>): RetainedWorktree {
+  return {
+    id: "11111111-2222-3333-4444-555555555555",
+    path: "/home/naps/tea/maestro/worktrees/feat/login",
+    base_repo: "/home/naps/tea/maestro",
+    branch: "feat/login",
+    reason: "force-killed",
+    retained_at: "2026-08-24T10:00:00Z",
+    in_the_way: {
+      uncommitted_files: 2,
+      untracked_files: 1,
+      unpushed_commits: 3,
+    },
+    ...overrides,
+  };
+}
+
+/** Mount a view over a scripted store and return (el, reclaimed-ids). */
+function mount(items: RetainedWorktree[], homeDir = "/home/naps") {
+  const reclaimed: string[] = [];
+  const view = createWorktreesView({
+    load: async () => items,
+    reclaim: async (id) => {
+      reclaimed.push(id);
+      items.splice(
+        items.findIndex((w) => w.id === id),
+        1,
+      );
+    },
+    homeDir: () => homeDir,
+  });
+  document.body.appendChild(view.el);
+  return { view, reclaimed };
+}
+
+describe("retained-worktrees view (#84)", () => {
+  it("lists branch, abbreviated path, reason and what is in the way", async () => {
+    const { view } = mount([
+      worktree({
+        path: "/home/naps/tea/maestro/worktrees/feat/login",
+      }),
+    ]);
+    await view.refresh();
+    const text = view.el.textContent ?? "";
+    expect(text).toContain("feat/login");
+    // Sidebar-style abbreviation of the path against the daemon's home dir,
+    // full path kept in the tooltip.
+    expect(text).toContain("t/m/w/f/login");
+    const pathEl = view.el.querySelector<HTMLElement>(".wt-path")!;
+    expect(pathEl.title).toBe("/home/naps/tea/maestro/worktrees/feat/login");
+    // Same reason labels as `maestro worktrees list` and the TUI overlay.
+    expect(text).toContain("force-killed");
+    // Same phrasing as InTheWay's Display impl — shared with the kill refusal.
+    expect(text).toContain("2 uncommitted files, 1 untracked file, 3 unpushed commits");
+  });
+
+  it("says a tree whose work has since been pushed is clear", async () => {
+    const { view } = mount([worktree({ in_the_way: {} })]);
+    await view.refresh();
+    expect(view.el.textContent).toContain("no unsaved work");
+  });
+
+  it("renders an empty store as a normal state, not an error", async () => {
+    const { view } = mount([]);
+    await view.refresh();
+    const text = view.el.textContent ?? "";
+    expect(text).toContain("no retained worktrees");
+    expect(text.toLowerCase()).not.toContain("error");
+    expect(text.toLowerCase()).not.toContain("failed");
+  });
+
+  it("guards reclaim with a confirmation that names what is lost and that the branch survives", async () => {
+    const wt = worktree({ branch: "feat/login" });
+    const { view, reclaimed } = mount([wt]);
+    await view.refresh();
+
+    view.el.querySelector<HTMLButtonElement>(".wt-reclaim-btn")!.click();
+    const confirmText = view.el.querySelector<HTMLElement>(".wt-confirm")!.textContent ?? "";
+    expect(confirmText).toContain("Reclaim worktree feat/login?");
+    // Names what will be lost before it happens…
+    expect(confirmText).toContain(
+      "2 uncommitted files, 1 untracked file, 3 unpushed commits",
+    );
+    // …and says reclaim does not take the commits too.
+    expect(confirmText).toContain("never deleted");
+
+    view.el.querySelector<HTMLButtonElement>(".wt-confirm-cancel")!.click();
+    expect(reclaimed).toEqual([]);
+
+    view.el.querySelector<HTMLButtonElement>(".wt-reclaim-btn")!.click();
+    view.el.querySelector<HTMLButtonElement>(".wt-confirm-go")!.click();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(reclaimed).toEqual(["11111111-2222-3333-4444-555555555555"]);
+    // The row is gone once the refresh lands.
+    expect(view.el.textContent).toContain("no retained worktrees");
+  });
+
+  it("sorts oldest-retained first, like every other client", async () => {
+    const { view } = mount([
+      worktree({ branch: "newer", retained_at: "2026-08-24T12:00:00Z" }),
+      worktree({ branch: "older", retained_at: "2026-08-24T08:00:00Z" }),
+    ]);
+    await view.refresh();
+    const branches = [...view.el.querySelectorAll(".wt-branch")].map((n) => n.textContent);
+    expect(branches).toEqual(["older", "newer"]);
+  });
+});

web/src/worktreesView.ts

@@ -0,0 +1,166 @@
+// Retained-worktrees view (#84): every worktree the daemon is holding that no
+// session uses, listed from `GET /api/worktrees` with a reclaim action.
+//
+// Wording is shared with the CLI (`maestro worktrees list`) and the TUI
+// overlay: same reason labels, same in-the-way phrasing via
+// `formatInTheWay` (the mirror of `InTheWay`'s Display impl). Reclaim reads
+// as what it is — destructive — naming what will be lost before it happens
+// and saying out loud that the branch survives (docs/WORKTREES.md).
+
+import { escapeHtml } from "./html.js";
+import {
+  abbreviateCwd,
+  abbreviateFolderName,
+  formatInTheWay,
+  reasonLabel,
+  type RetainedWorktree,
+  type Uuid,
+} from "./types.js";
+
+export interface WorktreesDeps {
+  /** `GET /api/worktrees`. */
+  load(): Promise<RetainedWorktree[]>;
+  /** `DELETE /api/worktrees/:id`. */
+  reclaim(id: Uuid): Promise<void>;
+  /** The daemon's home dir, for `~` abbreviation of paths. */
+  homeDir(): string | undefined;
+}
+
+export interface WorktreesViewHandle {
+  el: HTMLElement;
+  /** Re-fetch the store and re-render. Safe to call repeatedly. */
+  refresh(): Promise<void>;
+  dispose(): void;
+}
+
+/** Oldest-retained first, matching `maestro worktrees list`'s ordering. */
+function sorted(items: RetainedWorktree[]): RetainedWorktree[] {
+  return [...items].sort(
+    (a, b) => Date.parse(a.retained_at) - Date.parse(b.retained_at),
+  );
+}
+
+export function createWorktreesView(deps: WorktreesDeps): WorktreesViewHandle {
+  const el = document.createElement("section");
+  el.className = "worktrees";
+  el.innerHTML = `
+    <header class="wt-head">
+      <h2 class="wt-title">retained worktrees</h2>
+      <p class="wt-sub">
+        Kept when a session ended with unsaved work. Reclaiming removes the
+        directory only; branches are never deleted.
+      </p>
+    </header>
+    <div class="wt-list"></div>
+    <div class="wt-confirm" role="alertdialog" aria-modal="true" hidden></div>
+  `;
+  const listHost = el.querySelector<HTMLElement>(".wt-list")!;
+  const confirmEl = el.querySelector<HTMLElement>(".wt-confirm")!;
+
+  let pendingId: string | null = null;
+
+  const render = (items: RetainedWorktree[]) => {
+    listHost.replaceChildren();
+    if (items.length === 0) {
+      // A drained store is the normal state — say so plainly, not like
+      // something went wrong.
+      const empty = document.createElement("div");
+      empty.className = "empty";
+      empty.innerHTML = `
+        <div class="empty-glyph" aria-hidden="true">⌂</div>
+        <div class="empty-title">no retained worktrees</div>
+        <p class="empty-hint">Nothing is being held. Worktrees kept after a force-kill or an unsaved exit show up here.</p>`;
+      listHost.appendChild(empty);
+      return;
+    }
+    const home = deps.homeDir();
+    for (const w of sorted(items)) {
+      listHost.appendChild(renderRow(w, home));
+    }
+  };
+
+  const renderRow = (w: RetainedWorktree, home: string | undefined): HTMLElement => {
+    const row = document.createElement("div");
+    row.className = "wt-row";
+    const clear = formatInTheWay(w.in_the_way ?? {}) === "no unsaved work";
+    row.innerHTML = `
+      <span class="wt-branch">${escapeHtml(w.branch)}</span>
+      <span class="wt-path" title="${escapeHtml(w.path)}">${abbreviateFolderName(abbreviateCwd(w.path, home))}</span>
+      <span class="wt-reason">${escapeHtml(reasonLabel(w.reason))}</span>
+      <span class="wt-way"${clear ? ' data-clear="true"' : ""}>${escapeHtml(formatInTheWay(w.in_the_way ?? {}))}</span>
+      <button class="btn wt-reclaim-btn" type="button">Reclaim</button>
+    `;
+    row.querySelector(".wt-reclaim-btn")!.addEventListener("click", () => {
+      showConfirm(w);
+    });
+    return row;
+  };
+
+  const showConfirm = (w: RetainedWorktree) => {
+    pendingId = w.id;
+    // Mirrors the TUI's ReclaimConfirm line for line: what goes away, what is
+    // in the way right now, and that the branch survives reclaim.
+    confirmEl.innerHTML = `
+      <div class="wt-confirm-panel">
+        <p class="wt-confirm-q">Reclaim worktree ${escapeHtml(w.branch)}?</p>
+        <p class="wt-confirm-way">Currently in the way: ${escapeHtml(formatInTheWay(w.in_the_way ?? {}))}</p>
+        <p class="wt-confirm-note">The directory is removed; the branch is never deleted.</p>
+        <div class="wt-confirm-actions">
+          <button class="btn btn-danger wt-confirm-go" type="button">Reclaim</button>
+          <button class="btn btn-ghost wt-confirm-cancel" type="button">Cancel</button>
+        </div>
+      </div>`;
+    confirmEl.hidden = false;
+    confirmEl.querySelector<HTMLButtonElement>(".wt-confirm-go")!.focus();
+  };
+
+  const hideConfirm = () => {
+    pendingId = null;
+    confirmEl.hidden = true;
+    confirmEl.replaceChildren();
+  };
+
+  confirmEl.addEventListener("click", async (e) => {
+    const target = e.target as HTMLElement;
+    if (target.closest(".wt-confirm-cancel")) {
+      hideConfirm();
+      return;
+    }
+    if (!target.closest(".wt-confirm-go") || !pendingId) return;
+    const id = pendingId;
+    hideConfirm();
+    try {
+      await deps.reclaim(id);
+    } catch (err) {
+      alert(`Failed to reclaim: ${(err as Error).message}`);
+    }
+    await refresh();
+  });
+
+  const onKey = (e: KeyboardEvent) => {
+    if (e.key === "Escape" && !confirmEl.hidden) hideConfirm();
+  };
+  document.addEventListener("keydown", onKey);
+
+  const refresh = async () => {
+    try {
+      render(await deps.load());
+    } catch (err) {
+      listHost.replaceChildren();
+      const fail = document.createElement("div");
+      fail.className = "empty";
+      fail.innerHTML = `<div class="empty-title">Couldn't load retained worktrees</div><p class="empty-hint"></p>`;
+      fail.querySelector(".empty-hint")!.textContent = (err as Error).message;
+      listHost.appendChild(fail);
+    }
+  };
+
+  return {
+    el,
+    refresh,
+    dispose() {
+      document.removeEventListener("keydown", onKey);
+      el.remove();
+    },
+  };
+}