feat(maestro): persist PTY scrollback across a reboot

A resumed session opened on a blank pane: the agent's conversation came
back, the terminal history the operator was reading did not. Each PTY
bridge's replay ring is now mirrored to `<state_dir>/scrollback/<id>.bin`
and handed to the new bridge on resume, and on the recovery pass that
re-adopts a session tmux still holds — that one lost its ring with the
previous daemon too. Restored bytes go out ahead of the live ones, and
are dropped once the ring holds a full budget of new output of its own.

Flushed every 10 seconds by the liveness watcher, and once more when a
bridge is sealed on exit. The timer is the part that matters: a host
reboot runs no exit path at all, so a scrollback written only on a clean
shutdown is missing in exactly the case this exists for. Ten seconds
bounds the loss to the last few lines — this is visual continuity, not
state — and costs at most one file write per active session per tick,
since a session whose bridge has read nothing since the last flush is
skipped.

The file is capped at the existing `pty_replay_bytes` budget rather than
a second one, is deleted on kill and when recovery prunes a sidecar, and
a missing, unreadable or oversized one degrades to an empty pane instead
of failing the resume.

Closes #171

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

CLAUDE.md

@@ -14,6 +14,7 @@ maestro daemon            tmux wrapper + session API + SPA on 127.0.0.1:7070
   ├── DELETE   /api/sessions/:id    kill
   ├── POST     /api/sessions/:id/input  type text into a session
   ├── POST     /api/sessions/:id/prompt an agent reports its first prompt (#131)
+  ├── POST     /api/sessions/:id/resume respawn a dormant session, same id (#166)
   ├── GET      /api/info            hostname, version, home dir, spawn presets
   ├── GET      /api/dirs            directory listing (spawn autocomplete)
   ├── GET      /api/recent-dirs     spawn history

crates/maestro-cli/src/sessions.rs

@@ -188,6 +188,7 @@ fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &Daemon
         let status = match s.status {
             SessionStatus::Running => "running",
             SessionStatus::Dead => "dead",
+            SessionStatus::Dormant => "dormant",
         };
         let activity = match s.activity {
             ActivityState::Active => "active",
@@ -252,6 +253,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 

crates/maestro-cli/tests/against_mock_daemon.rs

@@ -28,6 +28,7 @@ async fn info_carries_version_and_presets() {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
+            resume_command: None,
         }],
         ..Default::default()
     });

crates/maestro-config/src/lib.rs

@@ -30,6 +30,11 @@ pub const FILE_NAME: &str = "config.toml";
 /// Last-resort daemon HTTP base, matching the daemon's own default `bind_addr`.
 pub const DEFAULT_DAEMON_URL: &str = "http://127.0.0.1:7070";
 
+/// Leader key both clients use when `[tui].leader` is unset (#159). Canonical
+/// key form, the spelling `InputKey::parse` and the web's `canonicalizeKey`
+/// both produce.
+pub const DEFAULT_LEADER: &str = "ctrl-a";
+
 #[derive(Debug, thiserror::Error)]
 pub enum ConfigError {
     #[error("io: {0}")]
@@ -124,6 +129,80 @@ pub struct DaemonSection {
     /// `Some(0)` disables history entirely (no log written, no recents read).
     #[serde(default)]
     pub spawn_history_days: Option<u32>,
+    /// What recovery does with sessions that outlived their tmux server —
+    /// after a host reboot, or any restart that finds a sidecar with no pane
+    /// (#167). Default [`ResumeOnBoot::Dormant`].
+    #[serde(default, deserialize_with = "deserialize_resume_on_boot")]
+    pub resume_on_boot: Option<ResumeOnBoot>,
+}
+
+impl DaemonSection {
+    /// The configured `[daemon].resume_on_boot`, or the safe default:
+    /// recovered-but-dead sessions wait for the operator.
+    pub fn resume_on_boot(&self) -> ResumeOnBoot {
+        self.resume_on_boot.unwrap_or_default()
+    }
+}
+
+/// `[daemon].resume_on_boot` — what recovery does with a session whose tmux
+/// pane is gone but whose sidecar is still on disk (#167).
+///
+/// Resuming agents unattended seconds after a reboot is a foot-gun: they run
+/// with whatever flags they were spawned with, with nobody watching. So the
+/// default waits for a human, and `auto` is opted into per host.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum ResumeOnBoot {
+    /// Register each one `Dormant` and wait for the operator to resume it.
+    #[default]
+    Dormant,
+    /// Resume each one during recovery, on the same path a client's
+    /// `POST /api/sessions/:id/resume` takes.
+    Auto,
+    /// Prune the sidecars instead: a reboot is a clean slate.
+    Never,
+}
+
+/// Every `[daemon].resume_on_boot` name and its variant, in documentation
+/// order.
+pub const RESUME_ON_BOOT_POLICIES: &[(&str, ResumeOnBoot)] = &[
+    ("dormant", ResumeOnBoot::Dormant),
+    ("auto", ResumeOnBoot::Auto),
+    ("never", ResumeOnBoot::Never),
+];
+
+impl ResumeOnBoot {
+    /// The name this policy is spelled with in the config file and in logs.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ResumeOnBoot::Dormant => "dormant",
+            ResumeOnBoot::Auto => "auto",
+            ResumeOnBoot::Never => "never",
+        }
+    }
+}
+
+fn deserialize_resume_on_boot<'de, D>(deserializer: D) -> Result<Option<ResumeOnBoot>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let raw = Option::<String>::deserialize(deserializer)?;
+    raw.map(|name| {
+        RESUME_ON_BOOT_POLICIES
+            .iter()
+            .find(|(n, _)| *n == name)
+            .map(|(_, policy)| *policy)
+            .ok_or_else(|| {
+                let known = RESUME_ON_BOOT_POLICIES
+                    .iter()
+                    .map(|(n, _)| format!("{n:?}"))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                D::Error::custom(format!(
+                    "invalid [daemon].resume_on_boot {name:?}; expected one of {known}"
+                ))
+            })
+    })
+    .transpose()
 }
 
 /// `[tui]` — `maestro tui` settings (NAP-275 epic, phase 2 NAP-277).
@@ -152,6 +231,15 @@ pub struct TuiSection {
     pub keymap_insert: BTreeMap<String, String>,
 }
 
+impl TuiSection {
+    /// The configured leader, or [`DEFAULT_LEADER`]. Named `[tui].leader` for
+    /// history, but read by every client: the daemon serves it on
+    /// `GET /api/info` so the web follows the same knob (#159).
+    pub fn leader(&self) -> &str {
+        self.leader.as_deref().unwrap_or(DEFAULT_LEADER)
+    }
+}
+
 /// Palette presets supported by the TUI's `[tui].theme` setting.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TuiTheme {
@@ -299,16 +387,19 @@ pub fn builtin_presets() -> Vec<SpawnPreset> {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
+            resume_command: Some("claude --resume {agent_session}".into()),
         },
         SpawnPreset {
             id: "opencode".into(),
             label: "opencode".into(),
             command: "opencode".into(),
+            resume_command: None,
         },
         SpawnPreset {
             id: "zsh".into(),
             label: "Shell".into(),
             command: "zsh".into(),
+            resume_command: None,
         },
     ]
 }
@@ -320,6 +411,7 @@ pub fn custom_preset() -> SpawnPreset {
         id: CUSTOM_PRESET_ID.into(),
         label: "Custom…".into(),
         command: String::new(),
+        resume_command: None,
     }
 }
 
@@ -493,6 +585,18 @@ auto_install = false
         assert!(custom.command.is_empty());
     }
 
+    #[test]
+    fn builtin_claude_preset_resumes_by_agent_session() {
+        let claude = builtin_presets()
+            .into_iter()
+            .find(|preset| preset.id == "claude")
+            .expect("Claude preset");
+        assert_eq!(
+            claude.resume_command.as_deref(),
+            Some("claude --resume {agent_session}")
+        );
+    }
+
     #[test]
     fn spawn_presets_override_replaces_builtins() {
         // Present list replaces the built-ins entirely; custom still appended.
@@ -501,6 +605,7 @@ auto_install = false
                 id: "fish".into(),
                 label: "fish".into(),
                 command: "fish".into(),
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -537,6 +642,7 @@ auto_install = false
                 id: "  ".into(),
                 label: "x".into(),
                 command: "x".into(),
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -547,6 +653,7 @@ auto_install = false
                 id: "x".into(),
                 label: "x".into(),
                 command: "".into(),
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -564,11 +671,13 @@ auto_install = false
                     id: "a".into(),
                     label: "a".into(),
                     command: "a".into(),
+                    resume_command: None,
                 },
                 SpawnPreset {
                     id: "a".into(),
                     label: "a2".into(),
                     command: "a2".into(),
+                    resume_command: None,
                 },
             ]),
             ..Default::default()
@@ -583,6 +692,7 @@ auto_install = false
                 id: "custom".into(),
                 label: "Custom".into(),
                 command: "whatever".into(),
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -618,6 +728,27 @@ presets = [
         assert_eq!(ids, ["claude", "zsh", "custom"]);
     }
 
+    #[test]
+    fn spawn_preset_parses_resume_command_from_issue_example() {
+        let cfg = toml::from_str::<MaestroConfigFile>(
+            r#"
+[spawn]
+presets = [
+  { id = "claude", command = "claude --dangerously-skip-permissions", resume_command = "claude --dangerously-skip-permissions --resume {agent_session}" }
+]
+"#,
+        )
+        .expect("issue #165 example parses");
+
+        let preset = &cfg.spawn.presets.expect("configured presets")[0];
+        assert_eq!(preset.id, "claude");
+        assert_eq!(preset.command, "claude --dangerously-skip-permissions");
+        assert_eq!(
+            preset.resume_command.as_deref(),
+            Some("claude --dangerously-skip-permissions --resume {agent_session}")
+        );
+    }
+
     #[test]
     fn spawn_project_scan_fields_default_to_none() {
         // Absent [spawn].project_* → None; the daemon applies its own defaults.
@@ -718,4 +849,27 @@ bind_addr = "127.0.0.1:9090"
         );
         assert_eq!(cfg.resolve_daemon_url(None), "http://explicit:1");
     }
+
+    #[test]
+    fn resume_on_boot_defaults_to_dormant_and_parses_every_policy() {
+        assert_eq!(
+            MaestroConfigFile::default().daemon.resume_on_boot(),
+            ResumeOnBoot::Dormant,
+            "an absent policy is the safe one"
+        );
+        for (name, expected) in RESUME_ON_BOOT_POLICIES {
+            let cfg = file_with(&format!("[daemon]\nresume_on_boot = \"{name}\"\n"));
+            assert_eq!(cfg.daemon.resume_on_boot(), *expected, "{name}");
+            assert_eq!(expected.as_str(), *name);
+        }
+    }
+
+    #[test]
+    fn resume_on_boot_rejects_an_unknown_policy() {
+        let err = toml::from_str::<MaestroConfigFile>("[daemon]\nresume_on_boot = \"maybe\"\n")
+            .expect_err("unknown policy must not silently fall back");
+        let msg = err.to_string();
+        assert!(msg.contains("resume_on_boot"), "{msg}");
+        assert!(msg.contains("\"auto\""), "{msg}");
+    }
 }

crates/maestro-daemon/src/attach.rs

@@ -26,11 +26,17 @@ pub(crate) async fn serve(
 ) -> Result<(), axum::Error> {
     let (mut sink, mut stream) = socket.split();
 
+    // This client's claim on the shared window size. Registered up front and
+    // released on every exit below, so a socket that dies mid-session stops
+    // constraining the size for the clients still attached.
+    let viewport = manager.attach_viewport();
+
     // NAP-229: send buffered scrollback up-front so the client sees the last
     // screenful immediately instead of a blank terminal. The replay lock the
     // bridge held during snapshot+subscribe guarantees no byte appears both
     // here and on the live receiver, and none is dropped at the seam.
     if !replay.is_empty() && sink.send(Message::Binary(replay)).await.is_err() {
+        manager.release_viewport(id, viewport).await;
         return Ok(());
     }
 
@@ -70,7 +76,7 @@ pub(crate) async fn serve(
                     if let Ok(ctrl) = serde_json::from_str::<ClientControl>(&text) {
                         match ctrl {
                             ClientControl::Resize { cols, rows } => {
-                                let _ = manager.resize(id, cols, rows).await;
+                                let _ = manager.set_viewport(id, viewport, cols, rows).await;
                             }
                             ClientControl::Ping => {
                                 let pong = serde_json::to_string(&ClientControl::Pong)
@@ -88,6 +94,8 @@ pub(crate) async fn serve(
         }
     }
 
+    manager.release_viewport(id, viewport).await;
+
     if session_ended {
         let _ = sink.send(Message::Close(None)).await;
     }

crates/maestro-daemon/src/boot_id.rs

@@ -0,0 +1,65 @@
+//! Tells a daemon restart from a host reboot (#164).
+//!
+//! `/proc/sys/kernel/random/boot_id` is fixed for the life of the kernel and
+//! changes on every boot. [`SessionManager::recover`] compares it against the
+//! value it stored on the previous run and logs which of the two it was.
+//!
+//! It does not decide liveness (#174). A boot id changes without the tmux
+//! server dying whenever the state directory is restored, a VM or container
+//! snapshot is rolled back, or the `boot_id` file is truncated — so recovery
+//! always probes `tmux list-sessions` and the boot id only says whether a
+//! server that did not answer is coming back.
+
+use std::path::Path;
+
+/// Where the daemon reads the running kernel's boot id. Behind a trait so
+/// tests can simulate a changed (or unreadable) boot id without rebooting the
+/// machine.
+pub trait BootIdSource: std::fmt::Debug + Send + Sync + 'static {
+    /// Current boot id, or `None` if it can't be determined (non-Linux,
+    /// restricted `/proc`, missing or empty file).
+    fn current(&self) -> Option<String>;
+}
+
+/// Production source: `/proc/sys/kernel/random/boot_id`.
+#[derive(Debug, Default)]
+pub struct ProcBootId;
+
+impl BootIdSource for ProcBootId {
+    fn current(&self) -> Option<String> {
+        read_boot_id(Path::new("/proc/sys/kernel/random/boot_id"))
+    }
+}
+
+fn read_boot_id(path: &Path) -> Option<String> {
+    let contents = std::fs::read_to_string(path).ok()?;
+    let trimmed = contents.trim();
+    (!trimmed.is_empty()).then(|| trimmed.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_trimmed_contents() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("boot_id");
+        std::fs::write(&path, "abc-123\n").unwrap();
+        assert_eq!(read_boot_id(&path).as_deref(), Some("abc-123"));
+    }
+
+    #[test]
+    fn missing_file_returns_none() {
+        let dir = tempfile::tempdir().unwrap();
+        assert_eq!(read_boot_id(&dir.path().join("missing")), None);
+    }
+
+    #[test]
+    fn empty_file_returns_none() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("boot_id");
+        std::fs::write(&path, "\n").unwrap();
+        assert_eq!(read_boot_id(&path), None);
+    }
+}

crates/maestro-daemon/src/cli.rs

@@ -83,7 +83,17 @@ 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,
-    ));
+    ))
+    // #171: mirror PTY scrollback so a resumed session opens on what it was
+    // showing, instead of a blank pane.
+    .with_scrollback(config.scrollback_dir())
+    .with_boot_id(
+        config.boot_id_path(),
+        std::sync::Arc::new(crate::boot_id::ProcBootId),
+    )
+    // #167: recovery needs the presets to resolve a resumed session's command,
+    // so `auto` runs the same resume a client's POST would.
+    .with_resume_policy(config.resume_on_boot, config.spawn_presets.clone());
     // Spawned sessions learn where to report back (#103). Derived from the
     // configured bind address; set before any spawn can happen.
     manager.set_daemon_url(format!("http://{}", config.bind_addr));
@@ -105,6 +115,7 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
         config.home_dir.clone(),
         config.spawn_presets.clone(),
         projects,
+        config.leader.clone(),
     ));
 
     let listener = TcpListener::bind(config.bind_addr).await?;

crates/maestro-daemon/src/config.rs

@@ -92,6 +92,15 @@ pub struct DaemonConfig {
     /// start when none is present (#106): `[hooks].auto_install`, default
     /// `true`.
     pub hooks_auto_install: bool,
+    /// Canonical leader key advertised to clients in `GET /api/info` (#159):
+    /// `[tui].leader`, default [`maestro_config::DEFAULT_LEADER`]. The daemon
+    /// never binds it itself; it serves it so the web client and the TUI read
+    /// one knob.
+    pub leader: String,
+    /// What recovery does with sessions whose tmux pane is gone but whose
+    /// sidecar survives (#167): `[daemon].resume_on_boot`, default
+    /// [`maestro_config::ResumeOnBoot::Dormant`].
+    pub resume_on_boot: maestro_config::ResumeOnBoot,
 }
 
 impl DaemonConfig {
@@ -107,6 +116,18 @@ impl DaemonConfig {
     pub fn spawn_history_path(&self) -> PathBuf {
         self.state_dir.join("spawn-history.jsonl")
     }
+
+    /// Where PTY scrollback is mirrored so a resumed session opens on what
+    /// it printed before (#171): `<state_dir>/scrollback`.
+    pub fn scrollback_dir(&self) -> PathBuf {
+        self.state_dir.join("scrollback")
+    }
+
+    /// Where recovery records the kernel boot id it saw last (#164):
+    /// `<state_dir>/boot_id`.
+    pub fn boot_id_path(&self) -> PathBuf {
+        self.state_dir.join("boot_id")
+    }
 }
 
 /// Env-var overrides applied by [`load_config`]. Tests pass explicit
@@ -138,6 +159,8 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
     // validation (#22/#26).
     let spawn_presets = file.spawn.resolve()?;
 
+    let resume_on_boot = daemon.resume_on_boot();
+
     let hostname = daemon.hostname.unwrap_or_else(system_hostname);
     let home_dir = dirs::home_dir()
         .map(|p| p.to_string_lossy().into_owned())
@@ -197,6 +220,8 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
         project_roots,
         project_scan_depth,
         hooks_auto_install: file.hooks.auto_install(),
+        leader: file.tui.leader().to_string(),
+        resume_on_boot,
     })
 }
 
@@ -233,6 +258,29 @@ pub fn system_hostname() -> String {
 mod tests {
     use super::*;
 
+    /// #159: the leader the operator set for the TUI is what the daemon
+    /// advertises, so rebinding it once moves both clients' chord.
+    #[test]
+    fn leader_defaults_to_ctrl_a_and_follows_the_tui_section() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.toml");
+
+        std::fs::write(&path, "").unwrap();
+        let cfg = load_config(&path, EnvOverrides::default()).unwrap();
+        assert_eq!(cfg.leader, "ctrl-a");
+
+        std::fs::write(
+            &path,
+            r#"
+[tui]
+leader = "ctrl-b"
+"#,
+        )
+        .unwrap();
+        let cfg = load_config(&path, EnvOverrides::default()).unwrap();
+        assert_eq!(cfg.leader, "ctrl-b");
+    }
+
     #[test]
     fn hooks_auto_install_defaults_true_and_is_opt_out() {
         let dir = tempfile::tempdir().unwrap();
@@ -254,6 +302,34 @@ auto_install = false
         assert!(!cfg.hooks_auto_install);
     }
 
+    #[test]
+    fn resume_on_boot_defaults_to_dormant_and_reads_the_file() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.toml");
+        std::fs::write(&path, "").unwrap();
+        assert_eq!(
+            load_config(&path, EnvOverrides::default())
+                .unwrap()
+                .resume_on_boot,
+            maestro_config::ResumeOnBoot::Dormant
+        );
+
+        std::fs::write(
+            &path,
+            r#"
+[daemon]
+resume_on_boot = "auto"
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            load_config(&path, EnvOverrides::default())
+                .unwrap()
+                .resume_on_boot,
+            maestro_config::ResumeOnBoot::Auto
+        );
+    }
+
     #[test]
     fn empty_file_defaults_everything() {
         let dir = tempfile::tempdir().unwrap();

crates/maestro-daemon/src/lib.rs

@@ -12,6 +12,7 @@ pub mod attach;
 /// Naming a session after its first prompt (#131).
 #[cfg(feature = "haiku-autoname")]
 pub mod autoname;
+pub mod boot_id;
 pub mod branches;
 pub mod cli;
 pub mod config;
@@ -24,12 +25,15 @@ pub mod proc;
 pub mod projects;
 pub mod pty;
 pub mod release;
+pub mod resume;
+pub mod scrollback;
 pub mod session;
 pub mod sidecar;
 pub mod spawn_history;
 #[cfg(feature = "web")]
 pub mod static_bundle;
 pub mod tmux;
+pub mod viewport;
 pub mod worktree;
 pub mod worktree_probe;
 

crates/maestro-daemon/src/local_api.rs

@@ -39,6 +39,10 @@ pub struct LocalApiState {
     pub presets: Arc<Vec<SpawnPreset>>,
     /// Project discovery (#54) backing `GET /api/projects`.
     pub projects: Arc<crate::projects::ProjectScanner>,
+    /// Configured leader key (`[tui].leader`) advertised in `GET /api/info`
+    /// (#159), so the web client binds the chord the operator configured
+    /// rather than its own default.
+    pub leader: Arc<String>,
 }
 
 pub fn router(state: LocalApiState) -> Router {
@@ -48,6 +52,7 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::patterns::SESSION_ACTIVITY, post(report_activity))
         .route(routes::patterns::SESSION_INPUT, post(send_input))
         .route(routes::patterns::SESSION_FOCUS, post(set_focus))
+        .route(routes::patterns::SESSION_RESUME, post(resume_session))
         .route(
             routes::patterns::SESSION,
             delete(kill_session).patch(rename_session),
@@ -166,6 +171,9 @@ fn session_error_status(code: &str) -> StatusCode {
         // The session outlived its pane: nothing to type into, and nothing
         // the daemon can do about it.
         "not_running" => StatusCode::CONFLICT,
+        // Resume refusals (#166): the session exists and the request was
+        // well-formed, it just cannot be brought back in this state.
+        "already_running" | "cwd_missing" => StatusCode::CONFLICT,
         _ => StatusCode::BAD_GATEWAY,
     }
 }
@@ -219,6 +227,7 @@ async fn daemon_info(State(s): State<LocalApiState>) -> Json<DaemonInfo> {
         presets: (*s.presets).clone(),
         build: crate::release::build_info(),
         instance: crate::release::instance_id().to_string(),
+        leader: (*s.leader).clone(),
     })
 }
 
@@ -302,7 +311,11 @@ async fn report_activity(
     Path(id): Path<Uuid>,
     Json(body): Json<ReportActivityRequest>,
 ) -> Response {
-    match s.manager.report_activity(id, body.state, body.detail).await {
+    match s
+        .manager
+        .report_activity(id, body.state, body.detail, body.session_id)
+        .await
+    {
         Ok(()) => StatusCode::NO_CONTENT.into_response(),
         Err(e) => {
             let info = e.to_error_info();
@@ -359,6 +372,27 @@ async fn set_focus(
     }
 }
 
+/// `POST /api/sessions/:id/resume` (#166): respawn a session that has no pane
+/// under its own id and sidecar, so its name, `created_at`, env and worktree
+/// ownership survive. Answers with the updated session, which also goes out as
+/// `SessionUpdated` to every events subscriber.
+///
+/// Refused with `409` when the session is already running or its `cwd` is
+/// gone; `404` when there is no such session.
+async fn resume_session(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
+    match s.manager.resume(id, &s.presets).await {
+        Ok(session) => (StatusCode::OK, Json(session)).into_response(),
+        Err(e) => {
+            let info = e.to_error_info();
+            error_response(
+                session_error_status(&info.code),
+                info.code.as_str(),
+                info.message.as_str(),
+            )
+        }
+    }
+}
+
 fn error_response(status: StatusCode, code: &str, message: &str) -> Response {
     (status, Json(ApiError::new(code, message))).into_response()
 }
@@ -374,6 +408,7 @@ pub fn state_for(
     home_dir: impl Into<String>,
     presets: Vec<SpawnPreset>,
     projects: Arc<crate::projects::ProjectScanner>,
+    leader: impl Into<String>,
 ) -> LocalApiState {
     LocalApiState {
         manager,
@@ -381,6 +416,7 @@ pub fn state_for(
         home_dir: Arc::new(home_dir.into()),
         presets: Arc::new(presets),
         projects,
+        leader: Arc::new(leader.into()),
     }
 }
 
@@ -399,6 +435,16 @@ async fn attach_ws(
     ws: axum::extract::WebSocketUpgrade,
 ) -> Result<Response, Response> {
     let Some((replay, rx)) = s.manager.subscribe_pty_with_replay(id).await else {
+        // #166: a session the daemon knows but has no bridge for — a dormant
+        // one — is not missing, it is not running. Reporting it as unknown
+        // left the client unable to tell "gone" from "resumable".
+        if s.manager.has(id).await {
+            return Err(error_response(
+                StatusCode::CONFLICT,
+                "not_attachable",
+                "session has no live pane; resume it first",
+            ));
+        }
         return Err(error_response(
             StatusCode::NOT_FOUND,
             "unknown_session",

crates/maestro-daemon/src/pty.rs

@@ -21,6 +21,11 @@
 //!   one-shot prefix before joining the live broadcast, so attaching to an
 //!   idle session immediately shows the last screenful instead of a blank
 //!   terminal.
+//! - #171: a bridge can be started with scrollback restored from disk — what
+//!   the session printed before the daemon (or the host) went away. Those
+//!   bytes are handed to subscribers ahead of the live ones until the ring
+//!   has a full budget of new output of its own, at which point the restored
+//!   history is older than anything the budget covers and is dropped.
 
 use std::collections::VecDeque;
 use std::ffi::CString;
@@ -58,6 +63,10 @@ const READ_BUF_BYTES: usize = 4096;
 #[derive(Debug)]
 pub struct PtyBridge {
     fifo_path: PathBuf,
+    /// Scrollback from a previous life of this session (#171), replayed
+    /// ahead of the ring. Empty for a fresh spawn. Never appended to, so it
+    /// can never duplicate a byte the ring also holds.
+    restored: Vec<u8>,
     /// `None` once [`Self::seal`] has run: live subscribers see the channel
     /// close, but the replay buffer stays readable.
     sender: Option<broadcast::Sender<Vec<u8>>>,
@@ -79,6 +88,21 @@ impl PtyBridge {
     /// Variant that lets the caller pick a custom replay-buffer cap (bytes).
     /// Pass `0` to disable replay (subscribers see only live bytes).
     pub async fn start_with_replay(fifo_path: PathBuf, replay_bytes: usize) -> io::Result<Self> {
+        Self::start_restoring(fifo_path, replay_bytes, Vec::new()).await
+    }
+
+    /// As [`Self::start_with_replay`], seeded with `restored` scrollback read
+    /// back from disk (#171). The seed is truncated to the same
+    /// `replay_bytes` budget the ring uses — there is one budget here, not
+    /// two — and is dropped entirely when replay is disabled.
+    pub async fn start_restoring(
+        fifo_path: PathBuf,
+        replay_bytes: usize,
+        mut restored: Vec<u8>,
+    ) -> io::Result<Self> {
+        if restored.len() > replay_bytes {
+            restored.drain(..restored.len() - replay_bytes);
+        }
         if let Some(parent) = fifo_path.parent() {
             tokio::fs::create_dir_all(parent).await?;
         }
@@ -102,6 +126,7 @@ impl PtyBridge {
         });
         Ok(Self {
             fifo_path,
+            restored,
             sender: Some(sender),
             replay,
             last_activity,
@@ -155,7 +180,8 @@ impl PtyBridge {
         F: FnOnce() -> Option<Vec<u8>>,
     {
         let guard = self.replay.lock_for_snapshot();
-        let snapshot = capture().unwrap_or_else(|| guard.snapshot());
+        let live = capture().unwrap_or_else(|| guard.snapshot());
+        let snapshot = guard.with_restored_prefix(&self.restored, live);
         let rx = match &self.sender {
             Some(tx) => tx.subscribe(),
             // Sealed: hand back the scrollback plus a receiver that is already
@@ -171,6 +197,25 @@ impl PtyBridge {
         (snapshot, rx)
     }
 
+    /// Everything worth persisting for a later life of this session (#171):
+    /// the restored scrollback and the ring, trimmed together to the replay
+    /// budget so the file on disk is never bigger than the ring it mirrors.
+    pub fn scrollback(&self) -> Vec<u8> {
+        let guard = self.replay.lock_for_snapshot();
+        guard.with_restored_prefix(&self.restored, guard.snapshot())
+    }
+
+    /// Total bytes this bridge has appended to its ring. The scrollback flush
+    /// pass compares it against what it last wrote, so an idle session costs
+    /// no disk writes at all.
+    pub fn bytes_seen(&self) -> u64 {
+        self.replay
+            .inner
+            .lock()
+            .expect("ReplayBuffer poisoned")
+            .seen
+    }
+
     /// Stop reading and close the live stream, keeping the replay buffer.
     ///
     /// Attached clients see the channel close — without that a `maestro attach`
@@ -201,6 +246,8 @@ struct ReplayBuffer {
 struct ReplayInner {
     buf: VecDeque<u8>,
     cap: usize,
+    /// Bytes ever appended, not bytes held — the ring evicts, this does not.
+    seen: u64,
 }
 
 impl ReplayBuffer {
@@ -209,6 +256,7 @@ impl ReplayBuffer {
             inner: Arc::new(Mutex::new(ReplayInner {
                 buf: VecDeque::with_capacity(cap.min(READ_BUF_BYTES * 2)),
                 cap,
+                seen: 0,
             })),
         }
     }
@@ -225,6 +273,7 @@ impl ReplayBuffer {
         // If the incoming chunk alone exceeds the cap, take only its tail —
         // anything in the buffer would be evicted before this finishes anyway.
         let take_from = bytes.len().saturating_sub(s.cap);
+        s.seen += bytes.len() as u64;
         let bytes = &bytes[take_from..];
         s.buf.extend(bytes);
         while s.buf.len() > s.cap {
@@ -247,6 +296,24 @@ struct ReplayGuard<'a> {
 }
 
 impl ReplayGuard<'_> {
+    /// `live` with the restored scrollback (#171) in front of it, while the
+    /// ring still holds less than a full budget of its own output. Once it
+    /// holds a full budget, everything restored is older than what the
+    /// budget covers, so it is dropped rather than kept forever.
+    fn with_restored_prefix(&self, restored: &[u8], live: Vec<u8>) -> Vec<u8> {
+        let cap = self.inner.cap;
+        let held = self.inner.buf.len();
+        if restored.is_empty() || cap == 0 || held >= cap {
+            return live;
+        }
+        let keep = cap - held;
+        let start = restored.len().saturating_sub(keep);
+        let mut out = Vec::with_capacity((restored.len() - start) + live.len());
+        out.extend_from_slice(&restored[start..]);
+        out.extend_from_slice(&live);
+        out
+    }
+
     fn snapshot(&self) -> Vec<u8> {
         let (a, b) = self.inner.buf.as_slices();
         let mut out = Vec::with_capacity(a.len() + b.len());
@@ -292,6 +359,7 @@ async fn run_reader(
                 // never both, never neither.
                 let mut s = replay.inner.lock().expect("ReplayBuffer poisoned");
                 if s.cap > 0 {
+                    s.seen += n as u64;
                     let take_from = n.saturating_sub(s.cap);
                     s.buf.extend(&buf[take_from..n]);
                     while s.buf.len() > s.cap {
@@ -345,6 +413,80 @@ fn shell_quote(s: &str) -> String {
 mod tests {
     use super::*;
 
+    async fn bridge(cap: usize, restored: &[u8]) -> (tempfile::TempDir, PtyBridge) {
+        let dir = tempfile::TempDir::new().expect("tempdir");
+        let bridge =
+            PtyBridge::start_restoring(dir.path().join("pty.fifo"), cap, restored.to_vec())
+                .await
+                .expect("start bridge");
+        (dir, bridge)
+    }
+
+    /// Feed the bridge through its own FIFO and wait for the reader to have
+    /// taken the bytes, so the ring state is deterministic.
+    async fn feed(bridge: &PtyBridge, bytes: &[u8]) {
+        use std::io::Write;
+        let before = bridge.bytes_seen();
+        let mut f = std::fs::OpenOptions::new()
+            .write(true)
+            .open(bridge.fifo_path())
+            .expect("open fifo for write");
+        f.write_all(bytes).expect("write fifo");
+        drop(f);
+        for _ in 0..400 {
+            if bridge.bytes_seen() >= before + bytes.len() as u64 {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+        }
+        panic!("bridge never read the bytes written to its fifo");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_is_replayed_ahead_of_live_bytes() {
+        let (_dir, bridge) = bridge(64, b"before the reboot\n").await;
+        feed(&bridge, b"after\n").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"before the reboot\nafter\n");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_is_trimmed_to_the_replay_budget() {
+        let (_dir, bridge) = bridge(4, b"abcdefghij").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"ghij");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_yields_once_the_ring_holds_a_full_budget() {
+        let (_dir, bridge) = bridge(4, b"old!").await;
+        feed(&bridge, b"ab").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"d!ab", "prefix plus ring stays inside the budget");
+        feed(&bridge, b"cd").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(
+            replay, b"abcd",
+            "restored history is now older than the budget"
+        );
+    }
+
+    #[tokio::test]
+    async fn scrollback_carries_the_restored_prefix_and_the_ring() {
+        let (_dir, bridge) = bridge(8, b"old").await;
+        feed(&bridge, b"new").await;
+        assert_eq!(bridge.scrollback(), b"oldnew");
+        assert_eq!(bridge.bytes_seen(), 3);
+    }
+
+    #[tokio::test]
+    async fn no_replay_budget_means_no_restored_scrollback() {
+        let (_dir, bridge) = bridge(0, b"old").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert!(replay.is_empty());
+        assert!(bridge.scrollback().is_empty());
+    }
+
     #[test]
     fn replay_buffer_keeps_last_cap_bytes() {
         let r = ReplayBuffer::new(4);

crates/maestro-daemon/src/resume.rs

@@ -0,0 +1,99 @@
+//! Choosing the command a resumed session comes back on (#166).
+//!
+//! A session records the command it was spawned with. Bringing it back means
+//! running that preset's `resume_command` (#165) instead, so an agent picks up
+//! its old conversation rather than starting a fresh one. Everything else
+//! about the session — id, sidecar, name, `created_at`, env, worktree — is
+//! untouched, so only the command is decided here.
+
+use maestro_protocol::{Session, SpawnPreset};
+
+/// The command to respawn `session` with.
+///
+/// The preset is matched on the command the session was spawned with, which is
+/// what the sidecar holds. A session with no matching preset, a preset with no
+/// `resume_command`, or a `resume_command` needing an agent session id the
+/// session never reported all fall back to the original command: respawning
+/// what the operator asked for is always honest, where a half-filled resume
+/// template is not.
+pub fn resume_command(session: &Session, presets: &[SpawnPreset]) -> String {
+    presets
+        .iter()
+        .find(|p| p.command == session.command)
+        .and_then(|p| p.resume_command_for(session.agent_session_id.as_deref()))
+        .unwrap_or_else(|| session.command.clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    fn presets() -> Vec<SpawnPreset> {
+        vec![
+            SpawnPreset {
+                id: "claude".into(),
+                label: "Claude".into(),
+                command: "claude".into(),
+                resume_command: Some("claude --resume {agent_session}".into()),
+            },
+            SpawnPreset {
+                id: "zsh".into(),
+                label: "Shell".into(),
+                command: "zsh".into(),
+                resume_command: None,
+            },
+        ]
+    }
+
+    fn session(command: &str, agent_session_id: Option<&str>) -> Session {
+        Session {
+            id: uuid::Uuid::new_v4(),
+            cwd: "/tmp".into(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+            status: maestro_protocol::SessionStatus::Dormant,
+            created_at: chrono::Utc::now(),
+            foreground: None,
+            activity: maestro_protocol::ActivityState::Idle,
+            activity_detail: None,
+            last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
+            current_cwd: None,
+            blocked_work: None,
+            last_focused_at: None,
+            agent_session_id: agent_session_id.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn uses_the_matching_presets_resume_command() {
+        assert_eq!(
+            resume_command(&session("claude", Some("conv-7")), &presets()),
+            "claude --resume conv-7"
+        );
+    }
+
+    #[test]
+    fn falls_back_when_the_agent_session_id_is_unknown() {
+        assert_eq!(
+            resume_command(&session("claude", None), &presets()),
+            "claude"
+        );
+    }
+
+    #[test]
+    fn falls_back_for_a_preset_without_a_resume_command() {
+        assert_eq!(resume_command(&session("zsh", None), &presets()), "zsh");
+    }
+
+    #[test]
+    fn falls_back_when_no_preset_matches() {
+        assert_eq!(
+            resume_command(&session("bash --noprofile", Some("conv-7")), &presets()),
+            "bash --noprofile"
+        );
+    }
+}

crates/maestro-daemon/src/scrollback.rs

@@ -0,0 +1,148 @@
+//! Persisted PTY scrollback (#171).
+//!
+//! The PTY replay ring lives in memory, so everything a session printed is
+//! gone the moment the daemon process is. A resumed session then opens on a
+//! blank pane: the agent's conversation is back, but the terminal history the
+//! operator was reading is not.
+//!
+//! This store mirrors each bridge's ring to `<state_dir>/scrollback/<id>.bin`,
+//! and hands it back when a session gets a new bridge — on resume, and on the
+//! recovery pass that re-adopts a session tmux still holds. The file is
+//! capped at the same `replay_bytes` budget the in-memory ring uses, so disk
+//! cost is bounded by the same number the operator already configures.
+//!
+//! Nothing here is allowed to fail a resume. The payload is raw PTY bytes
+//! with no framing to be corrupt, and a file that is missing, unreadable or
+//! oversized degrades to an empty (or truncated) pane rather than an error.
+
+use std::io;
+use std::path::{Path, PathBuf};
+
+use uuid::Uuid;
+
+/// Filesystem-backed scrollback store, rooted at a directory.
+#[derive(Debug, Clone)]
+pub struct ScrollbackStore {
+    dir: PathBuf,
+}
+
+impl ScrollbackStore {
+    pub fn new(dir: impl Into<PathBuf>) -> Self {
+        Self { dir: dir.into() }
+    }
+
+    pub fn dir(&self) -> &Path {
+        &self.dir
+    }
+
+    pub fn path_for(&self, id: Uuid) -> PathBuf {
+        self.dir.join(format!("{id}.bin"))
+    }
+
+    /// Atomically write `bytes` to `<dir>/<id>.bin`, creating the directory if
+    /// needed. Written through a temp file and renamed, so a reboot in the
+    /// middle of a flush leaves the previous scrollback intact rather than a
+    /// half-file.
+    pub fn write(&self, id: Uuid, bytes: &[u8]) -> io::Result<()> {
+        std::fs::create_dir_all(&self.dir)?;
+        let tmp = self.dir.join(format!("{id}.bin.tmp"));
+        std::fs::write(&tmp, bytes)?;
+        std::fs::rename(&tmp, self.path_for(id))
+    }
+
+    /// The stored scrollback for `id`, capped to the last `budget` bytes.
+    ///
+    /// Never fails: a missing file, an unreadable one, or a `budget` of zero
+    /// all read as "no scrollback", which is exactly the blank pane the
+    /// operator had before this existed.
+    pub fn read(&self, id: Uuid, budget: usize) -> Vec<u8> {
+        if budget == 0 {
+            return Vec::new();
+        }
+        let path = self.path_for(id);
+        let mut bytes = match std::fs::read(&path) {
+            Ok(b) => b,
+            Err(e) if e.kind() == io::ErrorKind::NotFound => return Vec::new(),
+            Err(e) => {
+                tracing::warn!(error = ?e, %id, path = %path.display(), "scrollback: unreadable, resuming with a blank pane");
+                return Vec::new();
+            }
+        };
+        // A file written under a larger budget than this daemon now runs
+        // with keeps its tail, the same end of the stream the ring would.
+        if bytes.len() > budget {
+            bytes.drain(..bytes.len() - budget);
+        }
+        bytes
+    }
+
+    /// Delete the scrollback for `id`. No-op if it is not there.
+    pub fn delete(&self, id: Uuid) -> io::Result<()> {
+        match std::fs::remove_file(self.path_for(id)) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn store() -> (tempfile::TempDir, ScrollbackStore) {
+        let dir = tempfile::TempDir::new().expect("tempdir");
+        let store = ScrollbackStore::new(dir.path().join("scrollback"));
+        (dir, store)
+    }
+
+    #[test]
+    fn round_trips_bytes() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"hello world").expect("write");
+        assert_eq!(store.read(id, 64), b"hello world");
+    }
+
+    #[test]
+    fn a_missing_file_reads_as_empty() {
+        let (_dir, store) = store();
+        assert!(store.read(Uuid::new_v4(), 64).is_empty());
+    }
+
+    #[test]
+    fn a_file_over_budget_keeps_its_tail() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"abcdefghij").expect("write");
+        assert_eq!(store.read(id, 4), b"ghij");
+    }
+
+    #[test]
+    fn a_zero_budget_reads_as_empty() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"abcdefghij").expect("write");
+        assert!(store.read(id, 0).is_empty());
+    }
+
+    #[test]
+    fn delete_removes_the_file_and_tolerates_a_missing_one() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"gone soon").expect("write");
+        store.delete(id).expect("delete");
+        assert!(!store.path_for(id).exists());
+        store.delete(id).expect("second delete is a no-op");
+    }
+
+    #[test]
+    fn a_second_write_replaces_the_first() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"first").expect("write");
+        store.write(id, b"second").expect("rewrite");
+        assert_eq!(store.read(id, 64), b"second");
+        assert!(!store.dir().join(format!("{id}.bin.tmp")).exists());
+    }
+}

crates/maestro-daemon/src/session.rs

@@ -7,10 +7,12 @@
 
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 
 use chrono::Utc;
+use maestro_config::ResumeOnBoot;
 use maestro_protocol::{
     ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, NameSource, Session,
     SessionStatus, WorktreeSpec, NAME_KEY, NAME_SOURCE_KEY,
@@ -18,11 +20,14 @@ use maestro_protocol::{
 use tokio::sync::{broadcast, Mutex};
 use uuid::Uuid;
 
+use crate::boot_id::BootIdSource;
 use crate::panes::Panes;
 use crate::pty::{pipe_pane_command, PtyBridge};
+use crate::scrollback::ScrollbackStore;
 use crate::sidecar::{SidecarError, SidecarStore};
 use crate::spawn_history::{RecentDir, SpawnHistory, SpawnHistoryRecord};
 use crate::tmux::TmuxError;
+use crate::viewport::{ViewportId, Viewports};
 use crate::worktree::{WorktreeError, WorktreeManager};
 
 /// Capacity of the session-events broadcast channel. A subscriber that falls
@@ -40,6 +45,16 @@ pub const DEFAULT_LIVENESS_INTERVAL: Duration = Duration::from_secs(2);
 /// attempt, which is all #83 needs.
 pub const DEFAULT_BLOCKED_WORK_INTERVAL: Duration = Duration::from_secs(15);
 
+/// How often the liveness watcher mirrors PTY scrollback to disk (#171).
+///
+/// A host reboot gives no warning and runs no exit path, so this interval is
+/// the whole guarantee: whatever a session printed in the last few seconds
+/// before the power went is what a resumed pane is missing. Ten seconds keeps
+/// that loss cosmetic — scrollback is visual continuity, not state — while
+/// costing at most one file write per *active* session per tick, since a
+/// session whose bridge read nothing is skipped entirely.
+pub const DEFAULT_SCROLLBACK_INTERVAL: Duration = Duration::from_secs(10);
+
 /// Gap between the text of a `send` and the Enter that submits it.
 ///
 /// Agents that run a full-screen prompt (Claude Code, opencode) coalesce a
@@ -60,7 +75,10 @@ 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>,
-    pub bridge: PtyBridge,
+    /// The PTY bridge feeding this session's attach stream. `None` for a
+    /// `Dormant` session (#162): there is no pane behind it, so there is
+    /// nothing to pipe and nothing to attach to.
+    pub bridge: Option<PtyBridge>,
     /// Agent-reported activity (#105) still within its TTL. While in force it
     /// outranks the activity pass's own inference; when it lapses, inference
     /// resumes and [`Session::activity_detail`] is cleared with it. This
@@ -80,11 +98,20 @@ pub struct SessionRecord {
     /// (`POST /.../focus`), `None` while unfocused. Daemon-local; never rides
     /// the wire.
     pub focused_since: Option<std::time::Instant>,
+    /// Set for as long as a [`SessionManager::resume`] is between its two
+    /// takes of the map lock (#175). The spawn happens with the lock released,
+    /// so the `Running` check alone lets a second request through; this is the
+    /// state the second one is refused on. Daemon-local; never rides the wire.
+    pub resuming: bool,
     /// Sticky acknowledgement applied by [`crate::activity::apply_focus_suppression`]:
     /// once the pane has been focused long enough to clear an `AwaitingInput`
     /// glow, this holds through focus loss until the session does new work.
     /// Daemon-local; never rides the wire.
     pub awaiting_suppressed: bool,
+    /// [`PtyBridge::bytes_seen`] as of this session's last scrollback flush
+    /// (#171). The flush pass skips a session whose bridge has read nothing
+    /// since, so an idle session costs no disk writes.
+    pub flushed_bytes: u64,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -106,6 +133,15 @@ pub enum SessionError {
     /// a stray keystroke on an attach socket, which is dropped.
     #[error("session is no longer running: {0}")]
     NotRunning(Uuid),
+    /// A resume (#166) was asked for a session that is already running. There
+    /// is nothing to bring back, and respawning would strand the pane that is
+    /// already there.
+    #[error("session is already running: {0}")]
+    AlreadyRunning(Uuid),
+    /// A resume (#166) was asked for a session whose working directory is
+    /// gone. Nothing can be resumed in a directory that no longer exists.
+    #[error("session working directory no longer exists: {0}")]
+    CwdMissing(PathBuf),
     /// The kill was refused (#79): the session's worktree holds unsaved work.
     /// Nothing happened — the session keeps running and the tree is untouched,
     /// so it stays the operator's handle on their own unfinished work.
@@ -124,6 +160,8 @@ impl SessionError {
             SessionError::InvalidEnv(_) => "invalid_env",
             SessionError::NotRunning(_) => "not_running",
             SessionError::KillGuarded(_) => "kill_guarded",
+            SessionError::AlreadyRunning(_) => "already_running",
+            SessionError::CwdMissing(_) => "cwd_missing",
         };
         let unsaved_work = match self {
             SessionError::KillGuarded(b) => Some(*b),
@@ -166,6 +204,42 @@ struct Inner {
     report_ttl: Duration,
     sessions: Mutex<HashMap<Uuid, SessionRecord>>,
     events: broadcast::Sender<CatalogEvent>,
+    /// Sizes reported by the clients attached to each session, and what tmux
+    /// was last told. See [`crate::viewport`] for why the window is not simply
+    /// set to whatever arrived most recently.
+    viewports: Mutex<Viewports>,
+    /// Hands out [`ViewportId`]s. Monotonic for the daemon's lifetime, so a
+    /// client that reconnects never collides with the registration its
+    /// previous socket has not finished releasing.
+    next_viewport: AtomicU64,
+    /// Boot-id tracking for `recover` (#164). `None` — the default — means
+    /// reboot detection is unwired, which behaves exactly like a boot id
+    /// that could never be read: always fall back to probing tmux.
+    boot_id: Option<BootIdConfig>,
+    /// What recovery does with a session whose pane is gone (#167), and the
+    /// presets an `auto` resume resolves its command from. Defaults to
+    /// [`ResumeOnBoot::Dormant`] with no presets: register and wait.
+    resume_policy: ResumeOnBoot,
+    resume_presets: Vec<maestro_protocol::SpawnPreset>,
+    /// Where PTY scrollback is mirrored so it survives the daemon, and the
+    /// host (#171). `None` — the default — means scrollback is not persisted
+    /// at all: a resumed session opens on a blank pane, exactly as before.
+    scrollback: Option<ScrollbackStore>,
+}
+
+/// Where recovery persists the boot id it last saw, and how it reads the
+/// current one. See [`crate::boot_id`].
+struct BootIdConfig {
+    path: PathBuf,
+    source: Arc<dyn BootIdSource>,
+}
+
+impl std::fmt::Debug for BootIdConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BootIdConfig")
+            .field("path", &self.path)
+            .finish_non_exhaustive()
+    }
 }
 
 impl SessionManager {
@@ -206,6 +280,12 @@ impl SessionManager {
                 report_ttl: crate::activity::REPORT_TTL,
                 sessions: Mutex::new(HashMap::new()),
                 events,
+                viewports: Mutex::new(Viewports::new()),
+                next_viewport: AtomicU64::new(0),
+                boot_id: None,
+                resume_policy: ResumeOnBoot::default(),
+                resume_presets: Vec::new(),
+                scrollback: None,
             }),
         }
     }
@@ -235,6 +315,56 @@ impl SessionManager {
         self
     }
 
+    /// Wire boot-id tracking for `recover` (#164). Builder, called once right
+    /// after construction like the other `with_*` methods. Without it,
+    /// `recover` always falls back to probing tmux — the same as a boot id
+    /// that could never be read.
+    ///
+    /// # Panics
+    ///
+    /// If the handle has already been cloned.
+    /// Persist PTY scrollback under `dir` (#171), so a resumed session comes
+    /// back showing what it printed before the daemon — or the host — went
+    /// away. Builder, called once right after construction like the other
+    /// `with_*` methods. Without it nothing is written, read or deleted.
+    ///
+    /// # Panics
+    ///
+    /// If the handle has already been cloned; see [`Self::with_spawn_history`].
+    pub fn with_scrollback(mut self, dir: PathBuf) -> Self {
+        let inner = Arc::get_mut(&mut self.inner)
+            .expect("with_scrollback must be called before the SessionManager is cloned");
+        inner.scrollback = Some(ScrollbackStore::new(dir));
+        self
+    }
+
+    pub fn with_boot_id(mut self, path: PathBuf, source: Arc<dyn BootIdSource>) -> Self {
+        let inner = Arc::get_mut(&mut self.inner)
+            .expect("with_boot_id must be called before the SessionManager is cloned");
+        inner.boot_id = Some(BootIdConfig { path, source });
+        self
+    }
+
+    /// Wire the `[daemon].resume_on_boot` policy (#167) and the spawn presets
+    /// an `auto` resume resolves each session's command from. Builder, called
+    /// once right after construction like the other `with_*` methods. Without
+    /// it, recovery behaves as [`ResumeOnBoot::Dormant`].
+    ///
+    /// # Panics
+    ///
+    /// If the handle has already been cloned.
+    pub fn with_resume_policy(
+        mut self,
+        policy: ResumeOnBoot,
+        presets: Vec<maestro_protocol::SpawnPreset>,
+    ) -> Self {
+        let inner = Arc::get_mut(&mut self.inner)
+            .expect("with_resume_policy must be called before the SessionManager is cloned");
+        inner.resume_policy = policy;
+        inner.resume_presets = presets;
+        self
+    }
+
     /// Set the daemon's own HTTP base URL (#103), exported to every session
     /// spawned afterwards as `MAESTRO_URL`. Unlike the `with_*` builders this
     /// is a plain setter: the daemon runner learns its bound address after
@@ -279,7 +409,10 @@ impl SessionManager {
     /// unknown to this daemon.
     pub async fn subscribe_pty(&self, id: Uuid) -> Option<broadcast::Receiver<Vec<u8>>> {
         let sessions = self.inner.sessions.lock().await;
-        sessions.get(&id).map(|r| r.bridge.subscribe())
+        sessions
+            .get(&id)
+            .and_then(|r| r.bridge.as_ref())
+            .map(|b| b.subscribe())
     }
 
     /// Subscribe to a session's PTY broadcast and return the replay buffer
@@ -298,19 +431,26 @@ impl SessionManager {
         let (result, updated) = {
             let mut sessions = self.inner.sessions.lock().await;
             let rec = sessions.get_mut(&id)?;
-            rec.session.last_focused_at = Some(Utc::now());
-            let updated = rec.session.clone();
+            let SessionRecord {
+                session, bridge, ..
+            } = &mut *rec;
+            // #162: a dormant session has no bridge and no pane — nothing was
+            // ever piped for it, so there is no stream to hand back and the
+            // attach reads as unknown. Checked before anything is stamped.
+            let bridge = bridge.as_ref()?;
+            session.last_focused_at = Some(Utc::now());
+            let updated = session.clone();
             // For a live session, tmux's own screen beats the byte tail: the
             // tail starts mid-stream, so a full-screen program (an agent TUI)
             // replayed from it renders as garbage until something forces a
             // repaint. A dead session has no pane left to capture, so it
             // keeps the byte tail.
-            let alive = rec.session.status == SessionStatus::Running;
+            let alive = session.status == SessionStatus::Running;
             // The capture shells out to tmux while the replay lock is held,
             // which parks the reader for the length of one tmux round-trip.
             // That only happens on attach, and the alternative is a seam in
             // the stream.
-            let result = rec.bridge.subscribe_with_snapshot(|| {
+            let result = bridge.subscribe_with_snapshot(|| {
                 if !alive {
                     return None;
                 }
@@ -466,6 +606,7 @@ impl SessionManager {
             // fresh tree has nothing in the way anyway.
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         };
 
         if let Err(e) = self.inner.sidecar.write(&session) {
@@ -487,13 +628,15 @@ impl SessionManager {
                     fifo_path,
                     worktree_path,
                     worktree_base_repo,
-                    bridge,
+                    bridge: Some(bridge),
                     reported_activity: None,
                     settled: false,
                     #[cfg(feature = "haiku-autoname")]
                     naming: false,
                     focused_since: None,
                     awaiting_suppressed: false,
+                    resuming: false,
+                    flushed_bytes: 0,
                 },
             );
         }
@@ -524,6 +667,184 @@ impl SessionManager {
         Ok(session)
     }
 
+    /// Bring a session that has no pane back to life (#166).
+    ///
+    /// The session comes back under the **same** uuid and the same sidecar, so
+    /// `metadata.name`, `created_at`, `env` and worktree ownership all survive
+    /// — only the tmux session and the PTY bridge are new. That is the whole
+    /// point: spawning a fresh session at the same path instead produces a
+    /// stranger with no worktree to clean up on kill.
+    ///
+    /// The command is [`crate::resume::resume_command`]: the matching preset's
+    /// `resume_command` (#165) with the session's own agent conversation id
+    /// substituted in, falling back to the command the session was spawned
+    /// with. `Session::command` keeps the original either way, so a second
+    /// resume still resolves the same preset.
+    ///
+    /// Refused for a session that is already running, and for one whose `cwd`
+    /// has disappeared — neither is something a respawn could fix.
+    pub async fn resume(
+        &self,
+        id: Uuid,
+        presets: &[maestro_protocol::SpawnPreset],
+    ) -> Result<Session, SessionError> {
+        // The spawn below runs with the map lock released, so the `Running`
+        // check alone is not enough to keep two resumes apart (#175): both
+        // would pass it, both would open a `PtyBridge` on the same FIFO, and
+        // the loser would report a tmux failure instead of the conflict it
+        // is. The record is marked in-flight under this first lock, and every
+        // path out of here clears it again.
+        let mut session = {
+            let mut sessions = self.inner.sessions.lock().await;
+            let rec = sessions.get_mut(&id).ok_or(SessionError::NotFound(id))?;
+            if rec.session.status == SessionStatus::Running || rec.resuming {
+                return Err(SessionError::AlreadyRunning(id));
+            }
+            rec.resuming = true;
+            rec.session.clone()
+        };
+        if !session.cwd.exists() {
+            self.clear_resuming(id).await;
+            return Err(SessionError::CwdMissing(session.cwd.clone()));
+        }
+        let command = crate::resume::resume_command(&session, presets);
+
+        // Same fifo path as the original spawn: it is derived from the id, and
+        // `mkfifo` tolerates the stale node the previous run left behind.
+        let fifo_path = self.inner.fifo_dir.join(format!("{id}.fifo"));
+        // #171: the pane is new, but the scrollback the operator was reading
+        // before the reboot is on disk. It goes in ahead of the live bytes.
+        let bridge = PtyBridge::start_restoring(
+            fifo_path.clone(),
+            self.inner.replay_bytes,
+            self.restored_scrollback(id),
+        )
+        .await?;
+        let mut session_env = sanitize_env(&session.env)?;
+        session_env.insert("MAESTRO_SESSION_ID".into(), id.to_string());
+        if let Some(url) = self
+            .inner
+            .daemon_url
+            .lock()
+            .expect("daemon_url mutex")
+            .clone()
+        {
+            session_env.insert("MAESTRO_URL".into(), url);
+        }
+        let spawned = {
+            let tmux = self.inner.tmux.clone();
+            let cwd = session.cwd.clone();
+            let command = command.clone();
+            let sink = pipe_pane_command(&fifo_path);
+            tmux_blocking(move || tmux.new_session_piped(id, &cwd, &command, &session_env, &sink))
+                .await
+        };
+        if let Err(e) = spawned {
+            // `bridge` drops here, closing the FIFO reader. Nothing else was
+            // touched, so the session stays exactly as dormant as it was.
+            self.clear_resuming(id).await;
+            return Err(SessionError::Tmux(e));
+        }
+
+        session.status = SessionStatus::Running;
+        // A resumed session is producing its initial output again; the
+        // watcher refines this on its next tick, exactly as after a spawn.
+        session.foreground = None;
+        session.activity = ActivityState::Active;
+        session.activity_detail = None;
+        session.last_activity_at = Utc::now();
+        session.activity_since = Utc::now();
+        session.current_cwd = None;
+        session.last_focused_at = None;
+
+        if let Err(e) = self.inner.sidecar.write(&session) {
+            // tmux already spawned; kill it rather than leave a pane the
+            // sidecar does not describe.
+            let tmux = self.inner.tmux.clone();
+            let _ = tmux_blocking(move || tmux.kill_session(id)).await;
+            self.clear_resuming(id).await;
+            return Err(SessionError::Sidecar(e));
+        }
+
+        {
+            let mut sessions = self.inner.sessions.lock().await;
+            let Some(rec) = sessions.get_mut(&id) else {
+                // Killed while we were spawning. Undo the pane instead of
+                // leaving one behind with no record of it — and delete the
+                // sidecar the write above just put back (#175). The kill
+                // deleted it before that write landed, so leaving it would
+                // have the next recovery register a dormant ghost for a
+                // session that is gone and whose worktree is already removed.
+                drop(sessions);
+                let tmux = self.inner.tmux.clone();
+                let _ = tmux_blocking(move || tmux.kill_session(id)).await;
+                if let Err(e) = self.inner.sidecar.delete(id) {
+                    tracing::warn!(error = ?e, %id, "resume: failed to delete the sidecar of a session killed mid-resume");
+                }
+                return Err(SessionError::NotFound(id));
+            };
+            rec.session = session.clone();
+            rec.fifo_path = fifo_path;
+            rec.bridge = Some(bridge);
+            rec.reported_activity = None;
+            rec.settled = false;
+            rec.focused_since = None;
+            rec.awaiting_suppressed = false;
+            rec.resuming = false;
+        }
+        let _ = self.inner.events.send(CatalogEvent::SessionUpdated {
+            session: session.clone(),
+        });
+        Ok(session)
+    }
+
+    /// Delete the scrollback of a sidecar recovery threw away (#171): the
+    /// session will never be listed again, so nothing would ever read it.
+    fn prune_scrollback(&self, id: Uuid) {
+        if let Some(store) = &self.inner.scrollback {
+            if let Err(e) = store.delete(id) {
+                tracing::warn!(error = ?e, %id, "recover: failed to prune scrollback");
+            }
+        }
+    }
+
+    /// Scrollback persisted for `id` by an earlier life of this session
+    /// (#171), capped to the replay budget. Empty when scrollback is not
+    /// wired, and empty — never an error — when the file is missing or
+    /// unreadable: a blank pane is the honest fallback, and it is what the
+    /// operator had before any of this existed.
+    fn restored_scrollback(&self, id: Uuid) -> Vec<u8> {
+        self.inner
+            .scrollback
+            .as_ref()
+            .map(|store| store.read(id, self.inner.replay_bytes))
+            .unwrap_or_default()
+    }
+
+    /// Mirror every live bridge's scrollback to disk (#171).
+    ///
+    /// Called on a timer by the liveness watcher rather than only on a clean
+    /// exit, because the case this exists for — a host reboot — runs no exit
+    /// path at all: anything flushed only on shutdown is missing exactly when
+    /// it is needed. Sessions whose bridge has read nothing since the last
+    /// flush are skipped, so an idle host writes nothing.
+    ///
+    /// Best-effort throughout: a failed write is warned and the session keeps
+    /// running.
+    pub async fn flush_scrollback(&self) {
+        run_scrollback_pass(&self.inner).await;
+    }
+
+    /// Drop the in-flight marker [`Self::resume`] set under its first lock
+    /// (#175), so a refused or failed resume can be retried. A no-op when the
+    /// record is already gone: a kill that landed mid-resume took the marker
+    /// with it.
+    async fn clear_resuming(&self, id: Uuid) {
+        if let Some(rec) = self.inner.sessions.lock().await.get_mut(&id) {
+            rec.resuming = false;
+        }
+    }
+
     /// Best-effort removal of a worktree created earlier in `create` when a
     /// later step fails. No-op when the request had no worktree.
     fn rollback_worktree(&self, base: &Option<PathBuf>, path: &Option<PathBuf>) {
@@ -614,6 +935,10 @@ impl SessionManager {
             // Start "due" so the first live tick probes: a recovered daemon
             // should not wait a full interval to show what blocks.
             let mut since_probe = blocked_work_interval;
+            // Scrollback starts *not* due: a daemon that just recovered has
+            // nothing new to mirror, and the sessions it adopted were primed
+            // from the files this would overwrite (#171).
+            let mut since_flush = Duration::ZERO;
             loop {
                 ticker.tick().await;
                 let Some(inner) = weak.upgrade() else {
@@ -628,6 +953,11 @@ impl SessionManager {
                     since_probe = Duration::ZERO;
                     run_blocked_work_pass(&inner).await;
                 }
+                since_flush += interval;
+                if since_flush >= DEFAULT_SCROLLBACK_INTERVAL {
+                    since_flush = Duration::ZERO;
+                    run_scrollback_pass(&inner).await;
+                }
             }
         });
     }
@@ -639,8 +969,20 @@ impl SessionManager {
     /// and start a `PtyBridge`. Sessions whose sidecar references a `cwd`
     /// that no longer exists are still adopted — the spec does not require
     /// us to repair them.
+    ///
+    /// #164/#174: the kernel's boot id says whether the host rebooted since
+    /// the last run, but it never decides which sessions are alive —
+    /// `tmux list-sessions` does, always, which is what the rest of the
+    /// daemon assumes. A boot id can change without the tmux server dying
+    /// (a restored state directory, a VM or container snapshot restore, a
+    /// truncated `boot_id` file); skipping the probe then registered every
+    /// live session `Dormant`, and resume could never bring one back because
+    /// the tmux name was still taken. The boot id is now only a signal that a
+    /// tmux server which did not answer is not coming back, and it names
+    /// itself in recovery's log.
     pub async fn recover(&self) -> Result<usize, SessionError> {
         tokio::fs::create_dir_all(&self.inner.fifo_dir).await?;
+        let rebooted = self.check_boot_id().await;
         let live = {
             let tmux = self.inner.tmux.clone();
             tmux_blocking(move || tmux.list_sessions()).await?
@@ -671,11 +1013,19 @@ impl SessionManager {
                     current_cwd: None,
                     blocked_work: None,
                     last_focused_at: None,
+                    agent_session_id: None,
                 },
             };
             let fifo_path = self.inner.fifo_dir.join(format!("{id}.fifo"));
-            let bridge =
-                PtyBridge::start_with_replay(fifo_path.clone(), self.inner.replay_bytes).await?;
+            // The ring the previous daemon held died with it, so an adopted
+            // session would otherwise replay nothing until tmux's own screen
+            // capture — which is one screenful, not scrollback (#171).
+            let bridge = PtyBridge::start_restoring(
+                fifo_path.clone(),
+                self.inner.replay_bytes,
+                self.restored_scrollback(id),
+            )
+            .await?;
             // Re-pipe so output starts flowing again. `Tmux::pipe_pane` runs
             // without tmux's `-o` flag, so any stale pipe the previous daemon
             // left running to a now-unread FIFO is replaced (NAP-228).
@@ -695,13 +1045,15 @@ 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()),
-                    bridge,
+                    bridge: Some(bridge),
                     reported_activity: None,
                     settled: false,
                     #[cfg(feature = "haiku-autoname")]
                     naming: false,
                     focused_since: None,
                     awaiting_suppressed: false,
+                    resuming: false,
+                    flushed_bytes: 0,
                 },
             );
             let _ = self
@@ -710,16 +1062,195 @@ impl SessionManager {
                 .send(CatalogEvent::SessionAdded { session });
             adopted += 1;
         }
+        self.register_dormant(rebooted).await;
         Ok(adopted)
     }
 
-    /// Forward keystrokes to a session's pane. A dead session is read-only —
-    /// its pane is gone, so this is a no-op rather than a tmux failure the
-    /// client would have to interpret.
+    /// Compare the running kernel's boot id against the one recovery stored
+    /// last time (#164), then persist the current one for next time. Returns
+    /// `true` only when both are known and differ — a host reboot.
+    ///
+    /// A missing stored value (first run) or an unreadable current one
+    /// (non-Linux, restricted `/proc`, unwired in this build) both read as
+    /// "no reboot". Either way the tmux probe runs (#174): the answer only
+    /// tells recovery whether a tmux server that did not answer is coming
+    /// back, never which sessions are alive.
+    async fn check_boot_id(&self) -> bool {
+        let Some(cfg) = &self.inner.boot_id else {
+            return false;
+        };
+        let Some(current) = cfg.source.current() else {
+            return false;
+        };
+        let stored = tokio::fs::read_to_string(&cfg.path)
+            .await
+            .ok()
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        let rebooted = stored.is_some_and(|s| s != current);
+        if let Some(parent) = cfg.path.parent() {
+            let _ = tokio::fs::create_dir_all(parent).await;
+        }
+        if let Err(e) = tokio::fs::write(&cfg.path, &current).await {
+            tracing::warn!(error = ?e, path = %cfg.path.display(), "recover: failed to persist boot id");
+        }
+        rebooted
+    }
+
+    /// Second recovery pass (#162): register every sidecar tmux had nothing to
+    /// adopt as a [`SessionStatus::Dormant`] session.
+    ///
+    /// A host reboot kills the tmux server, so the first pass runs over an
+    /// empty list and every session would otherwise disappear from the API
+    /// while its sidecar sat untouched on disk. A dormant record keeps the id,
+    /// name, cwd, command, worktree and `created_at` — everything the sidecar
+    /// holds — so the operator still has a record of what was running. It has
+    /// no tmux session and no [`PtyBridge`] behind it: it cannot be attached
+    /// to, cannot be typed into, and is skipped by both watcher passes. The
+    /// only thing left to do with one is dismiss it, which removes the sidecar
+    /// so the next recovery does not bring it back.
+    ///
+    /// Activity is not carried over: whatever the session was doing, it is not
+    /// doing it now. The rest of the sidecar is left as written.
+    ///
+    /// #163: a sidecar whose `cwd` no longer exists is pruned instead —
+    /// nothing can be resumed in a directory that is gone, so the honest move
+    /// is to delete the sidecar rather than register a record no operator can
+    /// act on. A sidecar whose `cwd` still exists is kept regardless of age.
+    ///
+    /// `rebooted` (#164) only changes what gets logged: a detected reboot
+    /// names the count even when it is zero, so the operator sees that
+    /// recovery told a reboot from a restart instead of a log that stays
+    /// silent either way. It never decides membership — everything here got
+    /// here by tmux not holding it (#174).
+    async fn register_dormant(&self, rebooted: bool) {
+        let stored = match self.inner.sidecar.load_all() {
+            Ok(stored) => stored,
+            Err(e) => {
+                tracing::warn!(error = ?e, "recover: reading sidecars for dormant sessions failed");
+                return;
+            }
+        };
+        let mut registered = Vec::new();
+        let mut pruned = 0usize;
+        let mut discarded = 0usize;
+        {
+            let mut sessions = self.inner.sessions.lock().await;
+            for mut session in stored {
+                if sessions.contains_key(&session.id) {
+                    // Adopted live by the first pass; its sidecar is on disk too.
+                    continue;
+                }
+                if !session.cwd.exists() {
+                    if let Err(e) = self.inner.sidecar.delete(session.id) {
+                        tracing::warn!(error = ?e, id = %session.id, "recover: failed to prune sidecar with missing cwd");
+                    }
+                    self.prune_scrollback(session.id);
+                    pruned += 1;
+                    continue;
+                }
+                if self.inner.resume_policy == ResumeOnBoot::Never {
+                    // #167: this host wants a reboot to be a clean slate, so
+                    // the sidecar goes the way #163's does — nothing is
+                    // registered and the next recovery finds nothing.
+                    if let Err(e) = self.inner.sidecar.delete(session.id) {
+                        tracing::warn!(error = ?e, id = %session.id, "recover: failed to prune sidecar under resume_on_boot=never");
+                    }
+                    self.prune_scrollback(session.id);
+                    discarded += 1;
+                    continue;
+                }
+                let id = session.id;
+                session.status = SessionStatus::Dormant;
+                session.foreground = None;
+                session.activity = ActivityState::Idle;
+                session.activity_detail = None;
+                sessions.insert(
+                    id,
+                    SessionRecord {
+                        session: session.clone(),
+                        fifo_path: self.inner.fifo_dir.join(format!("{id}.fifo")),
+                        // Still known, so a dismissal cleans the worktree up —
+                        // the same reason recovery restores it for a live
+                        // session (#54 review).
+                        worktree_path: session.worktree.as_ref().map(|w| w.path.clone()),
+                        worktree_base_repo: session.worktree.as_ref().map(|w| w.base_repo.clone()),
+                        bridge: None,
+                        reported_activity: None,
+                        settled: false,
+                        #[cfg(feature = "haiku-autoname")]
+                        naming: false,
+                        focused_since: None,
+                        awaiting_suppressed: false,
+                        resuming: false,
+                        flushed_bytes: 0,
+                    },
+                );
+                registered.push(session);
+            }
+        }
+        if rebooted {
+            tracing::info!(
+                dormant = registered.len(),
+                "host rebooted, sessions dormant"
+            );
+        } else if !registered.is_empty() {
+            tracing::info!(
+                dormant = registered.len(),
+                "registered sessions with no live tmux as dormant"
+            );
+        }
+        if pruned > 0 {
+            tracing::info!(pruned, "pruned sidecars whose cwd no longer exists");
+        }
+        let resumable: Vec<Uuid> = registered.iter().map(|s| s.id).collect();
+        for session in registered {
+            let _ = self
+                .inner
+                .events
+                .send(CatalogEvent::SessionAdded { session });
+        }
+
+        // #167: say which policy ran and how many sessions it acted on, so a
+        // host that resumes agents unattended says so in its own log. The
+        // match is exhaustive on purpose: a fourth policy must decide what it
+        // does here rather than inherit whichever arm happened to be last.
+        match self.inner.resume_policy {
+            ResumeOnBoot::Dormant => tracing::info!(
+                policy = ResumeOnBoot::Dormant.as_str(),
+                sessions = resumable.len(),
+                "resume_on_boot: sessions left dormant for the operator"
+            ),
+            ResumeOnBoot::Never => tracing::info!(
+                policy = ResumeOnBoot::Never.as_str(),
+                sessions = discarded,
+                "resume_on_boot: pruned the sidecars of sessions with no live pane"
+            ),
+            ResumeOnBoot::Auto => {
+                tracing::info!(
+                    policy = ResumeOnBoot::Auto.as_str(),
+                    sessions = resumable.len(),
+                    "resume_on_boot: resuming sessions with no live pane"
+                );
+                let presets = self.inner.resume_presets.clone();
+                for id in resumable {
+                    // The same call the client's POST /api/sessions/:id/resume
+                    // makes — one resume path, not two.
+                    if let Err(e) = self.resume(id, &presets).await {
+                        tracing::warn!(error = %e, id = %id, "resume_on_boot=auto: resume failed; session stays dormant");
+                    }
+                }
+            }
+        }
+    }
+
+    /// Forward keystrokes to a session's pane. A dead or dormant session is
+    /// read-only — its pane is gone, so this is a no-op rather than a tmux
+    /// failure the client would have to interpret.
     pub async fn send_keys(&self, id: Uuid, bytes: &[u8]) -> Result<(), SessionError> {
         match self.status(id).await {
             None => return Err(SessionError::NotFound(id)),
-            Some(SessionStatus::Dead) => return Ok(()),
+            Some(SessionStatus::Dead | SessionStatus::Dormant) => return Ok(()),
             Some(SessionStatus::Running) => {}
         }
         let tmux = self.inner.tmux.clone();
@@ -732,13 +1263,15 @@ impl SessionManager {
     /// Type `text` into a session's pane, with an Enter after it when
     /// `submit` is set.
     ///
-    /// Unlike [`Self::send_keys`], a dead session is an error: the caller
-    /// asked for text to land somewhere, and a silent success would let a
-    /// script believe an agent had been told something it never heard.
+    /// Unlike [`Self::send_keys`], a dead or dormant session is an error: the
+    /// caller asked for text to land somewhere, and a silent success would let
+    /// a script believe an agent had been told something it never heard.
     pub async fn send_input(&self, id: Uuid, text: &str, submit: bool) -> Result<(), SessionError> {
         match self.status(id).await {
             None => return Err(SessionError::NotFound(id)),
-            Some(SessionStatus::Dead) => return Err(SessionError::NotRunning(id)),
+            Some(SessionStatus::Dead | SessionStatus::Dormant) => {
+                return Err(SessionError::NotRunning(id))
+            }
             Some(SessionStatus::Running) => {}
         }
         let tmux = self.inner.tmux.clone();
@@ -756,12 +1289,12 @@ impl SessionManager {
         Ok(())
     }
 
-    /// Resize a session's window. No-op for a dead session, as with
+    /// Resize a session's window. No-op for a dead or dormant session, as with
     /// [`Self::send_keys`].
     pub async fn resize(&self, id: Uuid, cols: u16, rows: u16) -> Result<(), SessionError> {
         match self.status(id).await {
             None => return Err(SessionError::NotFound(id)),
-            Some(SessionStatus::Dead) => return Ok(()),
+            Some(SessionStatus::Dead | SessionStatus::Dormant) => return Ok(()),
             Some(SessionStatus::Running) => {}
         }
         let tmux = self.inner.tmux.clone();
@@ -770,6 +1303,52 @@ impl SessionManager {
             .map_err(SessionError::Tmux)
     }
 
+    /// Register a client that is about to start reporting its display size,
+    /// and hand back the handle it reports under.
+    ///
+    /// Cheap and infallible: the session it will report against is not
+    /// consulted until the first [`Self::set_viewport`].
+    pub fn attach_viewport(&self) -> ViewportId {
+        self.inner.next_viewport.fetch_add(1, Ordering::Relaxed)
+    }
+
+    /// A client reported the size it can display.
+    ///
+    /// The shared tmux window is resized only when the size arbitrated across
+    /// every attached client actually changes — see [`crate::viewport`]. Two
+    /// clients of different sizes used to resize the window past each other on
+    /// every report, which leaves a full-screen agent repainting into rows it
+    /// never clears and looking, to the operator, like a pane that has stopped
+    /// accepting input.
+    pub async fn set_viewport(
+        &self,
+        id: Uuid,
+        viewport: ViewportId,
+        cols: u16,
+        rows: u16,
+    ) -> Result<(), SessionError> {
+        let target = self
+            .inner
+            .viewports
+            .lock()
+            .await
+            .set(id, viewport, cols, rows);
+        match target {
+            Some((cols, rows)) => self.resize(id, cols, rows).await,
+            None => Ok(()),
+        }
+    }
+
+    /// Drop a detached client's claim on the window size, resizing to what the
+    /// clients still attached can display. Errors are the caller's to ignore:
+    /// a socket closing because its session died has nothing left to resize.
+    pub async fn release_viewport(&self, id: Uuid, viewport: ViewportId) {
+        let target = self.inner.viewports.lock().await.release(id, viewport);
+        if let Some((cols, rows)) = target {
+            let _ = self.resize(id, cols, rows).await;
+        }
+    }
+
     /// Rename a session (#125): set `metadata.name`, or clear it when the
     /// requested name is blank so the session falls back to its command.
     ///
@@ -823,11 +1402,20 @@ impl SessionManager {
     /// A report that changes the effective state restarts `activity_since`
     /// (#104's clock); re-reporting an unchanged state only extends the TTL
     /// and stays silent on the event stream at steady state.
+    ///
+    /// `agent_session_id` (#161) is the agent's own conversation id, parsed
+    /// by the caller from the hook payload's `session_id` field. The
+    /// sidecar is rewritten only when the reported id differs from the
+    /// stored one — a repeated report of the same id is pure churn from the
+    /// hook's `PreToolUse` cadence and writes nothing, but a resume (#176)
+    /// issues a new conversation id and must replace the stale one, or
+    /// every later resume reattaches the pre-resume conversation.
     pub async fn report_activity(
         &self,
         id: Uuid,
         state: ActivityState,
         detail: Option<String>,
+        agent_session_id: Option<String>,
     ) -> Result<(), SessionError> {
         let updated = {
             let mut sessions = self.inner.sessions.lock().await;
@@ -843,7 +1431,16 @@ impl SessionManager {
                 state,
                 self.inner.report_ttl,
             ));
-            changed.then(|| rec.session.clone())
+            let id_changed =
+                agent_session_id.is_some() && rec.session.agent_session_id != agent_session_id;
+            if id_changed {
+                rec.session.agent_session_id = agent_session_id;
+                self.inner
+                    .sidecar
+                    .write(&rec.session)
+                    .map_err(SessionError::Sidecar)?;
+            }
+            (changed || id_changed).then(|| rec.session.clone())
         };
         if let Some(session) = updated {
             let _ = self
@@ -1116,7 +1713,11 @@ async fn run_activity_pass(inner: &Arc<Inner>) {
                     rec.session.activity_detail = None;
                 }
             }
-            let idle = rec.bridge.idle_for();
+            // Only `Running` sessions reach this pass, and every one of them
+            // has a bridge; a dormant session has neither pane nor bridge.
+            let Some(idle) = rec.bridge.as_ref().map(|b| b.idle_for()) else {
+                continue;
+            };
             // #105: while a report is in force it supplies the state and
             // nothing here may overwrite it; only an unreported session is
             // decided by inference.
@@ -1222,6 +1823,36 @@ async fn run_blocked_work_pass(inner: &Arc<Inner>) {
     }
 }
 
+/// Mirror every live bridge's scrollback to disk. See
+/// [`SessionManager::flush_scrollback`].
+async fn run_scrollback_pass(inner: &Arc<Inner>) {
+    let Some(store) = inner.scrollback.clone() else {
+        return;
+    };
+    // Snapshot under the lock, write with it released: the writes are
+    // filesystem work and every attach needs this map.
+    let pending: Vec<(Uuid, Vec<u8>)> = {
+        let mut sessions = inner.sessions.lock().await;
+        sessions
+            .iter_mut()
+            .filter_map(|(id, rec)| {
+                let bridge = rec.bridge.as_ref()?;
+                let seen = bridge.bytes_seen();
+                if seen == rec.flushed_bytes {
+                    return None;
+                }
+                rec.flushed_bytes = seen;
+                Some((*id, bridge.scrollback()))
+            })
+            .collect()
+    };
+    for (id, bytes) in pending {
+        if let Err(e) = store.write(id, &bytes) {
+            tracing::warn!(error = ?e, %id, "scrollback: flush failed");
+        }
+    }
+}
+
 /// Mark a session whose tmux session has disappeared as [`SessionStatus::Dead`]
 /// and settle its worktree per the natural-exit rule (#82).
 ///
@@ -1234,8 +1865,10 @@ async fn run_blocked_work_pass(inner: &Arc<Inner>) {
 /// alone and stays attached to the dead record for a later forced dismissal
 /// (#81), which leaves it on disk too.
 ///
-/// Dead sessions do not survive a daemon restart: [`SessionManager::recover`]
-/// adopts only what tmux still holds.
+/// A dead session does not come back as dead across a daemon restart: its
+/// sidecar survives, so [`SessionManager::recover`]'s second pass registers it
+/// as [`SessionStatus::Dormant`] (#162) — accurate either way, since neither
+/// has a pane behind it.
 async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
     let flipped = {
         let mut sessions = inner.sessions.lock().await;
@@ -1244,7 +1877,18 @@ async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
                 record.session.status = SessionStatus::Dead;
                 // Release anyone attached; the scrollback survives for a later
                 // attach.
-                record.bridge.seal();
+                if let Some(bridge) = record.bridge.as_mut() {
+                    bridge.seal();
+                    // The clean-exit half of #171: the last thing the session
+                    // printed is what a later resume should open on, and it
+                    // will produce nothing more for the flush pass to notice.
+                    if let Some(store) = &inner.scrollback {
+                        if let Err(e) = store.write(id, &bridge.scrollback()) {
+                            tracing::warn!(error = ?e, %id, "scrollback: final flush failed");
+                        }
+                        record.flushed_bytes = bridge.bytes_seen();
+                    }
+                }
                 let session = record.session.clone();
                 let worktree = record
                     .worktree_base_repo
@@ -1265,6 +1909,7 @@ async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
             // The tree is settled (removed); a stale "in the way" would
             // describe something the session no longer holds.
             session.blocked_work = None;
+            session.worktree = None;
             let mut sessions = inner.sessions.lock().await;
             if let Some(record) = sessions.get_mut(&id) {
                 record.session.worktree = None;
@@ -1364,6 +2009,14 @@ async fn cleanup_record(
     if let Err(e) = inner.sidecar.delete(id) {
         tracing::warn!(error = ?e, %id, "cleanup: failed to delete sidecar");
     }
+    // #171: the session is gone, so its scrollback goes with it — nothing
+    // will ever read the file again, and leaving it would keep a killed
+    // session's output on disk indefinitely.
+    if let Some(store) = &inner.scrollback {
+        if let Err(e) = store.delete(id) {
+            tracing::warn!(error = ?e, %id, "cleanup: failed to delete scrollback");
+        }
+    }
     if let (Some(base), Some(path)) = (&record.worktree_base_repo, &record.worktree_path) {
         if keep_worktree {
             tracing::info!(

crates/maestro-daemon/src/viewport.rs

@@ -0,0 +1,186 @@
+//! What size the shared tmux window should be, given every client watching it.
+//!
+//! A tmux window has one size, but a session can have several clients attached
+//! at once — two browser panes, a browser and the TUI. Each reports the size
+//! *it* can display, and applying whichever arrived last makes the window
+//! flip-flop. Every flip forces a full-screen application (Claude Code, vim) to
+//! repaint at a new height, and the rows it drew at the old height are never
+//! cleared: the operator ends up looking at a stale input box, types into a
+//! box that is not where the screen says it is, and concludes the pane is
+//! stuck.
+//!
+//! So the window is sized to the smallest attached client on each axis — the
+//! same rule tmux uses for its own multiple clients, and the only size every
+//! client can render without truncation. The size last handed to tmux is
+//! remembered, so a report that changes nothing costs no `tmux` fork at all.
+
+use std::collections::HashMap;
+
+use uuid::Uuid;
+
+/// One attached client within a session. Allocated by
+/// [`crate::session::SessionManager`] and opaque to everything else.
+pub type ViewportId = u64;
+
+/// Per-session client sizes, and what tmux was last told.
+#[derive(Debug, Default)]
+pub struct Viewports {
+    clients: HashMap<Uuid, HashMap<ViewportId, (u16, u16)>>,
+    applied: HashMap<Uuid, (u16, u16)>,
+}
+
+impl Viewports {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Record what `viewport` can display. Returns the size tmux must be set
+    /// to, or `None` when the window already has it.
+    pub fn set(
+        &mut self,
+        session: Uuid,
+        viewport: ViewportId,
+        cols: u16,
+        rows: u16,
+    ) -> Option<(u16, u16)> {
+        self.clients
+            .entry(session)
+            .or_default()
+            .insert(viewport, (cols, rows));
+        self.settle(session)
+    }
+
+    /// Drop a client that has detached. Returns the size tmux must be set to
+    /// now that it no longer constrains the window.
+    ///
+    /// The last client leaving settles nothing: the window keeps the size it
+    /// has rather than snapping to some remembered default no one is watching.
+    pub fn release(&mut self, session: Uuid, viewport: ViewportId) -> Option<(u16, u16)> {
+        let clients = self.clients.get_mut(&session)?;
+        clients.remove(&viewport);
+        if clients.is_empty() {
+            self.clients.remove(&session);
+            self.applied.remove(&session);
+            return None;
+        }
+        self.settle(session)
+    }
+
+    /// The smallest size every attached client can render, but only when it
+    /// differs from what tmux was last told.
+    ///
+    /// A zero on either axis is a client that cannot display anything yet — a
+    /// pane still laying out, a hidden tab — and must not drag the shared
+    /// window down with it, so it is held but left out of the arbitration.
+    fn settle(&mut self, session: Uuid) -> Option<(u16, u16)> {
+        let clients = self.clients.get(&session)?;
+        let mut cols = u16::MAX;
+        let mut rows = u16::MAX;
+        for &(c, r) in clients.values() {
+            if c == 0 || r == 0 {
+                continue;
+            }
+            cols = cols.min(c);
+            rows = rows.min(r);
+        }
+        if cols == u16::MAX || rows == u16::MAX {
+            return None;
+        }
+        let target = (cols, rows);
+        if self.applied.get(&session) == Some(&target) {
+            return None;
+        }
+        self.applied.insert(session, target);
+        Some(target)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_first_report_settles_the_window() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        assert_eq!(v.set(s, 1, 80, 24), Some((80, 24)));
+    }
+
+    #[test]
+    fn a_report_that_changes_nothing_costs_no_resize() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        v.set(s, 1, 80, 24);
+        assert_eq!(v.set(s, 1, 80, 24), None);
+        assert_eq!(v.set(s, 1, 80, 24), None);
+    }
+
+    /// The bug this module exists for: two clients of different sizes used to
+    /// resize the window past each other on every report.
+    #[test]
+    fn two_clients_settle_on_the_smaller_instead_of_fighting() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        assert_eq!(v.set(s, 1, 53, 46), Some((53, 46)));
+        assert_eq!(v.set(s, 2, 53, 20), Some((53, 20)));
+        // Whatever order they re-report in, the answer stays the smaller one.
+        assert_eq!(v.set(s, 1, 53, 46), None);
+        assert_eq!(v.set(s, 2, 53, 20), None);
+        assert_eq!(v.set(s, 1, 53, 46), None);
+    }
+
+    #[test]
+    fn each_axis_is_arbitrated_on_its_own() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        v.set(s, 1, 200, 20);
+        assert_eq!(v.set(s, 2, 53, 46), Some((53, 20)));
+    }
+
+    #[test]
+    fn a_zero_sized_client_does_not_shrink_the_window() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        assert_eq!(v.set(s, 1, 80, 24), Some((80, 24)));
+        assert_eq!(v.set(s, 2, 0, 0), None);
+        assert_eq!(v.set(s, 2, 0, 30), None);
+    }
+
+    #[test]
+    fn releasing_the_small_client_gives_the_window_back() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        v.set(s, 1, 80, 46);
+        v.set(s, 2, 80, 20);
+        assert_eq!(v.release(s, 2), Some((80, 46)));
+    }
+
+    #[test]
+    fn releasing_the_last_client_settles_nothing() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        v.set(s, 1, 80, 24);
+        assert_eq!(v.release(s, 1), None);
+        // ...and the session is forgotten, so a fresh attach settles again.
+        assert_eq!(v.set(s, 2, 80, 24), Some((80, 24)));
+    }
+
+    #[test]
+    fn releasing_an_unknown_viewport_is_harmless() {
+        let mut v = Viewports::new();
+        let s = Uuid::new_v4();
+        assert_eq!(v.release(s, 7), None);
+        v.set(s, 1, 80, 24);
+        assert_eq!(v.release(s, 7), None);
+    }
+
+    #[test]
+    fn sessions_do_not_arbitrate_against_each_other() {
+        let mut v = Viewports::new();
+        let a = Uuid::new_v4();
+        let b = Uuid::new_v4();
+        assert_eq!(v.set(a, 1, 80, 24), Some((80, 24)));
+        assert_eq!(v.set(b, 2, 53, 20), Some((53, 20)));
+        assert_eq!(v.set(a, 1, 80, 24), None);
+    }
+}

crates/maestro-daemon/tests/activity_report.rs

@@ -18,6 +18,7 @@ use uuid::Uuid;
 
 struct Fixture {
     manager: SessionManager,
+    sidecar: SidecarStore,
     _tmux: TmuxFixture,
     _state_dir: TempDir,
 }
@@ -25,15 +26,17 @@ struct Fixture {
 async fn fixture(ttl: Duration) -> Fixture {
     let tmux = TmuxFixture::new();
     let state_dir = TempDir::new().unwrap();
+    let sidecar = SidecarStore::new(state_dir.path().join("sessions"));
     let manager = SessionManager::new(
         Arc::new(tmux.tmux.clone()),
-        SidecarStore::new(state_dir.path().join("sessions")),
+        sidecar.clone(),
         WorktreeManager::new(None),
         state_dir.path().join("fifos"),
     )
     .with_activity_report_ttl(ttl);
     Fixture {
         manager,
+        sidecar,
         _tmux: tmux,
         _state_dir: state_dir,
     }
@@ -67,7 +70,7 @@ async fn report_on_unknown_session_is_not_found() {
     let fx = fixture(Duration::from_secs(300)).await;
     let err = fx
         .manager
-        .report_activity(Uuid::new_v4(), ActivityState::Idle, None)
+        .report_activity(Uuid::new_v4(), ActivityState::Idle, None, None)
         .await
         .unwrap_err();
     assert!(matches!(err, maestro_daemon::SessionError::NotFound(_)));
@@ -83,6 +86,7 @@ async fn report_sets_error_state_and_detail() {
             id,
             ActivityState::Error,
             Some("cargo build failed: link error".into()),
+            None,
         )
         .await
         .unwrap();
@@ -101,7 +105,7 @@ async fn replacing_a_report_replaces_both_state_and_detail() {
     let id = spawn_sleeping(&fx.manager).await;
 
     fx.manager
-        .report_activity(id, ActivityState::Error, Some("first failure".into()))
+        .report_activity(id, ActivityState::Error, Some("first failure".into()), None)
         .await
         .unwrap();
     fx.manager
@@ -109,6 +113,7 @@ async fn replacing_a_report_replaces_both_state_and_detail() {
             id,
             ActivityState::AwaitingInput,
             Some("needs approval".into()),
+            None,
         )
         .await
         .unwrap();
@@ -125,7 +130,7 @@ async fn detail_is_capped_server_side() {
 
     let long = "x".repeat(10_000);
     fx.manager
-        .report_activity(id, ActivityState::Error, Some(long))
+        .report_activity(id, ActivityState::Error, Some(long), None)
         .await
         .unwrap();
 
@@ -144,7 +149,12 @@ async fn reported_state_survives_watcher_ticks_until_the_ttl_then_inference_resu
     fx.manager.start_liveness_watcher(Duration::from_millis(50));
 
     fx.manager
-        .report_activity(id, ActivityState::Error, Some("agent died mid-run".into()))
+        .report_activity(
+            id,
+            ActivityState::Error,
+            Some("agent died mid-run".into()),
+            None,
+        )
         .await
         .unwrap();
 
@@ -162,3 +172,100 @@ async fn reported_state_survives_watcher_ticks_until_the_ttl_then_inference_resu
     })
     .await;
 }
+
+#[tokio::test]
+async fn a_reported_session_id_is_recorded_on_the_session() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-abc123".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-abc123"));
+}
+
+/// #161: repeated reports of the same id are pure churn from the hook's
+/// `PreToolUse` cadence — the sidecar must not be rewritten for them.
+#[tokio::test]
+async fn a_repeated_report_of_the_same_session_id_writes_nothing() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-first"));
+}
+
+/// #176: a resume issues a new conversation id. The stored id must move to
+/// it, or every later resume reattaches the stale pre-resume conversation.
+#[tokio::test]
+async fn a_reported_session_id_is_replaced_when_it_differs() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-second".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-second"));
+
+    let stored = fx
+        .sidecar
+        .read(id)
+        .expect("sidecar read")
+        .expect("sidecar present");
+    assert_eq!(stored.agent_session_id.as_deref(), Some("conv-second"));
+}
+
+#[tokio::test]
+async fn a_reported_session_id_survives_recovery_from_the_sidecar() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-abc123".into()))
+        .await
+        .unwrap();
+
+    let stored = fx
+        .sidecar
+        .read(id)
+        .expect("sidecar read")
+        .expect("sidecar present");
+    assert_eq!(stored.agent_session_id.as_deref(), Some("conv-abc123"));
+
+    // The sidecar holding the id is only half the claim: a restarted daemon
+    // has to carry it back onto the recovered session, which is what a resume
+    // reads. Build a parallel manager over the same tmux server and state
+    // dirs and recover through it.
+    let revived = SessionManager::new(
+        Arc::new(fx._tmux.tmux.clone()),
+        fx.sidecar.clone(),
+        WorktreeManager::new(None),
+        fx._state_dir.path().join("fifos"),
+    );
+    revived.recover().await.expect("recover");
+    let recovered = observed(&revived, id).await;
+    assert_eq!(
+        recovered.agent_session_id.as_deref(),
+        Some("conv-abc123"),
+        "the recovered session must carry the agent session id, not just the sidecar"
+    );
+}

crates/maestro-daemon/tests/attach.rs

@@ -38,6 +38,7 @@ async fn spawn_daemon_ws() -> Harness {
         "/home/test",
         Vec::new(),
         std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await
@@ -93,6 +94,74 @@ async fn rejects_unknown_session() {
     assert!(format!("{err}").contains("404"));
 }
 
+/// #166: a session the daemon knows but has no bridge for is not unknown, it
+/// is not running. `404 unknown_session` made "gone" and "resumable" look the
+/// same to a client that could have offered a resume.
+#[tokio::test]
+async fn dormant_session_is_not_attachable_rather_than_unknown() {
+    let h = spawn_daemon_ws().await;
+    let cwd = TempDir::new().unwrap();
+    let session = h
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .unwrap();
+
+    // The host reboot: tmux is gone, the sidecar is not, and a fresh manager
+    // registers the session dormant.
+    h._fx.tmux.tmux.kill_server().unwrap();
+    let dormant = SessionManager::new(
+        std::sync::Arc::new(h._fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(h._fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        h._fx.fifo_dir(),
+    );
+    dormant.recover().await.unwrap();
+    let dormant_addr = serve_manager(dormant).await;
+
+    let err = connect_attach(dormant_addr, session.id).await.unwrap_err();
+    let tokio_tungstenite::tungstenite::Error::Http(resp) = err else {
+        panic!("want an HTTP rejection, got {err}");
+    };
+    assert_eq!(resp.status().as_u16(), 409);
+    let body: maestro_protocol::ApiError =
+        serde_json::from_slice(resp.body().as_deref().expect("error body")).unwrap();
+    assert_eq!(body.error.code, "not_attachable");
+
+    // A session that really is unknown still reads as unknown.
+    let err = connect_attach(dormant_addr, Uuid::new_v4())
+        .await
+        .unwrap_err();
+    assert!(format!("{err}").contains("404"));
+}
+
+/// Serve `manager` on its own listener, for tests that need a second daemon
+/// over the same tmux/sidecar state.
+async fn serve_manager(manager: SessionManager) -> SocketAddr {
+    let router = local_api::router(local_api::state_for(
+        manager,
+        "test-host",
+        "/home/test",
+        Vec::new(),
+        std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
+    ));
+    let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
+        .await
+        .unwrap();
+    let addr = listener.local_addr().unwrap();
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router).await;
+    });
+    addr
+}
+
 #[tokio::test]
 async fn pty_round_trip_through_real_tmux() {
     let h = spawn_daemon_ws().await;

crates/maestro-daemon/tests/branches.rs

@@ -27,6 +27,7 @@ async fn spawn() -> Harness {
         "/home/test",
         presets,
         Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await

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

@@ -151,27 +151,40 @@ pub struct DaemonFixture {
 
 impl DaemonFixture {
     pub fn new() -> Self {
-        Self::build(None)
+        Self::build(None, maestro_daemon::pty::DEFAULT_REPLAY_BYTES)
+    }
+
+    /// Variant whose manager runs a custom PTY replay budget (NAP-229), which
+    /// also caps the scrollback it persists (#171).
+    pub fn new_with_replay(replay_bytes: usize) -> Self {
+        Self::build(None, replay_bytes)
     }
 
     /// Variant whose manager has a durable spawn history (#24) attached, with
     /// `retention_days` recency cap, logging to `<state_dir>/spawn-history.jsonl`.
     pub fn new_with_history(retention_days: u32) -> Self {
-        Self::build(Some(retention_days))
+        Self::build(
+            Some(retention_days),
+            maestro_daemon::pty::DEFAULT_REPLAY_BYTES,
+        )
     }
 
-    fn build(history_days: Option<u32>) -> Self {
+    fn build(history_days: Option<u32>, replay_bytes: usize) -> Self {
         let tmux = TmuxFixture::new();
         let state_dir = TempDir::new().unwrap();
         let sidecar = SidecarStore::new(state_dir.path().join("sessions"));
         // Default placement: worktrees land under their base repo (#56).
         let worktree_mgr = WorktreeManager::new(None);
-        let mut manager = SessionManager::new(
+        let mut manager = SessionManager::new_with_replay(
             Arc::new(tmux.tmux.clone()),
             sidecar,
             worktree_mgr,
             state_dir.path().join("fifos"),
+            replay_bytes,
         );
+        // #171: production wires this, so the fixtures do too — every test
+        // then exercises the same flush/restore/delete paths the daemon runs.
+        manager = manager.with_scrollback(state_dir.path().join("scrollback"));
         if let Some(days) = history_days {
             manager =
                 manager.with_spawn_history(SpawnHistory::new(Self::history_path(&state_dir), days));
@@ -198,4 +211,8 @@ impl DaemonFixture {
     pub fn fifo_dir(&self) -> PathBuf {
         self.state_dir.path().join("fifos")
     }
+
+    pub fn scrollback_dir(&self) -> PathBuf {
+        self.state_dir.path().join("scrollback")
+    }
 }

crates/maestro-daemon/tests/local_api.rs

@@ -36,6 +36,14 @@ async fn spawn(hostname: &str) -> Harness {
 async fn spawn_with(
     hostname: &str,
     projects: std::sync::Arc<maestro_daemon::projects::ProjectScanner>,
+) -> Harness {
+    spawn_with_leader(hostname, projects, maestro_config::DEFAULT_LEADER).await
+}
+
+async fn spawn_with_leader(
+    hostname: &str,
+    projects: std::sync::Arc<maestro_daemon::projects::ProjectScanner>,
+    leader: &str,
 ) -> Harness {
     let fx = DaemonFixture::new();
     let manager = fx.manager.clone();
@@ -48,6 +56,7 @@ async fn spawn_with(
         "/home/test",
         presets,
         projects,
+        leader,
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await
@@ -91,6 +100,38 @@ async fn info_returns_daemon_identity() {
     assert!(resp["version"].is_string());
 }
 
+/// #159: the web client reads its leader off `/api/info` instead of a
+/// hardcoded constant, so the payload has to carry the configured one — not
+/// the default dressed up as one.
+#[tokio::test]
+async fn info_advertises_the_configured_leader() {
+    let h = spawn_with_leader(
+        "naps-laptop",
+        std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        "ctrl-b",
+    )
+    .await;
+    let resp: serde_json::Value = reqwest::get(url(h.addr, "/api/info"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert_eq!(resp["leader"], "ctrl-b");
+}
+
+#[tokio::test]
+async fn info_reports_the_default_leader_when_unconfigured() {
+    let h = spawn("naps-laptop").await;
+    let resp: serde_json::Value = reqwest::get(url(h.addr, "/api/info"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert_eq!(resp["leader"], "ctrl-a");
+}
+
 #[tokio::test]
 async fn info_reports_build_and_instance() {
     // The status indicator needs a release to name and a process to compare
@@ -485,6 +526,33 @@ async fn post_activity_reports_error_with_detail() {
     assert_eq!(s.activity_detail.as_deref(), Some("cargo build failed"));
 }
 
+/// #161: a reported `session_id` lands on the session as `agent_session_id`.
+#[tokio::test]
+async fn post_activity_records_the_reported_session_id() {
+    let h = spawn("naps-laptop").await;
+    let id = spawn_via_manager(&h).await;
+
+    let resp = reqwest::Client::new()
+        .post(url(h.addr, &format!("/api/sessions/{id}/activity")))
+        .json(&serde_json::json!({
+            "state": "Active",
+            "session_id": "conv-abc123"
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NO_CONTENT);
+
+    let sessions: Vec<Session> = reqwest::get(url(h.addr, "/api/sessions"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    let s = sessions.iter().find(|s| s.id == id).unwrap();
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-abc123"));
+}
+
 #[tokio::test]
 async fn post_activity_to_unknown_session_returns_404() {
     let h = spawn("naps-laptop").await;

crates/maestro-daemon/tests/resume.rs

@@ -0,0 +1,593 @@
+//! End-to-end tests for `POST /api/sessions/:id/resume` (#166) and the
+//! manager call behind it, against real tmux.
+//!
+//! The point of resume is that the session comes back under the *same* uuid
+//! and sidecar — name, `created_at`, env and worktree ownership intact — with
+//! only the tmux session and the PTY bridge new.
+
+mod common;
+
+use std::collections::HashMap;
+use std::net::{Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_daemon::{local_api, SessionError, SessionManager};
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus, SpawnPreset};
+use tempfile::TempDir;
+use tokio::net::TcpListener;
+use tokio::sync::oneshot;
+use uuid::Uuid;
+
+/// A fresh manager over the same tmux server, sidecars and fifos — what the
+/// daemon builds after a restart.
+fn revive(fx: &DaemonFixture) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+}
+
+/// Create a session, then simulate the host reboot that leaves it dormant:
+/// the tmux server dies, the sidecar stays, a new manager recovers.
+async fn dormant_session(
+    fx: &DaemonFixture,
+    cwd: &TempDir,
+    command: &str,
+    name: &str,
+) -> (SessionManager, Session) {
+    let mut metadata = HashMap::new();
+    metadata.insert(
+        maestro_protocol::NAME_KEY.to_string(),
+        serde_json::Value::String(name.into()),
+    );
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::from([("MAESTRO_TEST_ENV".to_string(), "kept".to_string())]),
+            metadata,
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let revived = revive(fx);
+    revived.recover().await.expect("recover");
+    (revived, session)
+}
+
+fn marker_preset(command: &str, marker_dir: &TempDir) -> Vec<SpawnPreset> {
+    vec![SpawnPreset {
+        id: "agent".into(),
+        label: "Agent".into(),
+        command: command.into(),
+        resume_command: Some(format!(
+            "sh -c 'touch {}/resumed-{{agent_session}}; sleep 30'",
+            marker_dir.path().display()
+        )),
+    }]
+}
+
+/// The keystone: a dormant session comes back running under its own id, with
+/// its name, `created_at`, env and sidecar untouched.
+#[tokio::test]
+async fn resume_brings_a_dormant_session_back_under_the_same_id() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, original) = dormant_session(&fx, &cwd, "sleep 30", "long-runner").await;
+    assert_eq!(
+        manager.status(original.id).await,
+        Some(SessionStatus::Dormant)
+    );
+
+    let resumed = manager.resume(original.id, &[]).await.expect("resume");
+
+    assert_eq!(resumed.id, original.id, "same uuid");
+    assert_eq!(resumed.status, SessionStatus::Running);
+    assert_eq!(resumed.created_at, original.created_at);
+    assert_eq!(resumed.cwd, original.cwd);
+    assert_eq!(resumed.command, original.command);
+    assert_eq!(resumed.env, original.env);
+    assert_eq!(
+        resumed
+            .metadata
+            .get(maestro_protocol::NAME_KEY)
+            .and_then(|v| v.as_str()),
+        Some("long-runner")
+    );
+
+    // tmux really holds it again, and the sidecar is the same file, updated.
+    let live = fx.tmux.tmux.list_sessions().expect("list");
+    assert_eq!(live, vec![original.id]);
+    let stored = maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+        .read(original.id)
+        .expect("read sidecar")
+        .expect("sidecar still there");
+    assert_eq!(stored.status, SessionStatus::Running);
+    assert_eq!(stored.created_at, original.created_at);
+
+    // And it is attachable again, which a dormant session never was.
+    assert!(manager
+        .subscribe_pty_with_replay(original.id)
+        .await
+        .is_some());
+}
+
+/// The worktree the session owns stays the session's, so killing the resumed
+/// session still cleans the tree up.
+#[tokio::test]
+async fn resume_keeps_worktree_ownership() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    common::init_repo(repo.path());
+
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: repo.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: Some(maestro_protocol::WorktreeSpec {
+                base_repo: repo.path().to_path_buf(),
+                branch: "feature".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+    let worktree = session.worktree.clone().expect("worktree");
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    let resumed = manager.resume(session.id, &[]).await.expect("resume");
+
+    assert_eq!(resumed.worktree, Some(worktree.clone()));
+    assert_eq!(
+        resumed.cwd, worktree.path,
+        "resumed inside its own worktree"
+    );
+}
+
+/// The command comes from the preset's `resume_command`, with the session's
+/// own agent conversation id (#161) substituted in.
+#[tokio::test]
+async fn resume_runs_the_presets_resume_command() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let markers = TempDir::new().unwrap();
+    let presets = marker_preset("sleep 30", &markers);
+
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "agentic").await;
+    // The agent reported its conversation id before the reboot, so it is on
+    // the sidecar and the resume template can be filled in.
+    fx.manager
+        .report_activity(
+            session.id,
+            maestro_protocol::ActivityState::Idle,
+            None,
+            Some("conv-42".into()),
+        )
+        .await
+        .ok();
+    // Re-read the sidecar the report updated.
+    let manager = {
+        drop(manager);
+        let m = revive(&fx);
+        m.recover().await.expect("recover");
+        m
+    };
+
+    manager.resume(session.id, &presets).await.expect("resume");
+
+    let marker = markers.path().join("resumed-conv-42");
+    wait_for_async(Duration::from_secs(5), || {
+        let marker = marker.clone();
+        async move { marker.exists() }
+    })
+    .await;
+}
+
+/// A session that is already running has nothing to bring back, and
+/// respawning would strand the pane that is already there.
+#[tokio::test]
+async fn resume_refuses_a_running_session() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let err = fx
+        .manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("already running");
+    assert!(matches!(err, SessionError::AlreadyRunning(id) if id == session.id));
+    assert_eq!(err.to_error_info().code, "already_running");
+}
+
+/// Nothing can be resumed in a directory that no longer exists.
+#[tokio::test]
+async fn resume_refuses_when_the_cwd_is_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "homeless").await;
+
+    std::fs::remove_dir_all(cwd.path()).unwrap();
+
+    let err = manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("cwd is gone");
+    assert_eq!(err.to_error_info().code, "cwd_missing");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant),
+        "a refused resume leaves the session exactly as it was"
+    );
+}
+
+#[tokio::test]
+async fn resume_of_an_unknown_session_is_not_found() {
+    let fx = DaemonFixture::new();
+    let err = fx
+        .manager
+        .resume(Uuid::new_v4(), &[])
+        .await
+        .expect_err("unknown");
+    assert_eq!(err.to_error_info().code, "not_found");
+}
+
+// ---------------------------------------------------------------------------
+// HTTP surface
+// ---------------------------------------------------------------------------
+
+struct Harness {
+    addr: SocketAddr,
+    _shutdown: oneshot::Sender<()>,
+}
+
+async fn serve(manager: SessionManager, presets: Vec<SpawnPreset>) -> Harness {
+    let router = local_api::router(local_api::state_for(
+        manager,
+        "test-host",
+        "/home/test",
+        presets,
+        Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
+    ));
+    let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
+        .await
+        .unwrap();
+    let addr = listener.local_addr().unwrap();
+    let (tx, rx) = oneshot::channel::<()>();
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router)
+            .with_graceful_shutdown(async move {
+                let _ = rx.await;
+            })
+            .await;
+    });
+    Harness {
+        addr,
+        _shutdown: tx,
+    }
+}
+
+#[tokio::test]
+async fn post_resume_returns_the_revived_session() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "web-resumed").await;
+    let h = serve(manager, Vec::new()).await;
+
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(session.id)
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::OK);
+    let body: Session = resp.json().await.unwrap();
+    assert_eq!(body.id, session.id);
+    assert_eq!(body.status, SessionStatus::Running);
+}
+
+#[tokio::test]
+async fn post_resume_on_a_running_session_is_a_conflict() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    let h = serve(fx.manager.clone(), Vec::new()).await;
+
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(session.id)
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::CONFLICT);
+    let err: maestro_protocol::ApiError = resp.json().await.unwrap();
+    assert_eq!(err.error.code, "already_running");
+}
+
+#[tokio::test]
+async fn post_resume_on_an_unknown_session_is_404() {
+    let fx = DaemonFixture::new();
+    let h = serve(fx.manager.clone(), Vec::new()).await;
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(Uuid::new_v4())
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NOT_FOUND);
+}
+
+// ---------------------------------------------------------------------------
+// Races (#175)
+// ---------------------------------------------------------------------------
+
+/// Real tmux, with the *first* `new_session_piped` held inside the call until
+/// the test releases it. Later calls pass straight through, so a second resume
+/// racing the first never blocks on a gate the first one owns.
+///
+/// This is what makes the two races below deterministic rather than timing
+/// dependent: the resume under test is parked in exactly the window the bug
+/// lives in, and the racing operation runs to completion before it moves.
+#[derive(Debug)]
+struct GatedSpawn {
+    inner: maestro_daemon::tmux::Tmux,
+    entered: tokio::sync::mpsc::UnboundedSender<()>,
+    release: std::sync::Mutex<std::sync::mpsc::Receiver<()>>,
+    gated: std::sync::atomic::AtomicBool,
+}
+
+/// The test's end of a [`GatedSpawn`].
+struct Gate {
+    entered: tokio::sync::mpsc::UnboundedReceiver<()>,
+    release: std::sync::mpsc::SyncSender<()>,
+}
+
+impl Gate {
+    /// Wait until the gated spawn is parked mid-resume.
+    async fn wait_entered(&mut self) {
+        tokio::time::timeout(Duration::from_secs(10), self.entered.recv())
+            .await
+            .expect("resume reached the tmux spawn")
+            .expect("gate alive");
+    }
+
+    fn release(&self) {
+        self.release.send(()).expect("gate receiver alive");
+    }
+}
+
+fn gated_panes(inner: maestro_daemon::tmux::Tmux) -> (Arc<GatedSpawn>, Gate) {
+    let (entered_tx, entered_rx) = tokio::sync::mpsc::unbounded_channel();
+    let (release_tx, release_rx) = std::sync::mpsc::sync_channel(1);
+    (
+        Arc::new(GatedSpawn {
+            inner,
+            entered: entered_tx,
+            release: std::sync::Mutex::new(release_rx),
+            gated: std::sync::atomic::AtomicBool::new(true),
+        }),
+        Gate {
+            entered: entered_rx,
+            release: release_tx,
+        },
+    )
+}
+
+impl maestro_daemon::panes::Panes for GatedSpawn {
+    fn new_session_piped(
+        &self,
+        id: Uuid,
+        cwd: &std::path::Path,
+        command: &str,
+        session_env: &std::collections::BTreeMap<String, String>,
+        sink_command: &str,
+    ) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        if self.gated.swap(false, std::sync::atomic::Ordering::SeqCst) {
+            let _ = self.entered.send(());
+            let _ = self.release.lock().expect("gate mutex").recv();
+        }
+        self.inner
+            .new_session_piped(id, cwd, command, session_env, sink_command)
+    }
+
+    fn kill_session(&self, id: Uuid) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.kill_session(id)
+    }
+
+    fn list_sessions(&self) -> Result<Vec<Uuid>, maestro_daemon::tmux::TmuxError> {
+        self.inner.list_sessions()
+    }
+
+    fn pane_info(
+        &self,
+        id: Uuid,
+    ) -> Result<Option<maestro_daemon::tmux::PaneInfo>, maestro_daemon::tmux::TmuxError> {
+        self.inner.pane_info(id)
+    }
+
+    fn send_keys(&self, id: Uuid, bytes: &[u8]) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.send_keys(id, bytes)
+    }
+
+    fn pipe_pane(&self, id: Uuid, sink: &str) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.pipe_pane(id, sink)
+    }
+
+    fn resize_window(
+        &self,
+        id: Uuid,
+        cols: u16,
+        rows: u16,
+    ) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.resize_window(id, cols, rows)
+    }
+
+    fn capture_pane(&self, id: Uuid) -> Result<Option<Vec<u8>>, maestro_daemon::tmux::TmuxError> {
+        self.inner.capture_pane(id)
+    }
+}
+
+/// A dormant session whose manager's tmux spawn can be parked by the test.
+async fn dormant_gated(fx: &DaemonFixture, cwd: &TempDir) -> (SessionManager, Session, Gate) {
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let (panes, gate) = gated_panes(fx.tmux.tmux.clone());
+    let manager = SessionManager::new(
+        panes,
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    );
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+    (manager, session, gate)
+}
+
+/// A kill that lands while a resume is inside the tmux spawn must not leave
+/// the sidecar behind. The kill deletes it; the resume writes it back a moment
+/// later and then discovers its own record is gone. The sidecar it resurrected
+/// would otherwise make the next recovery register a ghost dormant session for
+/// a session that was killed.
+#[tokio::test]
+async fn a_kill_during_resume_leaves_no_sidecar_behind() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session, mut gate) = dormant_gated(&fx, &cwd).await;
+    let id = session.id;
+
+    let resuming = tokio::spawn({
+        let manager = manager.clone();
+        async move { manager.resume(id, &[]).await }
+    });
+    gate.wait_entered().await;
+
+    manager.kill(id, false).await.expect("kill mid-resume");
+    gate.release();
+
+    let err = resuming.await.unwrap().expect_err("record is gone");
+    assert!(matches!(err, SessionError::NotFound(got) if got == id));
+
+    assert!(
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+            .read(id)
+            .expect("read sidecar")
+            .is_none(),
+        "the killed session's sidecar must not be resurrected by the losing resume"
+    );
+
+    // And so the next recovery registers no ghost.
+    let after = revive(&fx);
+    after.recover().await.expect("recover");
+    assert!(
+        after.snapshot().await.is_empty(),
+        "a killed session must not come back dormant"
+    );
+}
+
+/// Two resumes of the same session must not both proceed. The second is
+/// refused on the state — `already_running` — not on its tmux spawn colliding
+/// with the first one's.
+#[tokio::test]
+async fn a_second_resume_is_refused_while_the_first_is_in_flight() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session, mut gate) = dormant_gated(&fx, &cwd).await;
+    let id = session.id;
+
+    let resuming = tokio::spawn({
+        let manager = manager.clone();
+        async move { manager.resume(id, &[]).await }
+    });
+    gate.wait_entered().await;
+
+    let err = manager
+        .resume(id, &[])
+        .await
+        .expect_err("a resume is already in flight");
+    assert!(matches!(err, SessionError::AlreadyRunning(got) if got == id));
+    assert_eq!(err.to_error_info().code, "already_running");
+
+    gate.release();
+    let first = resuming.await.unwrap().expect("the first resume wins");
+    assert_eq!(first.status, SessionStatus::Running);
+    assert_eq!(
+        fx.tmux.tmux.list_sessions().expect("list"),
+        vec![id],
+        "exactly one pane for the session"
+    );
+}
+
+/// A refused resume must not leave the session marked in-flight: once the
+/// reason for the refusal is gone, resuming works.
+#[tokio::test]
+async fn a_refused_resume_can_be_retried() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "retried").await;
+
+    std::fs::remove_dir_all(cwd.path()).unwrap();
+    let err = manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("cwd is gone");
+    assert_eq!(err.to_error_info().code, "cwd_missing");
+
+    std::fs::create_dir_all(cwd.path()).unwrap();
+    let resumed = manager.resume(session.id, &[]).await.expect("resume");
+    assert_eq!(resumed.status, SessionStatus::Running);
+}

crates/maestro-daemon/tests/resume_policy.rs

@@ -0,0 +1,161 @@
+//! `[daemon].resume_on_boot` (#167): what recovery does with sessions whose
+//! tmux pane is gone but whose sidecar survived, against real tmux.
+//!
+//! The default is deliberately the timid one. Resuming agents unattended
+//! seconds after a reboot is a foot-gun, so `auto` is opted into per host and
+//! `never` throws the sidecars away instead.
+
+mod common;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_config::ResumeOnBoot;
+use maestro_daemon::SessionManager;
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus, SpawnPreset};
+use tempfile::TempDir;
+
+/// A fresh manager over the same tmux server, sidecars and fifos — what the
+/// daemon builds after a restart — carrying `policy`.
+fn revive(fx: &DaemonFixture, policy: ResumeOnBoot, presets: Vec<SpawnPreset>) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_resume_policy(policy, presets)
+}
+
+/// A preset whose `resume_command` touches a marker file, so a test can see
+/// that the resumed session ran the resume command rather than the original.
+fn marker_preset(command: &str, marker_dir: &TempDir) -> Vec<SpawnPreset> {
+    vec![SpawnPreset {
+        id: "agent".into(),
+        label: "Agent".into(),
+        command: command.into(),
+        resume_command: Some(format!(
+            "sh -c 'touch {}/resumed; sleep 30'",
+            marker_dir.path().display()
+        )),
+    }]
+}
+
+async fn create(fx: &DaemonFixture, cwd: &TempDir, command: &str) -> Session {
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create")
+}
+
+/// The default: a reboot leaves the session listed but not running, waiting
+/// for the operator.
+#[tokio::test]
+async fn dormant_is_the_default_and_leaves_the_session_waiting() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Dormant, Vec::new());
+    revived.recover().await.expect("recover");
+
+    assert_eq!(
+        revived.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+    assert!(fx
+        .sidecar_dir()
+        .join(format!("{}.json", session.id))
+        .exists());
+    assert!(
+        fx.tmux.tmux.list_sessions().expect("list").is_empty(),
+        "nothing was respawned"
+    );
+}
+
+/// `auto` brings each one back itself, down the same path a client's resume
+/// takes: same uuid, same sidecar, the preset's `resume_command`.
+#[tokio::test]
+async fn auto_resumes_every_dormant_session_during_recovery() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let markers = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Auto, marker_preset("sleep 30", &markers));
+    revived.recover().await.expect("recover");
+
+    assert_eq!(
+        revived.status(session.id).await,
+        Some(SessionStatus::Running),
+        "auto resumed it"
+    );
+    assert_eq!(
+        fx.tmux.tmux.list_sessions().expect("list"),
+        vec![session.id],
+        "back under the same uuid"
+    );
+    let stored = maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+        .read(session.id)
+        .expect("read sidecar")
+        .expect("same sidecar");
+    assert_eq!(stored.created_at, session.created_at);
+    assert_eq!(stored.command, "sleep 30", "the original command is kept");
+
+    // It really ran the preset's resume command, not the spawn command.
+    let marker = markers.path().join("resumed");
+    wait_for_async(Duration::from_secs(5), || {
+        let marker = marker.clone();
+        async move { marker.exists() }
+    })
+    .await;
+    assert!(marker.exists(), "resume_command ran");
+}
+
+/// `never` makes a reboot a clean slate: the sidecars go, and the session is
+/// not listed at all.
+#[tokio::test]
+async fn never_prunes_the_sidecars_instead() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Never, Vec::new());
+    revived.recover().await.expect("recover");
+
+    assert!(!revived.has(session.id).await, "not listed");
+    assert!(
+        !fx.sidecar_dir()
+            .join(format!("{}.json", session.id))
+            .exists(),
+        "sidecar pruned"
+    );
+    assert!(fx.tmux.tmux.list_sessions().expect("list").is_empty());
+}
+
+/// The policy only decides what happens to sessions that lost their pane. A
+/// session tmux still holds is adopted running by the first pass under every
+/// policy — including `never`, which must not delete a live session's sidecar.
+#[tokio::test]
+async fn the_policy_leaves_sessions_tmux_still_holds_alone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let live = create(&fx, &cwd, "sleep 30").await;
+
+    let revived = revive(&fx, ResumeOnBoot::Never, Vec::new());
+    assert_eq!(revived.recover().await.expect("recover"), 1);
+
+    assert_eq!(revived.status(live.id).await, Some(SessionStatus::Running));
+    assert!(fx.sidecar_dir().join(format!("{}.json", live.id)).exists());
+}

crates/maestro-daemon/tests/scrollback.rs

@@ -0,0 +1,219 @@
+//! Persisted PTY scrollback across a reboot (#171), against real tmux.
+//!
+//! Everything else in the reboot milestone restores what a session *is*; this
+//! restores what it *looked like*. The cases that matter are the ones a clean
+//! shutdown never gets to run: the host went down, and the only scrollback
+//! that exists is whatever the last periodic flush wrote.
+
+mod common;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_daemon::scrollback::ScrollbackStore;
+use maestro_daemon::SessionManager;
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus};
+use tempfile::TempDir;
+use uuid::Uuid;
+
+/// A fresh manager over the same tmux server, sidecars, fifos and scrollback —
+/// what the daemon builds after a restart.
+fn revive(fx: &DaemonFixture) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_scrollback(fx.scrollback_dir())
+}
+
+async fn spawn(fx: &DaemonFixture, cwd: &TempDir, command: &str) -> Session {
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create")
+}
+
+/// Wait until the session has printed `needle`, flushing as we go — the same
+/// thing the liveness watcher's flush pass does on its timer.
+async fn wait_for_flushed(
+    manager: &SessionManager,
+    store: &ScrollbackStore,
+    id: Uuid,
+    needle: &str,
+) {
+    wait_for_async(Duration::from_secs(10), || async {
+        manager.flush_scrollback().await;
+        String::from_utf8_lossy(&store.read(id, 64 * 1024)).contains(needle)
+    })
+    .await;
+}
+
+fn replay_text(replay: &[u8]) -> String {
+    String::from_utf8_lossy(replay).to_string()
+}
+
+/// The keystone: the host reboots with no exit path run at all, and the
+/// resumed session opens showing what it printed before.
+#[tokio::test]
+async fn a_resumed_session_replays_the_scrollback_from_before_the_reboot() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo before-the-reboot; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "before-the-reboot").await;
+
+    // The reboot: tmux dies where it stands. No kill, no seal, no shutdown
+    // hook — only whatever the periodic flush had already written.
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+
+    manager.resume(session.id, &[]).await.expect("resume");
+    let (replay, _rx) = manager
+        .subscribe_pty_with_replay(session.id)
+        .await
+        .expect("attachable again");
+    assert!(
+        replay_text(&replay).contains("before-the-reboot"),
+        "resumed pane should open on the old scrollback, got {:?}",
+        replay_text(&replay)
+    );
+}
+
+/// A daemon restart leaves tmux alone, so the session is adopted rather than
+/// resumed — and it too lost its in-memory ring with the old process.
+#[tokio::test]
+async fn an_adopted_session_replays_the_scrollback_of_the_previous_daemon() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo printed-earlier; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "printed-earlier").await;
+
+    // Daemon restart: the manager goes, tmux stays.
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Running)
+    );
+
+    let (replay, _rx) = manager
+        .subscribe_pty_with_replay(session.id)
+        .await
+        .expect("attachable");
+    assert!(
+        replay_text(&replay).contains("printed-earlier"),
+        "adopted pane should carry the old scrollback ahead of tmux's screen, got {:?}",
+        replay_text(&replay)
+    );
+}
+
+/// Killing a session takes its scrollback with it: nothing will ever read the
+/// file again, and the operator's output should not linger on disk.
+#[tokio::test]
+async fn killing_a_session_deletes_its_scrollback() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo doomed; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "doomed").await;
+    assert!(store.path_for(session.id).exists());
+
+    fx.manager.kill(session.id, false).await.expect("kill");
+    assert!(
+        !store.path_for(session.id).exists(),
+        "scrollback should not outlive the session"
+    );
+}
+
+/// A session that exits on its own does get an exit path, and takes it: the
+/// last thing it printed is flushed when the bridge is sealed, with no wait
+/// for the next tick.
+#[tokio::test]
+async fn a_session_that_exits_flushes_its_last_output() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo last-words'").await;
+    fx.manager
+        .start_liveness_watcher(Duration::from_millis(100));
+    wait_for_async(Duration::from_secs(10), || async {
+        fx.manager.status(session.id).await == Some(SessionStatus::Dead)
+    })
+    .await;
+
+    assert!(
+        String::from_utf8_lossy(&store.read(session.id, 64 * 1024)).contains("last-words"),
+        "a sealed bridge should have flushed what it printed"
+    );
+}
+
+/// Nothing here may fail a resume. A scrollback file that is gone, or one full
+/// of bytes no terminal would emit, degrades to a pane with no history — not
+/// to an error.
+#[tokio::test]
+async fn a_missing_or_corrupt_scrollback_still_resumes() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let gone = spawn(&fx, &cwd, "sleep 30").await;
+    let garbled = spawn(&fx, &cwd, "sleep 30").await;
+    fx.manager.flush_scrollback().await;
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    std::fs::create_dir_all(store.dir()).expect("scrollback dir");
+    std::fs::remove_file(store.path_for(gone.id)).ok();
+    std::fs::write(store.path_for(garbled.id), [0xff, 0xfe, 0x00, 0x80]).expect("write garbage");
+
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    for id in [gone.id, garbled.id] {
+        manager.resume(id, &[]).await.expect("resume");
+        assert_eq!(manager.status(id).await, Some(SessionStatus::Running));
+        assert!(manager.subscribe_pty_with_replay(id).await.is_some());
+    }
+}
+
+/// The disk cost is the replay budget, not a second one of its own.
+#[tokio::test]
+async fn the_flushed_file_stays_inside_the_replay_budget() {
+    let fx = DaemonFixture::new_with_replay(256);
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(
+        &fx,
+        &cwd,
+        "sh -c 'for i in $(seq 1 400); do echo line-$i; done; sleep 30'",
+    )
+    .await;
+    wait_for_flushed(&fx.manager, &store, session.id, "line-400").await;
+
+    let size = std::fs::metadata(store.path_for(session.id))
+        .expect("stat scrollback")
+        .len();
+    assert!(
+        size <= 256,
+        "scrollback file was {size} bytes, budget is 256"
+    );
+}

crates/maestro-daemon/tests/session_decisions.rs

@@ -555,3 +555,63 @@ async fn spawn_overrides_client_supplied_maestro_variables() {
         Some(&"http://127.0.0.1:7070".to_string())
     );
 }
+
+/// Two clients attached to one session used to resize the shared window past
+/// each other on every report they made. Every flip repaints a full-screen
+/// agent at a new height and orphans the rows it drew at the old one, which
+/// reads to the operator as a pane that has stopped taking input.
+#[tokio::test]
+async fn clients_of_different_sizes_do_not_resize_the_window_past_each_other() {
+    let fx = Fx::new();
+    let s = fx.manager.create(fx.request("bash")).await.expect("create");
+    let web = fx.manager.attach_viewport();
+    let tui = fx.manager.attach_viewport();
+
+    fx.manager.set_viewport(s.id, web, 53, 46).await.unwrap();
+    fx.manager.set_viewport(s.id, tui, 53, 20).await.unwrap();
+    // Both keep reporting, as a browser's ResizeObserver and the TUI's own
+    // redraw loop do. Neither report changes the arbitrated size.
+    for _ in 0..5 {
+        fx.manager.set_viewport(s.id, web, 53, 46).await.unwrap();
+        fx.manager.set_viewport(s.id, tui, 53, 20).await.unwrap();
+    }
+
+    let resizes: Vec<_> = fx
+        .fake
+        .calls()
+        .into_iter()
+        .filter_map(|c| match c {
+            Call::ResizeWindow { cols, rows, .. } => Some((cols, rows)),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(
+        resizes,
+        vec![(53, 46), (53, 20)],
+        "the window was resized more than the arbitrated size actually changed"
+    );
+}
+
+/// The smaller client leaving hands the window back to the one still attached.
+#[tokio::test]
+async fn releasing_a_client_resizes_to_what_is_left() {
+    let fx = Fx::new();
+    let s = fx.manager.create(fx.request("bash")).await.expect("create");
+    let web = fx.manager.attach_viewport();
+    let tui = fx.manager.attach_viewport();
+    fx.manager.set_viewport(s.id, web, 80, 46).await.unwrap();
+    fx.manager.set_viewport(s.id, tui, 80, 20).await.unwrap();
+
+    fx.manager.release_viewport(s.id, tui).await;
+
+    let resizes: Vec<_> = fx
+        .fake
+        .calls()
+        .into_iter()
+        .filter_map(|c| match c {
+            Call::ResizeWindow { cols, rows, .. } => Some((cols, rows)),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(resizes, vec![(80, 46), (80, 20), (80, 46)]);
+}

crates/maestro-daemon/tests/session_manager.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
+use maestro_daemon::sidecar::SidecarStore;
 use maestro_daemon::SessionError;
 use maestro_protocol::CreateSessionRequest;
 use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
@@ -140,6 +141,390 @@ async fn recover_adopts_existing_tmux_sessions() {
     assert_eq!(snap[0].command, "sleep 30");
 }
 
+/// #162: a host reboot kills the tmux server, so recovery finds nothing to
+/// adopt while every sidecar is still on disk. Those sessions come back as
+/// `Dormant` — a record of what was running — rather than vanishing from the
+/// API and leaving the operator with nothing.
+#[tokio::test]
+async fn recover_registers_orphaned_sidecars_as_dormant() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let mut metadata = HashMap::new();
+    metadata.insert(
+        maestro_protocol::NAME_KEY.to_string(),
+        serde_json::Value::String("after-reboot".into()),
+    );
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata,
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    // The reboot: the tmux server is gone, the sidecar is untouched.
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0, "no live tmux session left to adopt");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1, "the sidecar's session is still listed");
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+    assert_eq!(snap[0].command, "sleep 30");
+    assert_eq!(snap[0].cwd, s.cwd);
+    assert_eq!(snap[0].created_at, s.created_at);
+    assert_eq!(
+        snap[0]
+            .metadata
+            .get(maestro_protocol::NAME_KEY)
+            .and_then(|v| v.as_str()),
+        Some("after-reboot"),
+    );
+}
+
+/// #162: a session tmux still holds is adopted `Running` by the first pass and
+/// must not be re-registered as dormant by the second — the sidecar is on disk
+/// for both.
+#[tokio::test]
+async fn recover_does_not_mark_adopted_sessions_dormant() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let live = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create live");
+    let orphan = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 31".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create orphan");
+    // Only the second session loses its pane.
+    fx.tmux.tmux.kill_session(orphan.id).expect("kill session");
+
+    let revived = revive(&fx);
+    assert_eq!(revived.recover().await.expect("recover"), 1);
+
+    let mut snap = revived.snapshot().await;
+    snap.sort_by_key(|s| s.command.clone());
+    assert_eq!(snap.len(), 2);
+    assert_eq!(snap[0].id, live.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+    assert_eq!(snap[1].id, orphan.id);
+    assert_eq!(snap[1].status, SessionStatus::Dormant);
+}
+
+/// #163: a sidecar whose `cwd` no longer exists is pruned instead of
+/// registered dormant — the worktree it pointed at is gone, so there is
+/// nothing left to resume.
+#[tokio::test]
+async fn recover_deletes_sidecar_when_cwd_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let cwd_path = cwd.path().to_path_buf();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd_path.clone(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    drop(cwd);
+    std::fs::remove_dir_all(&cwd_path).ok();
+    assert!(!cwd_path.exists());
+
+    let revived = revive(&fx);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0);
+
+    assert!(!revived.has(s.id).await);
+    assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+}
+
+/// #163: a sidecar whose `cwd` still exists is left alone regardless of age
+/// — it is registered dormant like any other orphan.
+#[tokio::test]
+async fn recover_keeps_dormant_sidecar_when_cwd_exists() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    revived.recover().await.expect("recover");
+
+    assert!(revived.has(s.id).await);
+    assert!(fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+    let snap = revived.snapshot().await;
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+}
+
+/// #164: a fake [`maestro_daemon::boot_id::BootIdSource`] lets tests simulate
+/// a changed (or unreadable) boot id without rebooting the machine.
+#[derive(Debug)]
+struct FakeBootId(Option<String>);
+
+impl maestro_daemon::boot_id::BootIdSource for FakeBootId {
+    fn current(&self) -> Option<String> {
+        self.0.clone()
+    }
+}
+
+fn revive_with_boot_id(
+    fx: &DaemonFixture,
+    boot_id_path: PathBuf,
+    current: Option<&str>,
+) -> maestro_daemon::SessionManager {
+    maestro_daemon::SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_boot_id(
+        boot_id_path,
+        Arc::new(FakeBootId(current.map(String::from))),
+    )
+}
+
+/// #174: a boot id can change without the tmux server dying — a restored
+/// state directory, a VM or container snapshot restore, a truncated
+/// `boot_id` file. `tmux list-sessions` stays the single source of truth for
+/// liveness, so a session tmux still holds is adopted `Running` no matter
+/// what the boot id says. Registering it dormant instead stranded it: resume
+/// would collide with the tmux name still in use and fail forever.
+#[tokio::test]
+async fn recover_adopts_live_session_when_boot_id_changed() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "previous-boot").unwrap();
+
+    // tmux session is still alive: the probe runs and finds it.
+    let revived = revive_with_boot_id(&fx, boot_id_path.clone(), Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "tmux still holds the session; adopt it");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1);
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+
+    // The current boot id is now the stored one, for the next comparison.
+    assert_eq!(
+        std::fs::read_to_string(&boot_id_path).unwrap().trim(),
+        "current-boot"
+    );
+}
+
+/// #164, still true after #174: a real reboot takes the tmux server with it,
+/// so the probe comes back empty and every sidecar is registered dormant.
+#[tokio::test]
+async fn recover_registers_dormant_when_boot_id_changed_and_tmux_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "previous-boot").unwrap();
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0, "no tmux server survived the reboot");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1);
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+}
+
+/// #164: an unchanged boot id is a plain restart — recovery probes tmux as
+/// before and adopts the still-live session `Running`.
+#[tokio::test]
+async fn recover_probes_tmux_when_boot_id_unchanged() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "same-boot").unwrap();
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, Some("same-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1);
+    let snap = revived.snapshot().await;
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+}
+
+/// #164: no stored boot id (first run ever, or an older build that never
+/// wrote one) means there is nothing to compare against — falls back to
+/// today's probe-based recovery rather than assuming a reboot.
+#[tokio::test]
+async fn recover_falls_back_to_probe_when_no_stored_boot_id() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    assert!(!boot_id_path.exists());
+
+    let revived = revive_with_boot_id(&fx, boot_id_path.clone(), Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "no stored boot id; falls back to probing tmux");
+    assert_eq!(
+        std::fs::read_to_string(&boot_id_path).unwrap().trim(),
+        "current-boot"
+    );
+}
+
+/// #164: an unreadable current boot id (non-Linux, restricted `/proc`) falls
+/// back to today's behaviour rather than failing startup or assuming a
+/// reboot.
+#[tokio::test]
+async fn recover_falls_back_to_probe_when_boot_id_unreadable() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "stored-boot").unwrap();
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, None);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "boot id unreadable; falls back to probing tmux");
+}
+
+/// #162: dismissing a dormant session is the one thing that can be done to it
+/// — no tmux call to fail, and the sidecar goes with it so the next recovery
+/// does not resurrect it.
+#[tokio::test]
+async fn dormant_session_can_be_dismissed() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    revived.recover().await.expect("recover");
+    revived.kill(s.id, false).await.expect("dismiss");
+
+    assert!(!revived.has(s.id).await);
+    assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+}
+
+/// A second `SessionManager` over the same dirs and the same tmux server —
+/// what a daemon restart looks like from inside a test.
+fn revive(fx: &DaemonFixture) -> maestro_daemon::SessionManager {
+    maestro_daemon::SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+}
+
 /// Regression for NAP-253: the very first bytes a freshly-spawned command
 /// writes must reach the replay buffer. Before the fix, `pipe-pane` was a
 /// separate tmux invocation that ran after `new-session` + an async FIFO
@@ -954,6 +1339,65 @@ async fn natural_exit_of_a_pristine_worktree_removes_it() {
     );
 }
 
+/// #172: `mark_session_dead` clears the worktree off the in-memory record
+/// when a pristine tree settles, but the local `session` clone it writes to
+/// the sidecar and broadcasts must be cleared the same way — otherwise the
+/// sidecar keeps naming a tree the daemon just removed, and a recovery from
+/// that sidecar advertises a branch and path that no longer exist.
+#[tokio::test]
+async fn natural_exit_of_a_pristine_worktree_clears_it_from_the_sidecar() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    init_repo(repo.path());
+    let wt_path = repo.path().join("worktrees").join("feat").join("sidecar");
+
+    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/sidecar".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+
+    // Push everything so the branch has no unpushed commits: fully pristine.
+    let origin = TempDir::new().unwrap();
+    init_bare_repo(origin.path());
+    push_all_to_origin(repo.path(), origin.path());
+
+    fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
+    fx.manager.start_liveness_watcher(Duration::from_millis(50));
+    wait_for_async(Duration::from_secs(3), || async {
+        fx.manager.status(s.id).await == Some(SessionStatus::Dead)
+    })
+    .await;
+    wait_for_async(Duration::from_secs(3), || async {
+        fx.manager.is_settled(s.id).await == Some(true)
+    })
+    .await;
+
+    assert!(
+        !wt_path.exists(),
+        "a pristine worktree leaves nothing behind"
+    );
+
+    let sidecar = SidecarStore::new(fx.sidecar_dir())
+        .read(s.id)
+        .expect("sidecar read")
+        .expect("sidecar exists");
+    assert!(
+        sidecar.worktree.is_none(),
+        "the sidecar must not keep naming a worktree the daemon already removed"
+    );
+}
+
 fn run_git_in(dir: &std::path::Path, args: &[&str]) {
     let out = Command::new("git")
         .arg("-C")

crates/maestro-daemon/tests/sidecar.rs

@@ -32,6 +32,7 @@ fn sample(id: Uuid) -> Session {
         current_cwd: Some(PathBuf::from("/tmp/work/crates")),
         blocked_work: None,
         last_focused_at: None,
+        agent_session_id: Some("conv-abc123".into()),
     }
 }
 

crates/maestro-daemon/tests/web_ui.rs

@@ -26,6 +26,7 @@ async fn spawn() -> Harness {
         "/home/test",
         maestro_config::SpawnSection::default().resolve().unwrap(),
         std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
     ));
     let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
         .await

crates/maestro-hooks/src/lib.rs

@@ -84,15 +84,23 @@ if [ "$state" = "Prompt" ]; then
         >/dev/null 2>&1 || true
     exit 0
 fi
-body="{\"state\":\"$state\"}"
+fields="\"state\":\"$state\""
 # StopFailure payloads carry the outcome in "error". Only a plain enum
 # spelling is reported as the detail — anything else (quotes, backslashes,
 # prose) would risk breaking the JSON body, and the spelling already names
 # the failure.
 detail=$(printf '%s' "$payload" | sed -n 's/.*"error"[[:space:]]*:[[:space:]]*"\([a-z_]*\)".*/\1/p')
 if [ -n "$detail" ]; then
-    body="{\"state\":\"$state\",\"detail\":\"$detail\"}"
+    fields="$fields,\"detail\":\"$detail\""
 fi
+# Every Claude Code hook payload carries its own conversation id (#161).
+# Constrained to a safe charset for the same reason as "detail" above: it is
+# spliced into the JSON body unescaped.
+session_id=$(printf '%s' "$payload" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([A-Za-z0-9_-]*\)".*/\1/p')
+if [ -n "$session_id" ]; then
+    fields="$fields,\"session_id\":\"$session_id\""
+fi
+body="{$fields}"
 curl -fsS --connect-timeout 1 --max-time 2 \
     -H 'Content-Type: application/json' \
     -d "$body" \

crates/maestro-hooks/src/tests.rs

@@ -128,6 +128,41 @@ fn script_reports_the_error_spelling_as_detail() {
     assert!(request.contains(r#""detail":"rate_limit""#), "{request}");
 }
 
+/// #161: the payload's own `session_id` — the agent's conversation id — is
+/// parsed out and forwarded in the activity body, so the daemon can persist
+/// it on the session.
+#[test]
+fn script_forwards_the_payloads_session_id_in_the_activity_body() {
+    let request = capture_request(|url| {
+        sh(
+            HOOK_SCRIPT,
+            &["Active"],
+            &owned_envs(&session_envs(&url)),
+            br#"{"session_id":"conv-abc123","hook_event_name":"PreToolUse"}"#,
+        )
+    });
+    assert!(request.contains(r#""state":"Active""#), "{request}");
+    assert!(
+        request.contains(r#""session_id":"conv-abc123""#),
+        "{request}"
+    );
+}
+
+/// A payload without a `session_id` (or one with an unexpected shape) must
+/// never produce a broken body — no `session_id` field is posted.
+#[test]
+fn script_posts_no_session_id_when_the_payload_has_none() {
+    let request = capture_request(|url| {
+        sh(
+            HOOK_SCRIPT,
+            &["AwaitingInput"],
+            &owned_envs(&session_envs(&url)),
+            br#"{"hook_event_name":"Stop","stop_hook_active":false}"#,
+        )
+    });
+    assert!(!request.contains("session_id"), "{request}");
+}
+
 /// An `error` value that is not a plain enum spelling (or a payload without
 /// one at all) must never produce a broken body — no detail is posted.
 #[test]

crates/maestro-protocol/src/display.rs

@@ -284,6 +284,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 

crates/maestro-protocol/src/lib.rs

@@ -116,6 +116,13 @@ pub struct Session {
     /// sorts a never-focused session after every session that has one.
     #[serde(default)]
     pub last_focused_at: Option<DateTime<Utc>>,
+    /// The conversation id the agent running in this session reported for
+    /// itself (#161), parsed from a hook's `session_id` field. Written once,
+    /// from the first activity report that carries one, and left alone after
+    /// — an agent's own session id does not change mid-session. `None` for
+    /// sessions that never run an agent (plain shells) or predate the field.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub agent_session_id: Option<String>,
 }
 
 /// Default for [`Session::last_activity_at`] when an older payload omits it.
@@ -123,10 +130,38 @@ fn epoch() -> DateTime<Utc> {
     DateTime::from_timestamp(0, 0).expect("unix epoch is a valid timestamp")
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+/// Lifecycle of a session as the daemon knows it.
+///
+/// Deserializes leniently, like [`ActivityState`] (#162): an unknown spelling
+/// from a newer daemon reads as [`SessionStatus::Dead`] instead of failing the
+/// whole `Session`. `Dead` is the safe degrade — an unrecognised session is
+/// one this client must not treat as having a live pane to type into.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 pub enum SessionStatus {
     Running,
     Dead,
+    /// Known from its sidecar, with no tmux session behind it (#162). The
+    /// daemon registers these at recovery time for every sidecar tmux had
+    /// nothing to adopt — after a host reboot, that is every session there
+    /// was. There is no pane and no PTY bridge: a dormant session is a record
+    /// of what was running, listed so the operator still has it, and the only
+    /// thing that can be done to it is dismissing it.
+    Dormant,
+}
+
+impl<'de> Deserialize<'de> for SessionStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "Running" => Self::Running,
+            "Dormant" => Self::Dormant,
+            // Known or not, any other spelling degrades to the inert variant.
+            _ => Self::Dead,
+        })
+    }
 }
 
 /// Inferred session activity, orthogonal to [`SessionStatus`] (NAP-340). The
@@ -184,6 +219,11 @@ pub struct ReportActivityRequest {
     /// The daemon caps its length server-side.
     #[serde(default)]
     pub detail: Option<String>,
+    /// The agent's own conversation id (#161), forwarded from the hook
+    /// payload's `session_id` field. `None` for hook events that don't carry
+    /// one, or hooks predating this field.
+    #[serde(default)]
+    pub session_id: Option<String>,
 }
 
 /// Reject an unknown [`ActivityState`] spelling instead of degrading it to
@@ -489,8 +529,34 @@ impl ApiError {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct SpawnPreset {
     pub id: String,
+    #[serde(default)]
     pub label: String,
     pub command: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resume_command: Option<String>,
+}
+
+/// Placeholder a preset's `resume_command` may carry for the agent's own
+/// conversation id (#165), substituted from [`Session::agent_session_id`].
+pub const AGENT_SESSION_PLACEHOLDER: &str = "{agent_session}";
+
+impl SpawnPreset {
+    /// The command that resumes a session spawned from this preset, with
+    /// [`AGENT_SESSION_PLACEHOLDER`] filled in from `agent_session`.
+    ///
+    /// `None` when the preset has no `resume_command` — a plain shell has
+    /// nothing to resume — and also when the template asks for an agent
+    /// session id the session never reported: `claude --resume` with an empty
+    /// id resumes nothing, so the caller is better off respawning the original
+    /// command than running a broken one.
+    pub fn resume_command_for(&self, agent_session: Option<&str>) -> Option<String> {
+        let template = self.resume_command.as_deref()?;
+        if !template.contains(AGENT_SESSION_PLACEHOLDER) {
+            return Some(template.to_string());
+        }
+        let id = agent_session.filter(|s| !s.is_empty())?;
+        Some(template.replace(AGENT_SESSION_PLACEHOLDER, id))
+    }
 }
 
 /// Build provenance of the running daemon: the commit it was compiled
@@ -554,6 +620,12 @@ pub struct DaemonInfo {
     /// network blip, even when the build did not change.
     #[serde(default)]
     pub instance: String,
+    /// Canonical leader key the operator configured (`[tui].leader`, default
+    /// `ctrl-a`), served so the web client binds the same chord the TUI does
+    /// instead of its own hardcoded constant (#159). Empty from a daemon too
+    /// old to serve it, which clients read as "use your default".
+    #[serde(default)]
+    pub leader: String,
 }
 
 /// Payload of `GET /api/names?count=N` (#53) — a batch of fresh
@@ -736,6 +808,47 @@ pub enum ClientControl {
 mod tests {
     use super::*;
 
+    fn preset(resume: Option<&str>) -> SpawnPreset {
+        SpawnPreset {
+            id: "claude".into(),
+            label: "Claude".into(),
+            command: "claude".into(),
+            resume_command: resume.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn resume_command_substitutes_the_agent_session() {
+        let p = preset(Some("claude --resume {agent_session}"));
+        assert_eq!(
+            p.resume_command_for(Some("abc-123")).as_deref(),
+            Some("claude --resume abc-123")
+        );
+    }
+
+    #[test]
+    fn resume_command_without_a_placeholder_ignores_the_agent_session() {
+        let p = preset(Some("opencode --continue"));
+        assert_eq!(
+            p.resume_command_for(None).as_deref(),
+            Some("opencode --continue")
+        );
+    }
+
+    /// A template that wants an id the session never reported would run
+    /// `claude --resume` against nothing; the caller respawns instead.
+    #[test]
+    fn resume_command_is_none_without_the_id_it_asks_for() {
+        let p = preset(Some("claude --resume {agent_session}"));
+        assert!(p.resume_command_for(None).is_none());
+        assert!(p.resume_command_for(Some("")).is_none());
+    }
+
+    #[test]
+    fn a_preset_without_a_resume_command_has_none() {
+        assert!(preset(None).resume_command_for(Some("abc")).is_none());
+    }
+
     #[test]
     fn version_compatibility_is_major_only() {
         assert!(is_compatible(PROTOCOL_VERSION));
@@ -856,6 +969,7 @@ mod tests {
             current_cwd: Some(PathBuf::from("/home/naps62/projects/maestro/crates")),
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -1025,6 +1139,7 @@ mod tests {
         let full = ReportActivityRequest {
             state: ActivityState::AwaitingInput,
             detail: Some("waiting on permission".into()),
+            session_id: Some("conv-abc123".into()),
         };
         assert_eq!(full, round_trip(&full));
 
@@ -1053,6 +1168,33 @@ mod tests {
             serde_json::to_value(SessionStatus::Dead).unwrap(),
             serde_json::json!("Dead")
         );
+        assert_eq!(
+            serde_json::to_value(SessionStatus::Dormant).unwrap(),
+            serde_json::json!("Dormant")
+        );
+    }
+
+    // #162: a session with no tmux behind it still rides the wire whole.
+    #[test]
+    fn dormant_session_round_trips() {
+        let mut s = sample_session();
+        s.status = SessionStatus::Dormant;
+        assert_eq!(s, round_trip(&s));
+    }
+
+    // #162: a `SessionStatus` this client does not know must degrade to the
+    // inert variant, not fail the whole `Session` the way a derived
+    // `Deserialize` would.
+    #[test]
+    fn unknown_session_status_degrades_to_dead() {
+        assert_eq!(
+            serde_json::from_value::<SessionStatus>(serde_json::json!("Hibernating")).unwrap(),
+            SessionStatus::Dead
+        );
+        let mut value = serde_json::to_value(sample_session()).unwrap();
+        value["status"] = serde_json::json!("Hibernating");
+        let s: Session = serde_json::from_value(value).expect("session survives unknown status");
+        assert_eq!(s.status, SessionStatus::Dead);
     }
 
     #[test]

crates/maestro-protocol/src/routes.rs

@@ -66,6 +66,12 @@ pub fn session_focus(id: Uuid) -> String {
     format!("{SESSIONS}/{id}/focus")
 }
 
+/// `POST /api/sessions/:id/resume` (#166): respawn a dormant session under its
+/// own id, keeping its sidecar, name, worktree and `created_at`.
+pub fn session_resume(id: Uuid) -> String {
+    format!("{SESSIONS}/{id}/resume")
+}
+
 /// `WS /api/attach/:id` — raw PTY bytes.
 pub fn attach(id: Uuid) -> String {
     format!("{API_PREFIX}/attach/{id}")
@@ -79,6 +85,7 @@ pub mod patterns {
     pub const SESSION_INPUT: &str = "/api/sessions/:id/input";
     pub const SESSION_PROMPT: &str = "/api/sessions/:id/prompt";
     pub const SESSION_FOCUS: &str = "/api/sessions/:id/focus";
+    pub const SESSION_RESUME: &str = "/api/sessions/:id/resume";
     pub const ATTACH: &str = "/api/attach/:id";
 }
 
@@ -202,6 +209,10 @@ mod tests {
             session_focus(id()),
             "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/focus"
         );
+        assert_eq!(
+            session_resume(id()),
+            "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/resume"
+        );
         assert_eq!(
             attach(id()),
             "/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
@@ -236,6 +247,10 @@ mod tests {
             patterns::SESSION_FOCUS.trim_end_matches(":id/focus"),
             session(id()).trim_end_matches(&id().to_string())
         );
+        assert_eq!(
+            patterns::SESSION_RESUME.trim_end_matches(":id/resume"),
+            session(id()).trim_end_matches(&id().to_string())
+        );
         assert_eq!(
             patterns::ATTACH.trim_end_matches(":id"),
             attach(id()).trim_end_matches(&id().to_string())

crates/maestro-testing/src/lib.rs

@@ -47,6 +47,7 @@ pub fn session(id: Uuid, cwd: &str, command: &str) -> Session {
         current_cwd: None,
         blocked_work: None,
         last_focused_at: None,
+        agent_session_id: None,
     }
 }
 

crates/maestro-tui/src/action.rs

@@ -56,6 +56,14 @@ pub enum Action {
     /// Open the `ctrl-k` command bar (`docs/COMMAND-BAR.md`) — a query line
     /// over the sessions, ranked by the shared matcher.
     OpenCommandBar,
+    /// Escape hatch (#156): leader then `ctrl-k` sends the literal `0x0B`
+    /// byte to the focused pane instead of opening the command bar, giving
+    /// readline's kill-to-end-of-line back.
+    SendLiteralCtrlK,
+    /// Escape hatch (#158): the leader pressed twice sends one literal
+    /// leader byte to the focused pane and drops the pending chord, the way
+    /// tmux resolves a doubled prefix key.
+    SendLiteralLeader,
     ToggleSidebar,
     ShowHelp,
     Quit,
@@ -98,6 +106,8 @@ impl Action {
             Action::KillHighlighted => "Kill selected session".into(),
             Action::RenameHighlighted => "Rename selected session".into(),
             Action::OpenCommandBar => "Go to a session".into(),
+            Action::SendLiteralCtrlK => "Send literal Ctrl-K to session".into(),
+            Action::SendLiteralLeader => "Send literal leader key to session".into(),
             Action::ToggleSidebar => "Show or hide sidebar".into(),
             Action::ShowHelp => "Show help".into(),
             Action::Quit => "Quit Maestro".into(),
@@ -125,6 +135,8 @@ impl Action {
             "KillHighlighted" => return Ok(Action::KillHighlighted),
             "RenameHighlighted" => return Ok(Action::RenameHighlighted),
             "OpenCommandBar" => return Ok(Action::OpenCommandBar),
+            "SendLiteralCtrlK" => return Ok(Action::SendLiteralCtrlK),
+            "SendLiteralLeader" => return Ok(Action::SendLiteralLeader),
             "ToggleSidebar" => return Ok(Action::ToggleSidebar),
             "ShowHelp" => return Ok(Action::ShowHelp),
             "Quit" => return Ok(Action::Quit),
@@ -256,11 +268,26 @@ mod tests {
         assert_eq!(Action::OpenCommandBar.help_label(), "Go to a session");
     }
 
+    /// The escape hatch (#156) is an ordinary action like any other.
+    #[test]
+    fn send_literal_ctrl_k_round_trips() {
+        assert_eq!(
+            Action::parse("SendLiteralCtrlK").unwrap(),
+            Action::SendLiteralCtrlK
+        );
+        assert_eq!(Action::SendLiteralCtrlK.to_string(), "SendLiteralCtrlK");
+        assert_eq!(
+            Action::SendLiteralCtrlK.help_label(),
+            "Send literal Ctrl-K to session"
+        );
+    }
+
     #[test]
     fn display_round_trips() {
         for a in [
             Action::EnterInsert,
             Action::OpenCommandBar,
+            Action::SendLiteralCtrlK,
             Action::RenameHighlighted,
             Action::Quit,
             Action::OpenSpawnModal,

crates/maestro-tui/src/app.rs

@@ -23,7 +23,7 @@ use uuid::Uuid;
 
 use crate::action::Action;
 use crate::catalog::CatalogStore;
-use crate::command_bar::{BarOutcome, BarTarget, CommandBar};
+use crate::command_bar::{BarOutcome, BarTarget, CommandBar, SessionActionId};
 use crate::config::TuiConfig;
 use crate::daemon_link::DaemonLink;
 use crate::draft::{DraftInputResult, DraftPane};
@@ -306,6 +306,7 @@ impl App {
                     return Ok(true);
                 }
             }
+            self.chord.take_replay();
             return Ok(false);
         }
 
@@ -325,32 +326,46 @@ impl App {
             return Ok(false);
         }
 
-        let known = self.cfg.keymap.known_bindings(self.state.mode);
-        match self.chord.feed(&key, &known) {
-            ChordResult::Pending => Ok(false),
-            ChordResult::Resolved(canon) => {
-                let act = self.cfg.keymap.resolve(self.state.mode, &canon);
-                if matches!(act, Some(Action::Quit)) {
-                    return Ok(true);
+        // A key bumped out of an abandoned chord (#156) is replayed as its
+        // own keystroke, against the mode dispatch may have just changed.
+        let mut current_key = key;
+        let mut result = self.chord.feed(
+            &current_key,
+            &self.cfg.keymap.known_bindings(self.state.mode),
+        );
+        loop {
+            let canon = match result {
+                ChordResult::Pending => return Ok(false),
+                ChordResult::Resolved(canon) => canon,
+            };
+            let act = self.cfg.keymap.resolve(self.state.mode, &canon);
+            if matches!(act, Some(Action::Quit)) {
+                return Ok(true);
+            }
+            let pty_owns_keys =
+                self.state.mode == Mode::Insert && matches!(self.state.focus, Focus::Pane);
+            match act {
+                // `Noop` suppresses a binding, and a key with no binding in
+                // Insert mode is the session's — so a key bound to `Noop`
+                // reaches the pty too. That is the escape hatch for taking
+                // a default binding back.
+                Some(Action::Noop) | None if pty_owns_keys => {
+                    let effects = self.forward_to_session(&current_key).into_iter().collect();
+                    self.perform(effects).await;
                 }
-                let pty_owns_keys =
-                    self.state.mode == Mode::Insert && matches!(self.state.focus, Focus::Pane);
-                match act {
-                    // `Noop` suppresses a binding, and a key with no binding in
-                    // Insert mode is the session's — so a key bound to `Noop`
-                    // reaches the pty too. That is the escape hatch for taking
-                    // a default binding back.
-                    Some(Action::Noop) | None if pty_owns_keys => {
-                        let effects = self.forward_to_session(&key).into_iter().collect();
-                        self.perform(effects).await;
-                    }
-                    Some(act) => {
-                        let effects = self.dispatch(act);
-                        self.perform(effects).await;
-                    }
-                    None => {}
+                Some(act) => {
+                    let effects = self.dispatch(act);
+                    self.perform(effects).await;
                 }
-                Ok(false)
+                None => {}
+            }
+            match self.chord.take_replay() {
+                Some(replay_key) => {
+                    let known = self.cfg.keymap.known_bindings(self.state.mode);
+                    result = self.chord.feed(&replay_key, &known);
+                    current_key = replay_key;
+                }
+                None => return Ok(false),
             }
         }
     }
@@ -479,6 +494,25 @@ impl App {
                         self.close_command_bar();
                         (OverlayDecision::Consumed, vec![Effect::FastForwardIn(dir)])
                     }
+                    // The action page raises the flow this client already has
+                    // — for kill that is `KillConfirm`, which the TUI puts in
+                    // front of every kill (#160). The bar names the target;
+                    // it never reimplements the flow.
+                    BarOutcome::Open(BarTarget::SessionAction { session, action }) => {
+                        self.close_command_bar();
+                        let effects = match action {
+                            SessionActionId::Kill => {
+                                self.confirm_kill(session);
+                                Vec::new()
+                            }
+                            SessionActionId::Rename => {
+                                self.prompt_rename(session);
+                                Vec::new()
+                            }
+                            SessionActionId::SpawnSimilar => self.open_spawn_similar(session),
+                        };
+                        (OverlayDecision::Consumed, effects)
+                    }
                 }
             }
             Some(OverlayKind::Help) => {
@@ -527,6 +561,16 @@ impl App {
                 self.state.show_overlay(OverlayKind::Help);
             }
             Action::OpenCommandBar => effects.extend(self.open_command_bar()),
+            // Escape hatch (#156): the literal byte, not the bar.
+            Action::SendLiteralCtrlK => {
+                effects.extend(self.forward_to_session(&InputKey::ctrl_char('k')));
+            }
+            // Escape hatch (#158): the leader's own byte, built from the
+            // configured leader rather than a hardcoded key.
+            Action::SendLiteralLeader => {
+                let leader = self.cfg.leader.clone();
+                effects.extend(self.forward_to_session(&leader));
+            }
             Action::OpenSpawnModal => {
                 self.open_spawn_modal();
                 effects.push(Effect::LoadDraft);
@@ -555,24 +599,12 @@ impl App {
             }
             Action::KillHighlighted => {
                 if let Some(sid) = self.pick_sidebar_target() {
-                    self.state.show_overlay(OverlayKind::KillConfirm(sid));
+                    self.confirm_kill(sid);
                 }
             }
             Action::RenameHighlighted => {
                 if let Some(sid) = self.pick_sidebar_target() {
-                    // Pre-fill with the custom name only: a session that has
-                    // none starts empty rather than with its command already
-                    // typed in, which Enter would then pin as the name.
-                    self.rename_input = TextInput::with_value(
-                        self.catalog
-                            .snapshot()
-                            .sessions
-                            .iter()
-                            .find(|s| s.id == sid)
-                            .and_then(crate::sidebar::custom_name_for)
-                            .unwrap_or_default(),
-                    );
-                    self.state.show_overlay(OverlayKind::Rename(sid));
+                    self.prompt_rename(sid);
                 }
             }
         }
@@ -858,6 +890,30 @@ impl App {
         Some(None)
     }
 
+    /// Raise the kill confirmation for one session (`docs/WORKTREES.md`).
+    /// Shared by the keymap's own kill and the command bar's action page
+    /// (#155), which picks the action and hands off rather than reimplementing
+    /// it; the blockers the dialog names are read at render time.
+    fn confirm_kill(&mut self, sid: Uuid) {
+        self.state.show_overlay(OverlayKind::KillConfirm(sid));
+    }
+
+    /// Raise the rename prompt for one session, pre-filled with its custom
+    /// name only: a session that has none starts empty rather than with its
+    /// command already typed in, which Enter would then pin as the name.
+    fn prompt_rename(&mut self, sid: Uuid) {
+        self.rename_input = TextInput::with_value(
+            self.catalog
+                .snapshot()
+                .sessions
+                .iter()
+                .find(|s| s.id == sid)
+                .and_then(crate::sidebar::custom_name_for)
+                .unwrap_or_default(),
+        );
+        self.state.show_overlay(OverlayKind::Rename(sid));
+    }
+
     /// Put the spawn form up with a fresh draft behind it, preselecting the
     /// project of the session the operator was last on — so `n` then Enter
     /// spawns another session there, the way "spawn similar" would. A
@@ -871,6 +927,30 @@ impl App {
         self.state.open_spawn_modal();
     }
 
+    /// "Spawn similar" (#155): the spawn form seeded from one session's
+    /// directory and command, rather than from whatever the operator was last
+    /// looking at. Same base-repository rule as the plain seed, and the name
+    /// is left out on purpose — a clone is a new session and takes its own
+    /// generated handle, like `web/src/spawnSimilar.ts`.
+    fn open_spawn_similar(&mut self, sid: Uuid) -> Vec<Effect> {
+        let session = self
+            .catalog
+            .snapshot()
+            .sessions
+            .iter()
+            .find(|s| s.id == sid)
+            .cloned();
+        self.open_spawn_modal();
+        if let (Some(session), Some(draft)) = (session, self.draft.as_mut()) {
+            draft.seed_cwd = Some(match &session.worktree {
+                Some(wt) => wt.base_repo.clone(),
+                None => session.cwd.clone(),
+            });
+            draft.seed_command = (!session.command.is_empty()).then(|| session.command.clone());
+        }
+        vec![Effect::LoadDraft]
+    }
+
     /// The project of the session the operator was last on — its base
     /// repository for a worktree session, its cwd otherwise. Shared by the
     /// plain spawn modal seed and fast-forward's project pick (#67 review):
@@ -1818,6 +1898,7 @@ mod tests {
                     current_cwd: None,
                     blocked_work: None,
                     last_focused_at: None,
+                    agent_session_id: None,
                 })
                 .collect(),
         });
@@ -1999,6 +2080,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::SidebarNext);
@@ -2026,6 +2108,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -2857,6 +2940,55 @@ mod tests {
         CtEvent::Key(crossterm::event::KeyEvent::new(code, mods))
     }
 
+    fn ctrl_key_event(c: char) -> CtEvent {
+        key_event(
+            crossterm::event::KeyCode::Char(c),
+            crossterm::event::KeyModifiers::CONTROL,
+        )
+    }
+
+    /// Drive a sequence of key events through an app in Insert mode with a
+    /// session attached, and report the app afterwards plus every chunk of
+    /// bytes that reached that session, in order.
+    async fn drive_insert_sequence(
+        section: &TuiSection,
+        events: &[CtEvent],
+    ) -> (App, Vec<Vec<u8>>) {
+        use crate::session_task::{SessionHandle, SessionState};
+        use std::sync::atomic::{AtomicU64, AtomicU8};
+        use std::sync::{Arc, Mutex};
+        use tokio::sync::mpsc;
+
+        let sid = Uuid::from_u128(41);
+        let mut app = App::new(
+            TuiConfig::load(section).unwrap(),
+            CatalogStore::default(),
+            DaemonClient::new("http://127.0.0.1:7070"),
+            DaemonLink::default(),
+        );
+        let (tx, mut rx) = mpsc::channel(8);
+        app.emulators.insert(
+            sid,
+            SessionHandle {
+                tx,
+                screen: Arc::new(Mutex::new(vt100::Parser::new(24, 80, 0))),
+                state: Arc::new(AtomicU8::new(SessionState::Live as u8)),
+                revision: Arc::new(AtomicU64::new(0)),
+            },
+        );
+        app.state.attach_to_focused(sid);
+        app.state.mode = Mode::Insert;
+        app.state.focus = Focus::Pane;
+        for ev in events {
+            app.handle_event(ev.clone()).await.unwrap();
+        }
+        let mut sent = Vec::new();
+        while let Ok(SessionInput::Bytes(bytes)) = rx.try_recv() {
+            sent.push(bytes);
+        }
+        (app, sent)
+    }
+
     /// Escape belongs to the session: full-screen apps (vim, Claude Code) read
     /// it constantly, so no Insert-mode default may swallow it. The leader is
     /// the way back to the sidebar.
@@ -2875,19 +3007,120 @@ mod tests {
 
     /// `Noop` suppresses a binding, and in Insert mode a key with no binding is
     /// the session's — so binding a key to `Noop` hands it to the pty.
+    ///
+    /// Uses `ctrl-x`, not the leader: the leader is also a chord prefix
+    /// (#156), so a single fed keystroke on it resolves as `Pending`, not
+    /// `Resolved` — a different mechanism, covered separately below.
     #[tokio::test]
     async fn a_noop_insert_binding_forwards_the_key_to_the_session() {
         let mut section = TuiSection::default();
-        section.keymap_insert.insert("ctrl-a".into(), "Noop".into());
+        section.keymap_insert.insert("ctrl-x".into(), "Noop".into());
         let sent = bytes_sent_for(
             &section,
             key_event(
-                crossterm::event::KeyCode::Char('a'),
+                crossterm::event::KeyCode::Char('x'),
                 crossterm::event::KeyModifiers::CONTROL,
             ),
         )
         .await;
-        assert_eq!(sent, Some(vec![0x01]));
+        assert_eq!(sent, Some(vec![0x18]));
+    }
+
+    /// Leader then `ctrl-k` sends the literal byte and never opens the bar
+    /// (#156) — the default leader, `ctrl-a`.
+    #[tokio::test]
+    async fn leader_then_ctrl_k_sends_the_literal_byte_and_does_not_open_the_bar() {
+        let (app, sent) = drive_insert_sequence(
+            &TuiSection::default(),
+            &[ctrl_key_event('a'), ctrl_key_event('k')],
+        )
+        .await;
+        assert_eq!(sent, vec![vec![0x0b]]);
+        assert_eq!(app.state.overlay(), None);
+        assert_eq!(app.state.mode, Mode::Insert, "still in Insert, not left");
+    }
+
+    /// The escape hatch is built from the configured leader, not a hardcoded
+    /// `ctrl-a` — rebinding `[tui].leader` rebinds it too (#156).
+    #[tokio::test]
+    async fn a_rebound_leader_still_reaches_the_literal_ctrl_k_escape() {
+        let section = TuiSection {
+            leader: Some("ctrl-b".into()),
+            ..Default::default()
+        };
+        let (app, sent) =
+            drive_insert_sequence(&section, &[ctrl_key_event('b'), ctrl_key_event('k')]).await;
+        assert_eq!(sent, vec![vec![0x0b]]);
+        assert_eq!(app.state.overlay(), None);
+    }
+
+    /// Leader alone, followed by an ordinary key, still leaves Insert mode —
+    /// the escape hatch chord doesn't cost the leader its existing meaning
+    /// (#156).
+    #[tokio::test]
+    async fn leader_alone_still_leaves_insert_when_followed_by_another_key() {
+        let (app, sent) = drive_insert_sequence(
+            &TuiSection::default(),
+            &[
+                ctrl_key_event('a'),
+                key_event(
+                    crossterm::event::KeyCode::Char('j'),
+                    crossterm::event::KeyModifiers::NONE,
+                ),
+            ],
+        )
+        .await;
+        assert!(
+            sent.is_empty(),
+            "no bytes for the leader chord itself: {sent:?}"
+        );
+        assert_eq!(app.state.mode, Mode::Normal, "leader still leaves Insert");
+    }
+
+    /// Leader pressed twice sends one literal leader byte, tmux-style, and
+    /// clears the pending chord rather than leaving Insert (#158) — the
+    /// default leader, `ctrl-a`.
+    #[tokio::test]
+    async fn leader_twice_sends_the_literal_leader_byte_and_stays_in_insert() {
+        let (app, sent) = drive_insert_sequence(
+            &TuiSection::default(),
+            &[ctrl_key_event('a'), ctrl_key_event('a')],
+        )
+        .await;
+        assert_eq!(sent, vec![vec![0x01]]);
+        assert_eq!(app.state.mode, Mode::Insert, "still in Insert, not left");
+    }
+
+    /// The escape hatch is built from the configured leader, not a hardcoded
+    /// `ctrl-a` — rebinding `[tui].leader` rebinds it too (#158).
+    #[tokio::test]
+    async fn a_rebound_leader_still_reaches_the_literal_leader_escape() {
+        let section = TuiSection {
+            leader: Some("ctrl-b".into()),
+            ..Default::default()
+        };
+        let (app, sent) =
+            drive_insert_sequence(&section, &[ctrl_key_event('b'), ctrl_key_event('b')]).await;
+        assert_eq!(sent, vec![vec![0x02]]);
+        assert_eq!(app.state.mode, Mode::Insert);
+    }
+
+    /// After the literal-leader escape fires, the chord is gone — a further
+    /// leader press starts a fresh chord rather than resolving as a
+    /// three-deep sequence (#158).
+    #[tokio::test]
+    async fn leader_twice_then_ctrl_k_is_a_fresh_chord() {
+        let (_app, sent) = drive_insert_sequence(
+            &TuiSection::default(),
+            &[
+                ctrl_key_event('a'),
+                ctrl_key_event('a'),
+                ctrl_key_event('a'),
+                ctrl_key_event('k'),
+            ],
+        )
+        .await;
+        assert_eq!(sent, vec![vec![0x01], vec![0x0b]]);
     }
 
     #[test]
@@ -2984,6 +3217,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: focused,
+            agent_session_id: None,
         };
         let older = Utc::now() - chrono::Duration::seconds(60);
         app.catalog.apply_event(CatalogEvent::Snapshot {
@@ -3262,6 +3496,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::KillHighlighted);
@@ -3297,6 +3532,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: None,
             }],
         });
     }
@@ -3379,4 +3615,79 @@ mod tests {
             }]
         );
     }
+
+    // ---- the session action page (#155) ----
+
+    /// Drill into the second row's session, then pick an action by name.
+    fn drill_and_pick(app: &mut App, action: &str) -> (OverlayDecision, Vec<Effect>) {
+        app.dispatch(Action::OpenCommandBar);
+        app.handle_overlay_input(&InputKey::Down);
+        app.handle_overlay_input(&InputKey::Tab);
+        type_into_bar(app, action);
+        app.handle_overlay_input(&InputKey::Enter)
+    }
+
+    /// The bar picks the action and hands off: kill goes through the confirm
+    /// this client puts in front of every kill, not straight to the daemon.
+    #[test]
+    fn the_action_page_raises_the_existing_kill_confirm() {
+        let mut app = make_app();
+        let (alpha, _bravo) = seed_two_sessions(&mut app);
+        let (decision, effects) = drill_and_pick(&mut app, "kill");
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert!(effects.is_empty(), "the confirm is the whole effect");
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::KillConfirm(alpha)));
+        assert!(app.command_bar.is_none());
+    }
+
+    #[test]
+    fn the_action_page_raises_the_existing_rename_prompt_prefilled() {
+        let mut app = make_app();
+        let (alpha, _bravo) = seed_two_sessions(&mut app);
+        let (decision, effects) = drill_and_pick(&mut app, "rename");
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert!(effects.is_empty());
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::Rename(alpha)));
+        assert_eq!(app.rename_input.value(), "alpha");
+        assert!(app.command_bar.is_none());
+    }
+
+    /// Spawn similar opens the spawn form seeded from that session's directory
+    /// and command — not from whatever the operator was last looking at.
+    #[test]
+    fn the_action_page_raises_the_spawn_form_seeded_from_the_session() {
+        let mut app = make_app();
+        seed_two_sessions(&mut app);
+        let (decision, effects) = drill_and_pick(&mut app, "spawn");
+        assert_eq!(decision, OverlayDecision::Consumed);
+        assert_eq!(effects, vec![Effect::LoadDraft]);
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::Spawn));
+        let draft = app.draft.as_ref().unwrap();
+        assert_eq!(draft.seed_cwd, Some(std::path::PathBuf::from("/")));
+        assert_eq!(draft.seed_command.as_deref(), Some("bash"));
+        assert!(app.command_bar.is_none());
+    }
+
+    /// Backing out is free: the result-list query survives the round trip.
+    #[test]
+    fn escape_on_the_action_page_returns_to_the_result_list() {
+        let mut app = make_app();
+        seed_two_sessions(&mut app);
+        app.dispatch(Action::OpenCommandBar);
+        type_into_bar(&mut app, "alp");
+        app.handle_overlay_input(&InputKey::Tab);
+        assert!(app.command_bar.as_ref().unwrap().on_action_page());
+
+        let (decision, _) = app.handle_overlay_input(&InputKey::Esc);
+        assert_eq!(decision, OverlayDecision::Consumed);
+        let bar = app.command_bar.as_ref().expect("escape backs out, not out");
+        assert!(!bar.on_action_page());
+        assert_eq!(bar.query(), "alp");
+        assert_eq!(app.state.overlay(), Some(&OverlayKind::CommandBar));
+
+        // A second escape is the way out again.
+        app.handle_overlay_input(&InputKey::Esc);
+        assert!(app.command_bar.is_none());
+        assert!(app.state.overlay().is_none());
+    }
 }

crates/maestro-tui/src/catalog.rs

@@ -223,6 +223,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 

crates/maestro-tui/src/command_bar.rs

@@ -2,8 +2,9 @@
 //! result list, opened from Normal or Insert mode, closed with Escape.
 //!
 //! Three kinds live here: sessions and commands, ranked together by default,
-//! and directories, which need the `~` sigil (#154). The session action page
-//! (#155) and the leader's literal Ctrl-K (#156) land later.
+//! and directories, which need the `~` sigil (#154). `tab` on a session drills
+//! into its action page (#155), the same overlay over three actions. The
+//! leader's literal Ctrl-K (#156) lands later.
 //!
 //! Ranking is [`crate::matcher`]'s job and nothing here reorders it — the
 //! groups are a rendering of the ranked list, in the order their best-scoring
@@ -46,8 +47,42 @@ pub enum BarTarget {
     /// Fast-forward spawn in this directory, absolute — the abbreviated form
     /// is what the row shows and what the matcher ranked.
     Directory(PathBuf),
+    /// A row of the action page: run this action against this session (#155).
+    SessionAction {
+        session: Uuid,
+        action: SessionActionId,
+    },
 }
 
+/// The actions a session's action page offers, and no others: the bar picks
+/// one and hands off to the flow that already implements it
+/// (`docs/COMMAND-BAR.md`, "Drill-in"). Mirrors the web's `SessionActionId`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SessionActionId {
+    Kill,
+    Rename,
+    SpawnSimilar,
+}
+
+impl SessionActionId {
+    /// The row's text, which is also the only field the matcher sees.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Kill => "Kill session",
+            Self::Rename => "Rename session",
+            Self::SpawnSimilar => "Spawn similar",
+        }
+    }
+}
+
+/// The page's actions in the order an empty query lists them, since the
+/// matcher keeps input order.
+pub const SESSION_ACTIONS: [SessionActionId; 3] = [
+    SessionActionId::Kill,
+    SessionActionId::Rename,
+    SessionActionId::SpawnSimilar,
+];
+
 /// The first character of the query, when it is one of the two that narrow the
 /// list to a single kind.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -159,7 +194,9 @@ pub enum BarOutcome {
 pub fn order_sessions_for_bar(sessions: &[Session]) -> Vec<&Session> {
     let mut ordered: Vec<&Session> = sessions.iter().collect();
     ordered.sort_by(|a, b| {
-        let dead = |s: &Session| u8::from(s.status == SessionStatus::Dead);
+        // docs/COMMAND-BAR.md: anything with no live pane — dead or dormant
+        // (#162) — sorts after the sessions you could actually attach to.
+        let dead = |s: &Session| u8::from(s.status != SessionStatus::Running);
         dead(a)
             .cmp(&dead(b))
             .then_with(|| {
@@ -255,10 +292,23 @@ pub struct CommandBar {
     sessions: Vec<BarEntry>,
     commands: Vec<BarEntry>,
     directories: Vec<BarEntry>,
+    /// The action page while it is up (#155), and the result-list query it was
+    /// drilled into from — backing out restores that query, so the round trip
+    /// costs the operator nothing.
+    page: Option<ActionPage>,
+    stashed: String,
     rows: Vec<BarRow>,
     highlight: usize,
 }
 
+/// The session action page while it is up: the name the overlay titles itself
+/// with, and the three action rows the query line runs over.
+#[derive(Debug)]
+struct ActionPage {
+    name: String,
+    actions: Vec<BarEntry>,
+}
+
 impl CommandBar {
     /// Open the bar over the sessions the catalog has right now and the live
     /// keymap for the current mode. Directories arrive later
@@ -271,7 +321,7 @@ impl CommandBar {
             .map(|s| BarEntry {
                 candidate: MatchCandidate::Session(session_candidate(s, home_dir)),
                 target: BarTarget::Session(s.id),
-                dead: s.status == SessionStatus::Dead,
+                dead: s.status != SessionStatus::Running,
                 chords: Vec::new(),
             })
             .collect();
@@ -293,6 +343,8 @@ impl CommandBar {
             sessions,
             commands,
             directories: Vec::new(),
+            page: None,
+            stashed: String::new(),
             rows: Vec::new(),
             highlight: 0,
         };
@@ -381,7 +433,15 @@ impl CommandBar {
     /// "Keys") does not claim is ordinary editing.
     pub fn handle_key(&mut self, key: &InputKey) -> BarOutcome {
         match key {
-            InputKey::Esc => BarOutcome::Close,
+            // On the action page Escape is one level up, not the way out.
+            InputKey::Esc => {
+                if self.page.is_some() {
+                    self.leave_page();
+                    BarOutcome::Stay
+                } else {
+                    BarOutcome::Close
+                }
+            }
             InputKey::Enter => match self.selected() {
                 Some(row) => BarOutcome::Open(row.target.clone()),
                 // Nothing to open: the bar stays up rather than closing on a
@@ -402,9 +462,19 @@ impl CommandBar {
                 self.move_highlight(1);
                 BarOutcome::Stay
             }
-            // Tab drills into the highlighted session's action page (#155).
-            // Until then it is inert rather than a literal tab in the query.
-            InputKey::Tab | InputKey::BackTab => BarOutcome::Stay,
+            // Tab drills into the highlighted session's action page (#155);
+            // shift-tab is inert rather than a literal tab in the query.
+            InputKey::Tab => {
+                self.drill_in();
+                BarOutcome::Stay
+            }
+            InputKey::BackTab => BarOutcome::Stay,
+            // Ordinary editing, except at an empty query on the action page,
+            // where it is the second way back to the result list.
+            InputKey::Backspace if self.page.is_some() && self.input.value().is_empty() => {
+                self.leave_page();
+                BarOutcome::Stay
+            }
             other => {
                 let before = self.input.value().to_string();
                 self.input.handle_key(other);
@@ -416,15 +486,75 @@ impl CommandBar {
         }
     }
 
+    /// `tab`: drill into the highlighted session's action page. No effect on
+    /// any other kind, and none on the page itself, which has no session rows.
+    fn drill_in(&mut self) {
+        if self.page.is_some() {
+            return;
+        }
+        let Some(row) = self.selected() else {
+            return;
+        };
+        let BarTarget::Session(session) = row.target else {
+            return;
+        };
+        let name = row.name.clone();
+        let actions = SESSION_ACTIONS
+            .iter()
+            .map(|&action| BarEntry {
+                candidate: MatchCandidate::Command(CommandCandidate {
+                    label: action.label().to_string(),
+                }),
+                target: BarTarget::SessionAction { session, action },
+                dead: false,
+                chords: Vec::new(),
+            })
+            .collect();
+        self.page = Some(ActionPage { name, actions });
+        self.stashed = self.input.value().to_string();
+        self.input = TextInput::default();
+        self.recompute();
+    }
+
+    /// Escape, or backspace at an empty query: back to the result list with
+    /// the query the drill-in was made from.
+    fn leave_page(&mut self) {
+        self.page = None;
+        self.input = TextInput::with_value(std::mem::take(&mut self.stashed));
+        self.recompute();
+    }
+
+    /// Whether the action page is up. The session it acts on is in every one
+    /// of its rows' targets.
+    pub fn on_action_page(&self) -> bool {
+        self.page.is_some()
+    }
+
+    /// What the matcher sees. On the action page the whole query is the query:
+    /// a sigil narrows the result list to one kind, and the page is one kind
+    /// already.
+    fn parsed_query(&self) -> BarQuery<'_> {
+        match self.page {
+            Some(_) => BarQuery {
+                sigil: None,
+                query: self.input.value(),
+            },
+            None => parse_bar_query(self.input.value()),
+        }
+    }
+
     /// The sigil in force for the query as it stands.
     pub fn sigil(&self) -> Option<BarSigil> {
-        parse_bar_query(self.input.value()).sigil
+        self.parsed_query().sigil
     }
 
     /// The candidates the query line asks for. A sigil narrows to one kind;
     /// with no sigil the list is mixed — sessions and commands ranked together
     /// — except on an empty query, where the bar is a session switcher.
     fn active_entries(&self, parsed: BarQuery<'_>) -> Vec<&BarEntry> {
+        if let Some(page) = &self.page {
+            return page.actions.iter().collect();
+        }
         match parsed.sigil {
             Some(BarSigil::Command) => self.commands.iter().collect(),
             Some(BarSigil::Directory) => self.directories.iter().collect(),
@@ -438,7 +568,7 @@ impl CommandBar {
     /// different result.
     fn recompute(&mut self) {
         let rows: Vec<BarRow> = {
-            let parsed = parse_bar_query(self.input.value());
+            let parsed = self.parsed_query();
             let entries = self.active_entries(parsed);
             let candidates: Vec<MatchCandidate> =
                 entries.iter().map(|e| e.candidate.clone()).collect();
@@ -482,12 +612,16 @@ impl CommandBar {
         let height = parent.height.saturating_sub(4).clamp(5, 20);
         let area = centered(parent, 72, height);
         f.render_widget(Clear, area);
+        // The page names the session being acted on, so the target is never
+        // ambiguous.
+        let title = match (&self.page, self.sigil()) {
+            (Some(page), _) => format!(" act on {} ", page.name),
+            (None, Some(BarSigil::Command)) => " run a command ".to_string(),
+            (None, Some(BarSigil::Directory)) => " spawn in ".to_string(),
+            (None, None) => " go to ".to_string(),
+        };
         let block = Block::default()
-            .title(match self.sigil() {
-                Some(BarSigil::Command) => " run a command ",
-                Some(BarSigil::Directory) => " spawn in ",
-                None => " go to ",
-            })
+            .title(title)
             .borders(Borders::ALL)
             .style(pal.card.base())
             .border_style(pal.border_style(true));
@@ -510,7 +644,11 @@ impl CommandBar {
             .render(query, f.buffer_mut(), pal.card.text_style());
         f.render_widget(
             Paragraph::new(Line::from(Span::styled(
-                "[enter] open   [esc] close",
+                if self.page.is_some() {
+                    "[enter] run   [esc] back"
+                } else {
+                    "[enter] open   [esc] close"
+                },
                 pal.card.dim_style(),
             ))),
             row(inner.height - 1),
@@ -540,8 +678,9 @@ impl CommandBar {
         let mut lines: Vec<Line<'static>> = Vec::new();
         let mut highlight_line = 0usize;
         // While a sigil is in force there is one kind, so the header is
-        // dropped — it would name what the whole list already is.
-        let headers = self.sigil().is_none();
+        // dropped — it would name what the whole list already is. The action
+        // page is one kind too.
+        let headers = self.sigil().is_none() && self.page.is_none();
         for group in self.groups() {
             if headers {
                 lines.push(Line::from(Span::styled(
@@ -672,6 +811,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -752,6 +892,23 @@ mod tests {
         assert!(bar.rows()[1].dead);
     }
 
+    /// #162: docs/COMMAND-BAR.md ranks by whether you could attach, not by
+    /// which way the pane went away — a dormant session sorts with the dead.
+    #[test]
+    fn dormant_sessions_sort_after_live_ones_however_recent() {
+        let mut dormant = named(1, "dormant");
+        dormant.status = SessionStatus::Dormant;
+        dormant.last_focused_at = Some(at(99));
+        let live = named(2, "live");
+
+        let bar = CommandBar::new(&[dormant, live], &[], "/home/me");
+        assert_eq!(
+            ids(bar.rows()),
+            vec![Uuid::from_u128(2), Uuid::from_u128(1)]
+        );
+        assert!(bar.rows()[1].dead);
+    }
+
     #[test]
     fn typing_ranks_through_the_matcher_and_returns_ranges() {
         let mut bar = CommandBar::new(
@@ -1219,4 +1376,163 @@ mod tests {
         }
         assert_eq!(bold, vec!["w", "s"], "bold cells: {bold:?}");
     }
+
+    // ---- the session action page (#155) ----
+
+    fn targets(rows: &[BarRow]) -> Vec<BarTarget> {
+        rows.iter().map(|r| r.target.clone()).collect()
+    }
+
+    #[test]
+    fn tab_on_a_session_opens_its_action_page() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        assert!(bar.on_action_page());
+        assert_eq!(
+            labels(bar.rows()),
+            vec!["Kill session", "Rename session", "Spawn similar"]
+        );
+        assert_eq!(
+            targets(bar.rows()),
+            SESSION_ACTIONS
+                .iter()
+                .map(|&action| BarTarget::SessionAction {
+                    session: Uuid::from_u128(1),
+                    action,
+                })
+                .collect::<Vec<_>>()
+        );
+    }
+
+    /// Tab has no effect on any other kind, and none on the page itself, which
+    /// has no session rows.
+    #[test]
+    fn tab_on_a_command_or_directory_row_does_nothing() {
+        let keymap = vec![("x".to_string(), Action::KillHighlighted)];
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &keymap, "/home/me");
+        typed(&mut bar, ">");
+        bar.handle_key(&InputKey::Tab);
+        assert!(!bar.on_action_page());
+        assert_eq!(bar.query(), ">");
+
+        let mut bar = CommandBar::new(&[], &[], "/home/me");
+        bar.set_directories(&[PathBuf::from("/home/me/dev/api")]);
+        typed(&mut bar, "~");
+        bar.handle_key(&InputKey::Tab);
+        assert!(!bar.on_action_page());
+    }
+
+    #[test]
+    fn tab_on_the_action_page_does_not_drill_further() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        bar.handle_key(&InputKey::Tab);
+        assert!(bar.on_action_page());
+        assert_eq!(labels(bar.rows()).len(), 3);
+    }
+
+    /// The page drills into the highlighted session, not the first one.
+    #[test]
+    fn the_page_acts_on_the_highlighted_session() {
+        let mut bar = CommandBar::new(&[named(1, "alpha"), named(2, "bravo")], &[], "/home/me");
+        bar.move_highlight(1);
+        bar.handle_key(&InputKey::Tab);
+        assert_eq!(
+            bar.rows()[0].target,
+            BarTarget::SessionAction {
+                session: Uuid::from_u128(2),
+                action: SessionActionId::Kill,
+            }
+        );
+    }
+
+    #[test]
+    fn the_action_page_stays_fuzzy_searchable() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        typed(&mut bar, "ren");
+        assert_eq!(labels(bar.rows()), vec!["Rename session"]);
+        assert_eq!(
+            bar.selected().map(|r| r.target.clone()),
+            Some(BarTarget::SessionAction {
+                session: Uuid::from_u128(1),
+                action: SessionActionId::Rename,
+            })
+        );
+    }
+
+    /// A sigil narrows the result list to one kind; the page is one kind
+    /// already, so `>` there is a query character like any other.
+    #[test]
+    fn a_sigil_is_an_ordinary_character_on_the_action_page() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        typed(&mut bar, ">");
+        assert_eq!(bar.sigil(), None);
+        assert!(bar.rows().is_empty());
+    }
+
+    #[test]
+    fn escape_returns_to_the_result_list_with_the_query_intact() {
+        let mut bar = CommandBar::new(&[named(1, "alpha"), named(2, "bravo")], &[], "/home/me");
+        typed(&mut bar, "alp");
+        assert_eq!(bar.handle_key(&InputKey::Tab), BarOutcome::Stay);
+        assert_eq!(bar.query(), "", "the page starts on an empty query");
+        // Escape is one level up, not the way out.
+        assert_eq!(bar.handle_key(&InputKey::Esc), BarOutcome::Stay);
+        assert!(!bar.on_action_page());
+        assert_eq!(bar.query(), "alp");
+        assert_eq!(labels(bar.rows()), vec!["alpha"]);
+        // Off the page it closes the bar again.
+        assert_eq!(bar.handle_key(&InputKey::Esc), BarOutcome::Close);
+    }
+
+    #[test]
+    fn backspace_at_an_empty_query_returns_to_the_result_list() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        typed(&mut bar, "alp");
+        bar.handle_key(&InputKey::Tab);
+        bar.handle_key(&InputKey::Backspace);
+        assert!(!bar.on_action_page());
+        assert_eq!(bar.query(), "alp");
+    }
+
+    /// Backspace with something typed is ordinary editing of the page's own
+    /// query, not the way out.
+    #[test]
+    fn backspace_on_a_non_empty_page_query_edits_it() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        typed(&mut bar, "alp");
+        bar.handle_key(&InputKey::Tab);
+        typed(&mut bar, "kx");
+        bar.handle_key(&InputKey::Backspace);
+        assert!(bar.on_action_page());
+        assert_eq!(bar.query(), "k");
+        assert_eq!(labels(bar.rows()), vec!["Kill session"]);
+    }
+
+    #[test]
+    fn enter_on_the_page_opens_the_action_for_that_session() {
+        let mut bar = CommandBar::new(&[named(1, "alpha")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        typed(&mut bar, "spawn");
+        assert_eq!(
+            bar.handle_key(&InputKey::Enter),
+            BarOutcome::Open(BarTarget::SessionAction {
+                session: Uuid::from_u128(1),
+                action: SessionActionId::SpawnSimilar,
+            })
+        );
+    }
+
+    #[test]
+    fn the_action_page_titles_itself_with_the_session_it_acts_on() {
+        let mut bar = CommandBar::new(&[named(1, "amber-falcon")], &[], "/home/me");
+        bar.handle_key(&InputKey::Tab);
+        let rendered = render_to_string(&bar, 90, 20);
+        assert!(rendered.contains("act on amber-falcon"), "{rendered}");
+        assert!(rendered.contains("Kill session"), "{rendered}");
+        // One kind, so the group header is dropped the way a sigil drops it.
+        assert!(!rendered.contains("Commands"), "{rendered}");
+    }
 }

crates/maestro-tui/src/config.rs

@@ -114,7 +114,7 @@ impl TuiConfig {
             TuiTheme::Nord => Palette::NORD,
             TuiTheme::Dracula => Palette::DRACULA,
         };
-        let leader_str = section.leader.as_deref().unwrap_or("ctrl-a");
+        let leader_str = section.leader();
         let leader = InputKey::parse(leader_str)
             .map_err(|_| TuiConfigError::BadLeader(leader_str.to_string()))?;
         let chord_timeout = Duration::from_millis(section.chord_timeout_ms.unwrap_or(1000));
@@ -146,6 +146,25 @@ impl TuiConfig {
         keymap
             .set(Mode::Insert, &leader.canonical(), "LeaveInsert")
             .expect("leader canonical form is valid by construction");
+        // Leader, ctrl-k → the literal-Ctrl-K escape hatch (#156), built from
+        // the same leader spec so rebinding leader rebinds this chord too.
+        keymap
+            .set(
+                Mode::Insert,
+                &format!("{} ctrl-k", leader.canonical()),
+                "SendLiteralCtrlK",
+            )
+            .expect("leader canonical form is valid by construction");
+        // Leader, leader → the literal-leader escape hatch (#158), tmux-style:
+        // pressing it twice sends the leader byte itself. Built from the same
+        // leader spec, so rebinding leader rebinds this chord too.
+        keymap
+            .set(
+                Mode::Insert,
+                &format!("{} {}", leader.canonical(), leader.canonical()),
+                "SendLiteralLeader",
+            )
+            .expect("leader canonical form is valid by construction");
 
         for (input, action) in &section.keymap_normal {
             keymap.set(Mode::Normal, input, action).map_err(|source| {
@@ -278,6 +297,60 @@ mod tests {
         assert_eq!(cfg.keymap.resolve(Mode::Insert, "ctrl-a"), None);
     }
 
+    /// The literal-Ctrl-K escape hatch (#156) is chorded off the default
+    /// leader, `ctrl-a ctrl-k` — not the command bar.
+    #[test]
+    fn default_leader_escapes_a_literal_ctrl_k() {
+        let cfg = TuiConfig::load(&TuiSection::default()).unwrap();
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Insert, "ctrl-a ctrl-k"),
+            Some(Action::SendLiteralCtrlK),
+        );
+    }
+
+    /// Rebinding the leader must rebind the literal-Ctrl-K chord with it, not
+    /// just the Insert escape — proving the chord is built from the
+    /// configured leader rather than a hardcoded `ctrl-a`.
+    #[test]
+    fn rebinding_leader_moves_the_literal_ctrl_k_chord() {
+        let mut section = TuiSection::default();
+        section.leader = Some("ctrl-b".into());
+        let cfg = TuiConfig::load(&section).unwrap();
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Insert, "ctrl-b ctrl-k"),
+            Some(Action::SendLiteralCtrlK),
+        );
+        // The old leader's chord is gone along with its Insert escape.
+        assert_eq!(cfg.keymap.resolve(Mode::Insert, "ctrl-a ctrl-k"), None);
+    }
+
+    /// The literal-leader escape hatch (#158) is chorded off the leader
+    /// doubled: `ctrl-a ctrl-a` — tmux's doubled-prefix resolution.
+    #[test]
+    fn default_leader_escapes_a_literal_leader() {
+        let cfg = TuiConfig::load(&TuiSection::default()).unwrap();
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Insert, "ctrl-a ctrl-a"),
+            Some(Action::SendLiteralLeader),
+        );
+    }
+
+    /// Rebinding the leader must rebind the literal-leader chord with it,
+    /// not just the Insert escape and the Ctrl-K chord — proving it too is
+    /// built from the configured leader rather than a hardcoded `ctrl-a`.
+    #[test]
+    fn rebinding_leader_moves_the_literal_leader_chord() {
+        let mut section = TuiSection::default();
+        section.leader = Some("ctrl-b".into());
+        let cfg = TuiConfig::load(&section).unwrap();
+        assert_eq!(
+            cfg.keymap.resolve(Mode::Insert, "ctrl-b ctrl-b"),
+            Some(Action::SendLiteralLeader),
+        );
+        // The old leader's chord is gone along with the rest of its bindings.
+        assert_eq!(cfg.keymap.resolve(Mode::Insert, "ctrl-a ctrl-a"), None);
+    }
+
     #[test]
     fn user_normal_override_replaces_default() {
         let mut section = TuiSection::default();

crates/maestro-tui/src/daemon_link.rs

@@ -250,6 +250,7 @@ mod tests {
                 dirty: false,
             },
             instance: instance.into(),
+            leader: maestro_config::DEFAULT_LEADER.into(),
         }
     }
 

crates/maestro-tui/src/draft.rs

@@ -228,6 +228,10 @@ pub struct DraftPane {
     /// respawns there without touching the picker. Consumed by the first
     /// [`Self::set_projects`]; `None` once applied or when nothing seeded it.
     pub seed_cwd: Option<PathBuf>,
+    /// Command to preselect once the preset list lands — "spawn similar"'s
+    /// half of the clone (#155). Consumed by the first [`Self::set_presets`];
+    /// `None` once applied or when nothing seeded it.
+    pub seed_command: Option<String>,
     /// The repository picked in step one ([`group_key`] of its main box),
     /// `None` until a box is picked. Looked up fresh in `groups` rather than
     /// cached, so a project-list refresh can't leave it stale.
@@ -291,6 +295,7 @@ impl Default for DraftPane {
             id: NEXT_DRAFT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
             presets,
             selected_preset: 0,
+            seed_command: None,
             custom_command: crate::text_input::TextInput::default(),
             groups: Vec::new(),
             filter: crate::text_input::TextInput::default(),
@@ -342,6 +347,27 @@ impl DraftPane {
             .iter()
             .position(|p| !p.command.is_empty())
             .unwrap_or(0);
+        self.apply_seed_command();
+    }
+
+    /// Land a seeded command on the tile that runs it: its own preset when the
+    /// daemon offers one, otherwise the custom escape hatch with the command
+    /// typed in.
+    fn apply_seed_command(&mut self) {
+        let Some(command) = self.seed_command.take() else {
+            return;
+        };
+        match self.presets.iter().position(|p| p.command == command) {
+            Some(index) => self.selected_preset = index,
+            None => {
+                self.selected_preset = self
+                    .presets
+                    .iter()
+                    .position(|p| p.command.is_empty())
+                    .unwrap_or(self.selected_preset);
+                self.custom_command = crate::text_input::TextInput::with_value(command);
+            }
+        }
     }
 
     /// Replace the project snapshot: sort fresh-first (#54), group by
@@ -1679,6 +1705,7 @@ mod tests {
             id: "aider".into(),
             label: "Aider".into(),
             command: "aider".into(),
+            resume_command: None,
         }]);
         assert_eq!(
             draft.command(),
@@ -1688,6 +1715,51 @@ mod tests {
         assert_eq!(draft.presets.last().unwrap().id, "custom");
     }
 
+    /// "Spawn similar" (#155) seeds the cloned session's command: it lands on
+    /// the tile that runs it when the daemon offers one.
+    #[test]
+    fn a_seeded_command_selects_its_own_preset() {
+        let mut draft = DraftPane {
+            seed_command: Some("aider".into()),
+            ..DraftPane::default()
+        };
+        draft.set_presets(vec![
+            SpawnPreset {
+                id: "claude".into(),
+                label: "Claude".into(),
+                command: "claude".into(),
+                resume_command: None,
+            },
+            SpawnPreset {
+                id: "aider".into(),
+                label: "Aider".into(),
+                command: "aider".into(),
+                resume_command: None,
+            },
+        ]);
+        assert_eq!(draft.command(), "aider");
+        assert!(!draft.is_custom());
+        assert_eq!(draft.seed_command, None, "consumed by the first load");
+    }
+
+    /// A command no preset runs falls back to the custom tile with the command
+    /// typed in, so the clone still spawns what it cloned.
+    #[test]
+    fn a_seeded_command_with_no_preset_fills_the_custom_tile() {
+        let mut draft = DraftPane {
+            seed_command: Some("bash -l".into()),
+            ..DraftPane::default()
+        };
+        draft.set_presets(vec![SpawnPreset {
+            id: "claude".into(),
+            label: "Claude".into(),
+            command: "claude".into(),
+            resume_command: None,
+        }]);
+        assert!(draft.is_custom());
+        assert_eq!(draft.command(), "bash -l");
+    }
+
     #[test]
     fn left_right_cycles_presets_wrapping_into_custom() {
         let mut draft = DraftPane {

crates/maestro-tui/src/fast_forward.rs

@@ -183,6 +183,7 @@ mod tests {
             id: id.into(),
             label: id.into(),
             command: command.into(),
+            resume_command: None,
         }
     }
 

crates/maestro-tui/src/input.rs

@@ -387,6 +387,9 @@ pub struct ChordState {
     held: Vec<String>,
     last_press: Option<Instant>,
     timeout: Duration,
+    /// A key bumped out of an abandoned chord (see [`Self::feed`]), waiting
+    /// to be replayed as a fresh keystroke by the caller.
+    replay: Option<InputKey>,
 }
 
 impl ChordState {
@@ -395,6 +398,7 @@ impl ChordState {
             held: Vec::new(),
             last_press: None,
             timeout,
+            replay: None,
         }
     }
 
@@ -404,6 +408,13 @@ impl ChordState {
     ///   binding; wait for the next key.
     /// * `Resolved(s)` — `s` is the canonical chord (or single key) to look
     ///   up in the keymap. The held buffer is cleared.
+    ///
+    /// A held prefix that is itself directly bound (e.g. a leader key bound
+    /// alone as well as chorded, like `ctrl-a` and `ctrl-a ctrl-k`) resolves
+    /// to that binding the moment the next key fails to extend it, rather
+    /// than swallowing the held key and losing its meaning — the new key
+    /// never belonged to the chord and is handed back via [`Self::take_replay`]
+    /// so the caller can process it as its own keystroke.
     pub fn feed(&mut self, key: &InputKey, known_bindings: &HashSet<String>) -> ChordResult {
         if let Some(t) = self.last_press {
             if t.elapsed() > self.timeout {
@@ -428,11 +439,31 @@ impl ChordState {
 
         if is_prefix {
             self.held.push(key_s);
-            ChordResult::Pending
-        } else {
-            self.held.clear();
-            ChordResult::Resolved(candidate)
+            return ChordResult::Pending;
         }
+
+        if known_bindings.contains(&candidate) {
+            self.held.clear();
+            return ChordResult::Resolved(candidate);
+        }
+
+        if !self.held.is_empty() {
+            let held_str = self.held.join(" ");
+            self.held.clear();
+            if known_bindings.contains(&held_str) {
+                self.replay = Some(key.clone());
+                return ChordResult::Resolved(held_str);
+            }
+        }
+
+        ChordResult::Resolved(candidate)
+    }
+
+    /// Take the key bumped out of an abandoned chord by the last [`Self::feed`]
+    /// call, if any. The caller feeds it through again as a brand new
+    /// keystroke.
+    pub fn take_replay(&mut self) -> Option<InputKey> {
+        self.replay.take()
     }
 }
 
@@ -733,6 +764,41 @@ mod tests {
         assert_eq!(r, ChordResult::Resolved("g x".into()));
     }
 
+    /// A key bound both alone and as a chord prefix (the leader: `ctrl-a` and
+    /// `ctrl-a ctrl-k`) must still fire its own binding when the next key
+    /// doesn't complete the chord — the held key's meaning isn't lost, and
+    /// the new key comes back via `take_replay` for the caller to process on
+    /// its own (#156).
+    #[test]
+    fn a_bound_prefix_resolves_itself_and_replays_the_breaking_key() {
+        let mut chord = ChordState::new(Duration::from_secs(10));
+        let known: HashSet<String> = ["ctrl-a".into(), "ctrl-a ctrl-k".into()]
+            .into_iter()
+            .collect();
+
+        let r = chord.feed(&InputKey::ctrl_char('a'), &known);
+        assert_eq!(r, ChordResult::Pending);
+
+        let r = chord.feed(&InputKey::char('j'), &known);
+        assert_eq!(r, ChordResult::Resolved("ctrl-a".into()));
+        assert_eq!(chord.take_replay(), Some(InputKey::char('j')));
+    }
+
+    /// The full chord still resolves normally when the next key completes
+    /// it — no replay, no early fire of the shorter binding.
+    #[test]
+    fn a_completed_chord_off_a_bound_prefix_has_no_replay() {
+        let mut chord = ChordState::new(Duration::from_secs(10));
+        let known: HashSet<String> = ["ctrl-a".into(), "ctrl-a ctrl-k".into()]
+            .into_iter()
+            .collect();
+
+        chord.feed(&InputKey::ctrl_char('a'), &known);
+        let r = chord.feed(&InputKey::ctrl_char('k'), &known);
+        assert_eq!(r, ChordResult::Resolved("ctrl-a ctrl-k".into()));
+        assert_eq!(chord.take_replay(), None);
+    }
+
     #[test]
     fn chord_state_lone_key_resolves_immediately() {
         let mut chord = ChordState::new(Duration::from_secs(10));

crates/maestro-tui/src/sidebar.rs

@@ -268,6 +268,8 @@ impl Sidebar {
     fn name_row(&self, s: &Session, width: usize, focused: bool) -> Vec<Span<'static>> {
         let glyph = match (s.status, self.attached.contains(&s.id)) {
             (SessionStatus::Dead, _) => "✗",
+            // #162: known from its sidecar, nothing running behind it.
+            (SessionStatus::Dormant, _) => "◌",
             (SessionStatus::Running, true) => "●",
             (SessionStatus::Running, false) => "○",
         };
@@ -322,6 +324,7 @@ impl Sidebar {
         // on line 1; the kill confirm names the specifics.
         let blocked = s.blocked_work.filter(|b| !b.is_clear());
         let dead = s.status == SessionStatus::Dead;
+        let dormant = s.status == SessionStatus::Dormant;
         let highlighted = self.highlight == Some(SidebarItem::Session(s.id));
         let fill = self.card_fill(s, focused);
         let base = card_base(fill, focused);
@@ -361,6 +364,9 @@ impl Sidebar {
         if dead {
             tail.push(Span::styled(" exited", muted));
         }
+        if dormant {
+            tail.push(Span::styled(" dormant", muted));
+        }
         // docs/SIDEBAR.md: the card names the program, never its arguments.
         let command = Span::styled(format!(" {}", command_program(&s.command)), muted);
 
@@ -500,6 +506,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -1068,6 +1075,39 @@ mod tests {
         );
     }
 
+    /// #162, docs/SIDEBAR.md: a dormant session is known but not running —
+    /// its own glyph on line 1 and the muted `dormant` fragment on line 2, so
+    /// it never reads as something that exited.
+    #[test]
+    fn dormant_session_reads_as_known_but_not_running() {
+        let mut s = session_named(1, "claude");
+        s.status = SessionStatus::Dormant;
+        s.activity_since = Utc::now() - Duration::seconds(5);
+        let sb = Sidebar {
+            sessions: vec![s],
+            highlight: None,
+            attached: Default::default(),
+            pane_session: None,
+        };
+        let all = rows(&draw(&sb, 28, 8));
+        let idx = all.iter().position(|l| l.contains("claude")).unwrap();
+        assert!(
+            all[idx].contains('\u{25cc}'),
+            "expected the dormant glyph in: {:?}",
+            all[idx]
+        );
+        assert!(
+            all[idx + 1].contains("dormant"),
+            "expected dormant fragment in: {:?}",
+            all[idx + 1]
+        );
+        assert!(
+            !all[idx + 1].contains("exited"),
+            "a dormant session never reads as exited: {:?}",
+            all[idx + 1]
+        );
+    }
+
     /// docs/SIDEBAR.md: line 2 names the program, never its arguments.
     #[test]
     fn meta_line_drops_the_commands_arguments() {
@@ -1266,6 +1306,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         };
         let sb = Sidebar {
             sessions: vec![s],

docs/COMMAND-BAR.md

@@ -45,8 +45,21 @@ mirroring the TUI's. `ctrl-a` is select-all in a browser; the web
 `preventDefault`s it, since selecting all of a terminal pane does nothing
 useful.
 
-Only Ctrl-K gets an escape hatch. No other control character is intercepted, so
-none of them needs one.
+One knob drives both clients: the daemon serves `[tui].leader` as `leader` on
+`GET /api/info`, and the web binds that instead of its own constant (#159). A
+daemon too old to send the field, or an unreachable `/api/info`, leaves the web
+on `ctrl-a`. The section is named `[tui]` for history — it is the leader for
+every client, not the TUI's alone.
+
+The leader itself needs the same kind of way back: holding it consumes every
+press, on both clients, even before anything is bound behind it. Pressing it
+twice — `ctrl-a ctrl-a` by default — sends one literal leader byte to the
+focused pane and clears the pending chord, the way tmux resolves a doubled
+prefix key. This chord is also built from the configured leader, so a
+rebound leader carries its own escape hatch with it.
+
+Only Ctrl-K and the leader itself get an escape hatch. No other control
+character is intercepted, so none of them needs one.
 
 ### Focus round-trip
 
@@ -110,9 +123,9 @@ client opening `/api/attach/:id`, and a client reporting focus explicitly at
 `POST /api/sessions/:id/focus` when it refocuses a pane that is already open.
 
 **A session that has never been focused sorts after every session that has**,
-and among those, most recently created first. Dead sessions sort after live
-ones regardless of recency: a session you cannot attach to is not where you
-just were.
+and among those, most recently created first. Sessions with no live pane —
+`Dead`, and `Dormant` (#162) — sort after live ones regardless of recency: a
+session you cannot attach to is not where you just were.
 
 Under `>` an empty query lists every command in registry order. Under `~` it
 lists recent dirs, most recent first, then the project list.
@@ -145,12 +158,12 @@ searchable — the query line keeps working, now over those actions.
   ambiguous.
 - Escape, or backspace at an empty query, returns to the result list **with the
   previous query intact**. Drilling in and backing out is free.
-- Each action raises the flow it already has: kill goes through the existing
-  confirm-and-blockers dialog (`docs/WORKTREES.md`), rename through the
-  existing prompt pre-filled with the session's own name
-  (`docs/SIDEBAR.md`), spawn similar through the spawn form seeded from the
-  session's directory and command. The bar picks the action; it never
-  reimplements one.
+- Each action raises the flow it already has: kill through the confirmation
+  both clients ask for (`docs/SIDEBAR.md`) and the blockers dialog behind it
+  (`docs/WORKTREES.md`), rename through the existing prompt pre-filled with the
+  session's own name (`docs/SIDEBAR.md`), spawn similar through the spawn form
+  seeded from the session's directory and command. The bar picks the action; it
+  never reimplements one.
 
 No actions beyond those three, and no action across more than one session.
 

docs/INSTALL.md

@@ -136,7 +136,8 @@ cover every v1 action — only override what you want to change:
 ```toml
 [tui]
 theme = "dark"              # see the theme list below
-leader = "ctrl-a"            # one byte that escapes Insert mode
+leader = "ctrl-a"            # one byte that escapes Insert mode; the web reads
+                             # the same setting off /api/info
 chord_timeout_ms = 1000      # how long to hold a partial chord like `ctrl-w`
 
 [tui.keymap.normal]
@@ -242,6 +243,26 @@ Pick `/tmp` if the daemon must outlive your login session and you can't run
 tmux sockets with it). The env var `MAESTRO_DAEMON_TMUX_TMPDIR` takes
 precedence over the file.
 
+## What happens to sessions after a reboot
+
+A host reboot kills the tmux server, so every session the daemon knew is dead
+while its record on disk survives. What recovery does with those is
+`[daemon].resume_on_boot`:
+
+```toml
+[daemon]
+resume_on_boot = "dormant"   # "dormant" (default) | "auto" | "never"
+```
+
+- `dormant` — the sessions are listed but not running, and you resume the ones
+  you want from the web UI or the TUI.
+- `auto` — the daemon resumes them all itself during startup. Only pick this
+  on a host where restarting every agent unattended is safe: they come back on
+  the flags they were spawned with, with nobody watching.
+- `never` — the records are deleted and a reboot is a clean slate.
+
+See `docs/RESTART.md` for the full contract.
+
 ## What the systemd unit looks like
 
 The wizard writes a *user* unit (`systemctl --user`), since `maestro daemon`

docs/PREVIEW.md

@@ -28,6 +28,12 @@ A preview is a view, not a state. Nothing about it is durable:
 | Already in a pane, in another tab | That tab is brought forward. The active tab is restored when the preview ends. |
 | Not in any pane | A throwaway tab carries it. It is removed when the preview ends. |
 
+A session that is not `Running` — a dormant one, most often — never gets a
+live attach here or anywhere else a pane is filled: the daemon has nothing to
+answer a `409 not_attachable` and the socket would just die (WS close 1006).
+Its pane shows the same metadata-and-resume view `docs/SIDEBAR.md` describes
+for its card, honest about the fact that there is nothing to preview yet.
+
 The throwaway tab never counts as an open session: the tab bar does not appear
 because of it, the mobile shell does not switch away from the session list for
 it, and the sidebar does not mark the session as open.
@@ -46,7 +52,8 @@ Web client (`--preview` and friends in `web/src/styles.css`):
 | The previewed pane's titlebar | Tinted in the preview hue, at full strength, in place of the focused pane's accent tint. |
 | The canvas | A `preview` chip, top right, and a dashed inset ring. |
 | A throwaway tab | Dashed border, italic label. |
-| The sidebar row being previewed | Filled with the preview hue, over whatever open/focused state the row already had. |
+| The sidebar row being previewed | Filled with the preview hue, over whatever open state the row already had — but the row of the session already showing in the pane keeps its accent fill, since previewing it changes nothing on screen. |
+| The sidebar row of the session the operator picked | Keeps its accent fill for the whole preview. A preview never moves the accent; only opening another session does. |
 | A hovered sidebar row, and the keyboard cursor on a session | A lighter wash of the same hue, because both are what previews a row. |
 
 Rows say it with fill, not with an edge — see the tier ladder in

docs/RESTART.md

@@ -68,6 +68,116 @@ resolves, so a blocked client is never a trapped one. It clears itself the
 moment a probe succeeds — there is no "retry" button, because the client is
 already retrying.
 
+## What survives, and what comes back dormant
+
+A daemon restart leaves tmux alone, so recovery re-adopts every
+`maestro-<uuid>` session tmux still holds and the operator sees no change
+beyond the reconnect above.
+
+A **host reboot** is different: it kills the tmux server, so there is nothing
+to adopt while every session's sidecar is still on disk. Recovery always asks
+tmux — `tmux list-sessions` is the single source of truth for liveness, and the
+kernel's `boot_id` only tells a reboot from a restart in the log (#164, #174).
+A boot id changes without the tmux server dying whenever the state directory is
+restored, a VM or container snapshot is rolled back, or the `boot_id` file is
+truncated; a session tmux still holds is adopted `Running` in every one of
+those cases. Recovery makes a
+second pass over those sidecars and registers each as a `Dormant` session
+(#162) — id, name, cwd, command, worktree and `created_at` intact. A dormant
+session has no pane and no PTY bridge: it cannot be attached to, typed into or
+resized, and neither watcher pass touches it.
+
+A dormant session is brought back with `POST /api/sessions/:id/resume` (#166),
+which respawns tmux under the **same** uuid and sidecar — `metadata.name`,
+`created_at`, `env` and worktree ownership all survive, and only the tmux
+session and the PTY bridge are new. The command is the matching spawn preset's
+`resume_command` with `{agent_session}` filled in from the session's own
+`agent_session_id`, so an agent comes back inside its old conversation; a
+session with no matching preset, no `resume_command`, or no reported
+conversation id is respawned on the command it was created with. `Session::command`
+always keeps that original command, so a second resume resolves the same preset.
+Resume is refused with `409` for a session that is already running
+(`already_running`) and for one whose `cwd` has disappeared (`cwd_missing`) —
+neither is something a respawn could fix. A session with a resume already in
+flight is refused as `already_running` too (#175): the respawn happens with
+the session map unlocked, so the record is marked in-flight before it starts
+and the second request is answered on that state rather than on its tmux spawn
+colliding with the first one's. A resume that loses a race with a kill takes
+its own sidecar back off disk, so the killed session does not return as a
+dormant ghost on the next recovery. The other thing to do with a dormant
+session is dismiss it, which removes the sidecar so the next recovery does not
+bring it back.
+
+## What the pane looks like when it comes back
+
+The PTY replay ring lives in memory, so a resumed session would otherwise open
+on a blank pane: the conversation is back, the terminal history the operator
+was reading is not. Each bridge's ring is mirrored to
+`<state_dir>/scrollback/<id>.bin` (#171) and handed to the new bridge on
+resume, and on the recovery pass that re-adopts a session tmux still holds —
+that one lost its ring with the previous daemon too. The restored bytes go out
+ahead of the live ones, and are dropped once the ring holds a full budget of
+new output of its own, which is the point where everything restored is older
+than the budget covers.
+
+The file is capped at the same `[daemon] pty_replay_bytes` budget the ring
+uses — one budget, not two — and it is deleted when the session is killed, and
+when recovery prunes its sidecar. Nothing here can fail a resume: a missing,
+unreadable or oversized file degrades to an empty pane, which is exactly what
+the operator had before it existed.
+
+It is flushed every 10 seconds by the liveness watcher, and once more when a
+session's bridge is sealed on exit. The timer is the part that matters: a host
+reboot runs no exit path at all, so scrollback written only on a clean shutdown
+would be missing in the one case this exists for. Ten seconds bounds the loss
+to the last few lines — scrollback is visual continuity, not state — and costs
+at most one file write per *active* session per tick, since a session whose
+bridge has read nothing since the last flush is skipped.
+
+## What recovery does with them: `resume_on_boot`
+
+Whether a recovered-but-dead session is left dormant at all is the operator's
+call, per host, via `[daemon].resume_on_boot` (#167):
+
+| value       | what recovery does                                                    |
+| ----------- | --------------------------------------------------------------------- |
+| `"dormant"` | **Default.** Register each one dormant and wait for the operator.      |
+| `"auto"`    | Resume each one during recovery, itself.                               |
+| `"never"`   | Prune the sidecars instead — a reboot is a clean slate.                |
+
+`dormant` is the default because resuming agents unattended is a foot-gun:
+they come back on whatever flags they were spawned with, seconds after a
+reboot, with nobody watching. `auto` exists for hosts where that is known to
+be safe, and it is opted into rather than inherited.
+
+`auto` calls the same `resume` the client's `POST /api/sessions/:id/resume`
+does — same uuid, same sidecar, the preset's `resume_command` — so there is
+one resume path and not two. A session that fails to resume is logged and
+stays dormant; the rest still come back.
+
+`never` prunes the same way #163 does for a missing `cwd`: the sidecar is
+deleted and nothing is registered, so the session is not listed and the next
+recovery does not find it. Whatever worktree it owned is left on disk.
+
+The policy only decides the fate of sessions with no live pane. A session
+tmux still holds is adopted `Running` by the first pass under every policy,
+including `never`.
+
+Recovery logs the policy that ran and the number of sessions it acted on, so
+a host that resumes agents unattended says so in its own journal.
+
+Attaching to a session that has no bridge answers `409 not_attachable`, not
+`404 unknown_session`: the session exists, and a client that cannot tell "gone"
+from "not running" cannot offer the resume.
+
+`SessionStatus` is a wire type, so from this build forward it deserializes
+leniently on both clients: a spelling the client does not know reads as `Dead`
+rather than failing the whole session. That leniency lives in the client's own
+binary, so it covers spellings added *after* this build, not this one — a CLI
+or TUI still running an older build fails to parse a `Dormant` session, and
+with it the whole session list, until it is upgraded. Clients render a dormant session as known-but-not-running —
+see `docs/SIDEBAR.md` for the card and `docs/COMMAND-BAR.md` for how it ranks.
+
 ## Timing
 
 - **Grace window** — 1200 ms between the socket dropping and the overlay

docs/SIDEBAR.md

@@ -56,7 +56,7 @@ itself is not.
 Line 2 reads left to right:
 
 ```
-[<duration>] [<detail>] <command> [<diff stat> | exited]
+[<duration>] [<detail>] <command> [<diff stat> | exited | dormant]
 ```
 
 Its minimum content is therefore just the command.
@@ -104,8 +104,41 @@ fragment; it no longer decides whether line 2 exists.
 while an agent-reported state is in force (see Precedence): when the report
 lapses at its TTL or is replaced, the detail goes with it. The detail
 truncates with `…` ahead of the trailing fragments — a long detail never
-pushes `<command>`, `<blocked work>`, or `exited` off the line, and neither
-client ever lets it wrap.
+pushes `<command>`, `<blocked work>`, `exited` or `dormant` off the line, and
+neither client ever lets it wrap.
+
+`dormant` (#162) is the counterpart of `exited` for a session the daemon knows
+only from its sidecar: recovery found no tmux session behind it, so it has no
+pane, no scrollback, and nothing to attach to. It is not an exit — nothing was
+observed ending — so the two fragments never both show. The TUI marks the same
+state on line 1 with `◌`, next to `✗` for exited and `●`/`○` for running.
+
+### Dormant cards (#168)
+
+A dormant card is a muted variant of the normal card (the web client's
+`is-dormant` class, the same muted foreground `exited` already uses): name,
+cwd and last-known age render as usual, but the activity rail carries no
+colour, since recovery resets a dormant session's activity to `Idle` and
+there is nothing running to report otherwise.
+
+The row's right-hand actions swap **spawn similar** for **resume** (↻) — there
+is no live state to clone from — and call `POST /api/sessions/:id/resume`
+(#166). **Kill** stays: it is how a dormant session is dismissed, since the
+daemon already treats a kill of a dormant session as removing its sidecar
+rather than anything it needs to be running to do.
+
+A dormant session takes the **lowest precedence in the ordering**: within a
+folder, every live (`Running` or `Dead`) session sorts before every dormant
+one, name notwithstanding, and dormant sessions sort among themselves by name.
+So a reboot that leaves a whole tree dormant never buries the live work a
+session spawns into it.
+
+Selecting a dormant session — by click, by keyboard, or by preview
+(`docs/PREVIEW.md`) — never opens a live attach: the content pane shows the
+same metadata and resume affordance the card does, rather than a terminal
+that would die on the daemon's `409 not_attachable` (WS close 1006). Resuming
+turns the session `Running`; the pane and the card pick that up on their own
+next update, no navigation required.
 
 `<diff stat>` is the blocked-work breakdown (#83) in diff notation, replacing
 the spelled-out `⚠ 3 uncommitted files, 2 unpushed commits`. It renders only
@@ -189,7 +222,7 @@ furthest down wins the paint.
 | Under the pointer or the keyboard walk | preview hue, light | selection surface, while the sidebar holds the keyboard |
 | Open in some pane, not the focused one | 6% accent wash (`.is-open`) | — (the `●` glyph carries it) |
 | Showing in the pane | `--accent-fill` | `pane_row_bg()` — partway from the card surface to the selection surface |
-| Previewing (`docs/PREVIEW.md`) | `--preview-tint` | — (no preview colour role yet) |
+| Previewing (`docs/PREVIEW.md`), unless that row is the one showing in the pane | `--preview-tint` | — (no preview colour role yet) |
 
 The web ladder is written as one ordered run of equal-specificity rules in
 `styles.css`, every qualifier inside `:where()`, so the order they appear in
@@ -209,7 +242,7 @@ the cursor's fill while the pane holds the keyboard, and the web's ring on a
 highlighted **folder** row — a folder previews nothing, so it has no fill to
 step up to.
 
-The duration text inherits its state's colour; the exited and command
+The duration text inherits its state's colour; the exited, dormant and command
 fragments use the surface's `muted` role, as do the diff stat's `~`, `?` and
 `↑` fragments. Only `+` and `-` step outside the surface's muted role, and they
 take the `active` and `error` roles of the same surface.
@@ -316,7 +349,7 @@ Everything else is the same key on both clients:
 | `Tab`   | hand the keyboard to the pane               |
 | `c`     | collapse or expand the highlighted folder   |
 | `r`     | rename the highlighted session              |
-| `x`     | kill the highlighted session                |
+| `x`     | kill the highlighted session (confirms)     |
 | `n`     | open the spawn form                         |
 | `N`     | spawn with every default resolved           |
 | `?`     | show the shortcut overlay                   |
@@ -324,3 +357,18 @@ Everything else is the same key on both clients:
 The TUI binds these through its keymap, so a user can rebind any of them; the
 web client's are fixed. A binding added to one client belongs in this table and
 in both help overlays.
+
+## Killing a session
+
+**Every kill confirms first, in both clients** (#160). A kill is destructive
+and unattended agents live in these sessions, so neither client sends
+`DELETE /api/sessions/:id` off a single press. The TUI raises
+`OverlayKind::KillConfirm` (`[y]`/`[n]`); the web raises the same dialog its
+`✕` button and the command bar's action page both use. Cancel holds the focus
+in the web's dialog, so nothing kills on a stray Enter.
+
+The confirmation names what the card last saw in the way, when anything was —
+the daemon will refuse an unforced kill over such a worktree, and saying so
+before the attempt is cheaper than a refusal. What comes back from that refusal
+is a second, separate prompt offering `force=true`; `docs/WORKTREES.md` owns
+what a forced kill leaves behind.

web/src/api.ts

@@ -91,6 +91,18 @@ export async function killSession(id: Uuid, force = false): Promise<void> {
   );
 }
 
+/** Respawn a dormant session under its own uuid and sidecar (#166/#168).
+ * Refused with `409` (`already_running` / `cwd_missing`) when there is
+ * nothing a respawn could fix. */
+export async function resumeSession(id: Uuid): Promise<Session> {
+  return jsonOrError(
+    await fetch(routes.sessionResume(id), {
+      method: "POST",
+      credentials: "same-origin",
+    }),
+  );
+}
+
 /** Report whether this client's pane is the one currently showing `id` — not
  * merely highlighted in a sidebar. The daemon uses this to clear an
  * `AwaitingInput` glow once the pane has been looked at long enough

web/src/attach.ts

@@ -65,9 +65,17 @@ export interface AttachOptions {
    *  dropped — but NOT on an intentional `dispose()` (eviction / user close). The
    *  shell uses this to auto-close the pane rather than leave a dead one. */
   onClosed?: (sessionId: Uuid) => void;
+  /** Invoked when the handshake itself never completed — no retry was
+   *  attempted (see `shouldReconnect`'s `everOpened`). Unlike `onClosed`, this
+   *  is not "the session is gone": it is at least as likely a dormant
+   *  session's `409 not_attachable` caught mid-status-update (#168 review).
+   *  The shell re-renders rather than tearing the pane's leaf out, so a
+   *  dormant session's resume affordance can take over in place. */
+  onNeverAttached?: (sessionId: Uuid) => void;
   /** Asked on every close: should the socket be retried? The shell answers
-   *  from the catalog — see `shouldRetryClose`. */
-  shouldReconnect?: (sessionId: Uuid, code: number) => boolean;
+   *  from the catalog — see `shouldRetryClose`. `everOpened` is false when
+   *  this attempt never reached `open`. */
+  shouldReconnect?: (sessionId: Uuid, code: number, everOpened: boolean) => boolean;
 }
 
 /** What the header shows about the session (name / command). Optional — falls
@@ -379,6 +387,10 @@ export function createAttachConnection(
   let ws: WebSocket;
   let reconnectMs = INITIAL_RECONNECT_MS;
   let reconnectTimer: number | null = null;
+  // #168 review: a fresh attempt that never reaches `open` is a rejected
+  // handshake (dormant/unknown session), not a dropped stream — see
+  // `shouldRetryClose`'s `everOpened` param.
+  let everOpened = false;
 
   const sendControl = (msg: ClientControl) => {
     if (ws.readyState !== WebSocket.OPEN) return;
@@ -402,6 +414,7 @@ export function createAttachConnection(
     ws.binaryType = "arraybuffer";
 
     ws.onopen = () => {
+      everOpened = true;
       reconnectMs = INITIAL_RECONNECT_MS;
       setState("connected", "open");
       sendControl({ type: "Resize", cols: term.cols, rows: term.rows });
@@ -444,7 +457,7 @@ export function createAttachConnection(
       // close handle their own pane teardown.
       if (disposed) return;
 
-      if (opts.shouldReconnect?.(sessionId, ev.code)) {
+      if (opts.shouldReconnect?.(sessionId, ev.code, everOpened)) {
         const delay = Math.min(reconnectMs, MAX_RECONNECT_MS);
         setState("reconnecting…", "connecting");
         reconnectTimer = window.setTimeout(() => {
@@ -455,6 +468,12 @@ export function createAttachConnection(
         return;
       }
 
+      if (!everOpened) {
+        setState("not attached", "closed");
+        opts.onNeverAttached?.(sessionId);
+        return;
+      }
+
       setState(`closed (${ev.code})`, "closed");
       opts.onClosed?.(sessionId);
     };

web/src/barActions.test.ts

@@ -65,7 +65,7 @@ async function flush(): Promise<void> {
 }
 
 describe("kill from the action page", () => {
-  it("goes through the daemon, without a first confirmation", async () => {
+  it("goes through the same confirmation the sidebar raises (#160)", async () => {
     const calls: string[] = [];
     window.fetch = ((url: string, init?: RequestInit) => {
       calls.push(`${init?.method ?? "GET"} ${url}`);
@@ -75,6 +75,12 @@ describe("kill from the action page", () => {
     mount(s);
     raise(KILL_SESSION_EVENT, s);
     await flush();
+    expect(document.querySelector(".kill-dialog")?.getAttribute("aria-label")).toBe(
+      "Kill amber-falcon",
+    );
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
     expect(calls).toContain(`DELETE /api/sessions/${s.id}`);
     expect(document.querySelector(".kill-dialog")).toBeNull();
   });
@@ -101,6 +107,8 @@ describe("kill from the action page", () => {
     mount(s);
     raise(KILL_SESSION_EVENT, s);
     await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
     const dialog = document.querySelector(".kill-dialog");
     expect(dialog?.getAttribute("aria-label")).toBe("Kill amber-falcon");
     expect(dialog?.textContent).toContain("1 untracked file");

web/src/catalog.test.ts

@@ -98,7 +98,7 @@ describe("blocked-work indicator (#83)", () => {
     expect(rowFor(el, unprobed.id)?.querySelector(".leaf-blocked")).toBeNull();
   });
 
-  it("kills straight away, without a first confirmation", async () => {
+  it("confirms before an unguarded kill (#160)", async () => {
     const calls: string[] = [];
     window.fetch = ((url: string, init?: RequestInit) => {
       calls.push(`${init?.method ?? "GET"} ${url}`);
@@ -108,10 +108,45 @@ describe("blocked-work indicator (#83)", () => {
     const el = renderSidebar(storeWith([plain])).el;
     rowFor(el, plain.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
     await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.getAttribute("aria-label")).toBe("Kill claude");
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+    dialog?.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
     expect(calls).toContain(`DELETE /api/sessions/${plain.id}`);
     expect(document.querySelector(".kill-dialog")).toBeNull();
   });
 
+  it("kills nothing when the confirmation is cancelled (#160)", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(new Response(null, { status: 204 }));
+    }) as typeof fetch;
+    const plain = session({ id: "aaaaaaaa-0000-0000-0000-000000000007" });
+    const el = renderSidebar(storeWith([plain])).el;
+    rowFor(el, plain.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-cancel")?.click();
+    await flush();
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+  });
+
+  it("names the blockers in the confirmation, before the daemon refuses (#160)", async () => {
+    window.fetch = (() => Promise.reject(new Error("never called"))) as typeof fetch;
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000008",
+      blocked_work: { untracked_files: 1 },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.textContent).toContain("1 untracked file");
+    expect(dialog?.textContent).toContain("refused unless it is forced");
+  });
+
   it("offers the override when the daemon refuses a guarded kill", async () => {
     const calls: string[] = [];
     window.fetch = ((url: string, init?: RequestInit) => {
@@ -138,6 +173,8 @@ describe("blocked-work indicator (#83)", () => {
     const el = renderSidebar(storeWith([blocked])).el;
     rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
     await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
     const dialog = document.querySelector(".kill-dialog");
     expect(dialog?.textContent).toContain("1 untracked file");
     dialog?.querySelector<HTMLButtonElement>(".kill-dialog-force")?.click();
@@ -166,6 +203,8 @@ describe("blocked-work indicator (#83)", () => {
     const el = renderSidebar(storeWith([blocked])).el;
     rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
     await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
     document.querySelector<HTMLButtonElement>(".kill-dialog-cancel")?.click();
     expect(document.querySelector(".kill-dialog")).toBeNull();
     expect(calls.filter((c) => c.includes("force=true"))).toHaveLength(0);
@@ -375,6 +414,57 @@ describe("session cards (#107)", () => {
     expect(line2?.textContent).toContain("exited");
   });
 
+  // #162: a session recovered with no tmux behind it is known but not running,
+  // and never reads as something that exited.
+  it("shows dormant on line 2 for dormant sessions", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000118",
+      status: "Dormant",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.textContent).toContain("dormant");
+    expect(line2?.textContent).not.toContain("exited");
+  });
+
+  // #168: a dormant card is a muted variant with a resume action in place of
+  // "spawn similar", since there is nothing running to clone from live state.
+  it("renders a dormant card muted, with a resume action instead of spawn-similar", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(
+        new Response(JSON.stringify({ id: "aaaaaaaa-0000-0000-0000-000000000120", status: "Running" }), {
+          status: 200,
+        }),
+      );
+    }) as typeof fetch;
+    const s = session({ id: "aaaaaaaa-0000-0000-0000-000000000120", status: "Dormant" });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLElement;
+    expect(row.classList.contains("is-dormant")).toBe(true);
+    expect(row.querySelector(".leaf-clone")).toBeNull();
+    const resumeBtn = row.querySelector<HTMLButtonElement>(".leaf-resume");
+    expect(resumeBtn).toBeTruthy();
+    resumeBtn?.click();
+    await flush();
+    expect(calls).toContain(`POST /api/sessions/${s.id}/resume`);
+  });
+
+  // #168: a two-way running/dead test made a dormant card lie to screen
+  // readers — the visible flag says dormant, the aria-label said "exited".
+  it("marks a dormant row's status and aria-label distinctly from dead", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000119",
+      status: "Dormant",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLElement;
+    expect(row.dataset.status).toBe("dormant");
+    expect(row.getAttribute("aria-label")).toContain("dormant");
+    expect(row.getAttribute("aria-label")).not.toContain("exited");
+  });
+
   it("carries the state word only in tooltips and aria labels, never as text", () => {
     const s = session({
       id: "aaaaaaaa-0000-0000-0000-000000000019",

web/src/catalog.ts

@@ -1,6 +1,6 @@
 import { escapeHtml } from "./html.js";
-import { ApiRequestError, getDaemonInfo, killSession, renameSession } from "./api.js";
-import { openForceKillDialog } from "./killDialog.js";
+import { ApiRequestError, getDaemonInfo, killSession, renameSession, resumeSession } from "./api.js";
+import { openForceKillDialog, openKillConfirmDialog } from "./killDialog.js";
 import { openContextMenu } from "./contextMenu.js";
 import { toggleHelp } from "./help.js";
 import { CommandSet, defineCommands } from "./commands.js";
@@ -39,6 +39,15 @@ export function requestOpenSpawn(): void {
   document.dispatchEvent(new CustomEvent(OPEN_SPAWN_EVENT));
 }
 
+/** Ask the shell to open the command bar with an empty query. Dispatched by
+ *  the sidebar's search field, which is the touch entry point to the bar
+ *  (#157, docs/COMMAND-BAR.md "Touch entry"): there is no `ctrl-k` on a phone.
+ *  Handled in main.ts, which owns the session snapshot the bar needs. */
+export const OPEN_COMMAND_BAR_EVENT = "catalog-open-command-bar";
+export function requestOpenCommandBar(): void {
+  document.dispatchEvent(new CustomEvent(OPEN_COMMAND_BAR_EVENT));
+}
+
 /** Ask the shell to hand the keyboard back to the focused pane's terminal —
  *  what Tab in the sidebar list does. Handled in main.ts, which owns the
  *  connection pool. */
@@ -95,6 +104,21 @@ const STATE_WORDS: Record<string, string> = {
   error: "Error",
 };
 
+// #168: dormancy is not an exit (docs/SIDEBAR.md), so `dataset.status` and
+// the aria-label read the session's own three-way `status` rather than a
+// two-way running/dead test that folded `Dormant` into "dead"/"exited".
+function statusSlug(status: Session["status"]): string {
+  if (status === "Running") return "running";
+  if (status === "Dormant") return "dormant";
+  return "dead";
+}
+
+function statusWord(status: Session["status"]): string {
+  if (status === "Running") return "running";
+  if (status === "Dormant") return "dormant";
+  return "exited";
+}
+
 /** docs/SIDEBAR.md: the activity rail is pinned to the row's own left edge,
  * full height. The row's own padding (`renderNode`) shifts outward with
  * nesting depth, carrying the rail with it. */
@@ -104,6 +128,9 @@ function activityRailMarkup(slug: string, stateWord: string): string {
 
 function metaLine(s: Session, now: number): string {
   const dead = s.status === "Dead";
+  // #162: known from its sidecar with nothing running behind it — a distinct
+  // fragment, since it never exited.
+  const dormant = s.status === "Dormant";
   const blockers = sessionBlockers(s);
   const slug = activityColorSlug(s.activity ?? "Idle");
   const held = activityHeldMs(s.activity_since, now);
@@ -118,6 +145,7 @@ function metaLine(s: Session, now: number): string {
     commandFragment(s.command),
     blockers ? blockedFragment(blockers) : "",
     dead ? `<span class="card-flag">exited</span>` : "",
+    dormant ? `<span class="card-flag">dormant</span>` : "",
   ];
   return `<span class="card-line2" data-activity="${slug}">${fragments.join("")}</span>`;
 }
@@ -190,38 +218,51 @@ function renderNode(node: TreeNode, depth: number): HTMLElement {
   row.style.paddingLeft = `${depth * 16 + 8}px`;
   row.dataset.sessionId = s.id;
   row.dataset.navKey = `session:${s.id}`;
-  const running = s.status === "Running";
-  row.dataset.status = running ? "running" : "dead";
+  row.dataset.status = statusSlug(s.status);
+  // docs/SIDEBAR.md: a dormant card is a muted variant — nothing running
+  // behind it, so it earns no activity colour or spawn-similar affordance.
+  const dormant = s.status === "Dormant";
+  row.classList.toggle("is-dormant", dormant);
   const name = sessionName(s);
   const slug = activityColorSlug(s.activity ?? "Idle");
   const stateWord = STATE_WORDS[slug] ?? STATE_WORDS.idle;
-  row.setAttribute(
-    "aria-label",
-    `${name}, ${running ? "running" : "exited"}, ${stateWord}`,
-  );
+  row.setAttribute("aria-label", `${name}, ${statusWord(s.status)}, ${stateWord}`);
+  const cloneOrResumeAction = dormant
+    ? `<button class="leaf-act leaf-resume" type="button" title="Resume session" aria-label="Resume ${escapeHtml(name)}">↻</button>`
+    : `<button class="leaf-act leaf-clone" type="button" title="Spawn similar" aria-label="Spawn similar to ${escapeHtml(name)}">⧉</button>`;
   // docs/SIDEBAR.md: line 1 reserves action width, and line 2 is unconditional.
   row.innerHTML = `
     ${activityRailMarkup(slug, stateWord)}
     <span class="card-line1">
       <span class="leaf-name${isProvisionalName(s) ? " is-provisional" : ""}">${escapeHtml(name)}</span>
       <span class="leaf-actions">
-        <button class="leaf-act leaf-clone" type="button" title="Spawn similar" aria-label="Spawn similar to ${escapeHtml(name)}">⧉</button>
+        ${cloneOrResumeAction}
         <button class="leaf-act leaf-kill" type="button" title="Kill session" aria-label="Kill ${escapeHtml(name)}">✕</button>
       </span>
     </span>
     ${metaLine(s, now)}
   `;
-  const similarBtn = row.querySelector(".leaf-clone") as HTMLButtonElement;
-  similarBtn.addEventListener("click", (ev) => {
+  const similarBtn = row.querySelector<HTMLButtonElement>(".leaf-clone");
+  similarBtn?.addEventListener("click", (ev) => {
     ev.preventDefault();
     ev.stopPropagation();
     document.dispatchEvent(new CustomEvent(SPAWN_SIMILAR_EVENT, { detail: cur }));
   });
+  const resumeBtn = row.querySelector<HTMLButtonElement>(".leaf-resume");
+  resumeBtn?.addEventListener("click", (ev) => {
+    ev.preventDefault();
+    ev.stopPropagation();
+    resumeBtn.disabled = true;
+    void resumeSession(cur.id).catch((e: Error) => {
+      resumeBtn.disabled = false;
+      alert(`Failed to resume: ${e.message}`);
+    });
+  });
   const killBtn = row.querySelector(".leaf-kill") as HTMLButtonElement;
   killBtn.addEventListener("click", (ev) => {
     ev.preventDefault();
     ev.stopPropagation();
-    void requestKill(cur, sessionName(cur));
+    requestKill(cur, sessionName(cur));
   });
   row.addEventListener("click", () => {
     document.dispatchEvent(new CustomEvent(SESSION_SELECT_EVENT, { detail: cur.id }));
@@ -231,15 +272,23 @@ function renderNode(node: TreeNode, depth: number): HTMLElement {
     ev.stopPropagation();
     openContextMenu(ev.clientX, ev.clientY, [
       { label: "Rename…", onSelect: () => beginRename(row, cur) },
-      {
-        label: "Spawn similar",
-        onSelect: () =>
-          document.dispatchEvent(new CustomEvent(SPAWN_SIMILAR_EVENT, { detail: cur })),
-      },
+      cur.status === "Dormant"
+        ? {
+            label: "Resume",
+            onSelect: () =>
+              void resumeSession(cur.id).catch((e: Error) =>
+                alert(`Failed to resume: ${e.message}`),
+              ),
+          }
+        : {
+            label: "Spawn similar",
+            onSelect: () =>
+              document.dispatchEvent(new CustomEvent(SPAWN_SIMILAR_EVENT, { detail: cur })),
+          },
       {
         label: "Kill session",
         danger: true,
-        onSelect: () => void requestKill(cur, sessionName(cur)),
+        onSelect: () => requestKill(cur, sessionName(cur)),
       },
     ]);
   });
@@ -247,10 +296,8 @@ function renderNode(node: TreeNode, depth: number): HTMLElement {
     cur = next;
     const nextSlug = activityColorSlug(next.activity ?? "Idle");
     const nextWord = STATE_WORDS[nextSlug] ?? STATE_WORDS.idle;
-    row.setAttribute(
-      "aria-label",
-      `${sessionName(next)}, ${next.status === "Running" ? "running" : "exited"}, ${nextWord}`,
-    );
+    row.dataset.status = statusSlug(next.status);
+    row.setAttribute("aria-label", `${sessionName(next)}, ${statusWord(next.status)}, ${nextWord}`);
     const rail = row.querySelector(".activity-rail");
     if (rail) rail.outerHTML = activityRailMarkup(nextSlug, nextWord);
     const meta = row.querySelector(".card-line2");
@@ -284,26 +331,33 @@ function treeSignature(node: TreeNode): string {
 }
 
 /**
- * Kill on the first click (#81): the daemon is the one that decides whether a
- * session may go, and it refuses over a worktree holding unsaved work. Only
- * that refusal is worth a prompt, and it needs one `confirm()` cannot give —
- * a forced kill. Anything else surfaces as an alert.
+ * Kill behind a confirmation (#160): a kill is destructive and unattended
+ * agents live in these sessions, so the web asks first, the way the TUI always
+ * has. The daemon decides the rest — it refuses a kill over a worktree holding
+ * unsaved work, and that refusal needs a prompt the confirmation cannot give,
+ * a forced kill. Anything else surfaces in the dialog that asked.
  */
-async function requestKill(s: Session, name: string): Promise<void> {
-  try {
-    await killSession(s.id);
-  } catch (e) {
-    if (e instanceof ApiRequestError && e.code === "kill_guarded") {
-      openForceKillDialog({
-        name,
-        blockers: e.unsavedWork ?? sessionBlockers(s),
-        reason: e.detail,
-        onForce: () => killSession(s.id, true),
-      });
-      return;
-    }
-    alert(`Failed to kill: ${(e as Error).message}`);
-  }
+function requestKill(s: Session, name: string): void {
+  openKillConfirmDialog({
+    name,
+    blockers: sessionBlockers(s),
+    onKill: async () => {
+      try {
+        await killSession(s.id);
+      } catch (e) {
+        if (e instanceof ApiRequestError && e.code === "kill_guarded") {
+          openForceKillDialog({
+            name,
+            blockers: e.unsavedWork ?? sessionBlockers(s),
+            reason: e.detail,
+            onForce: () => killSession(s.id, true),
+          });
+          return;
+        }
+        throw e;
+      }
+    },
+  });
 }
 
 /**
@@ -361,16 +415,12 @@ function beginRename(row: HTMLElement, s: Session): void {
   input.select();
 }
 
-function renderEmpty(filtering: boolean, onSpawn: () => void): HTMLElement {
+// The tree has one empty state: no sessions at all. The old "No matches" one
+// belonged to the inline substring filter, which the command bar replaced
+// (#157) — the bar's own no-results state took over with it.
+function renderEmpty(onSpawn: () => void): HTMLElement {
   const el = document.createElement("div");
   el.className = "empty";
-  if (filtering) {
-    el.innerHTML = `
-      <div class="empty-glyph" aria-hidden="true">⌕</div>
-      <div class="empty-title">No matches</div>
-      <p class="empty-hint">No sessions match your search. Clear it to see everything.</p>`;
-    return el;
-  }
   el.innerHTML = `
     <div class="empty-glyph" aria-hidden="true">+</div>
     <div class="empty-title">No sessions yet</div>
@@ -441,12 +491,16 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
   // renders with absolute paths until it lands.
   let homeDir: string | undefined;
 
+  // The field never holds a query: it is the touch entry point to the command
+  // bar (#157), so it is `readonly` — a tap opens the bar instead of raising an
+  // on-screen keyboard over a field nothing is typed into.
   const searchHeader = document.createElement("header");
   searchHeader.className = "sidebar-search";
   searchHeader.innerHTML = `
     <input
       type="search"
       class="search"
+      readonly
       placeholder="Search sessions…"
       aria-label="Search sessions"
       autocomplete="off"
@@ -555,11 +609,23 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
   handle.addEventListener("pointerup", endDrag);
   handle.addEventListener("pointercancel", endDrag);
 
+  // Touch entry (#157): the field is a button that looks like a field. It
+  // never holds a query — focusing or tapping it hands the keyboard straight
+  // to the bar's own input, which is also why it blurs first: leaving the
+  // focus here would make the bar impossible to close without reopening it.
   const search = searchHeader.querySelector(".search") as HTMLInputElement;
-  let filter = "";
-  search.addEventListener("input", () => {
-    filter = search.value;
-    refresh();
+  const openBar = () => {
+    search.value = "";
+    search.blur();
+    requestOpenCommandBar();
+  };
+  search.addEventListener("focus", openBar);
+  // A tap can land without a focus event (iOS Safari on a blurred field), so
+  // the pointer path opens the bar too; the blur above keeps the two from
+  // stacking two overlays.
+  search.addEventListener("pointerdown", (e) => {
+    e.preventDefault();
+    openBar();
   });
 
   let highlights: SidebarHighlights = { open: new Set(), focused: null };
@@ -698,7 +764,7 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
       },
       "list.kill": () => {
         const hit = highlightedSession();
-        if (hit) void requestKill(hit.session, sessionName(hit.session));
+        if (hit) requestKill(hit.session, sessionName(hit.session));
       },
       "list.focusPane": () => document.dispatchEvent(new CustomEvent(FOCUS_PANE_EVENT)),
     }),
@@ -716,8 +782,8 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
     if (renamingId !== null) return;
     const state = store.snapshot();
     const sessions = [...state.sessions.values()];
-    const tree = buildTree(sessions, homeDir, filter);
-    const signature = sessions.length === 0 ? `EMPTY:${filter.trim()}` : treeSignature(tree);
+    const tree = buildTree(sessions, homeDir);
+    const signature = sessions.length === 0 ? "EMPTY" : treeSignature(tree);
     if (signature === renderedSignature) {
       for (const row of treeHost.querySelectorAll<HTMLElement>(".tree-leaf")) {
         const s = row.dataset.sessionId ? state.sessions.get(row.dataset.sessionId) : undefined;
@@ -728,9 +794,7 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
     renderedSignature = signature;
     treeHost.replaceChildren();
     if (sessions.length === 0) {
-      treeHost.appendChild(
-        renderEmpty(filter.trim().length > 0, () => requestOpenSpawn()),
-      );
+      treeHost.appendChild(renderEmpty(() => requestOpenSpawn()));
       return;
     }
     if (tree.kind === "folder") {
@@ -763,7 +827,7 @@ export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): S
   // than by row.
   const killHandler = (ev: Event) => {
     const s = (ev as CustomEvent<Session>).detail;
-    void requestKill(s, sessionName(s));
+    requestKill(s, sessionName(s));
   };
   const renameHandler = (ev: Event) => {
     const s = (ev as CustomEvent<Session>).detail;

web/src/commandBar.test.ts

@@ -99,6 +99,20 @@ describe("empty-query ordering", () => {
     ]);
   });
 
+  // #162: docs/COMMAND-BAR.md ranks by whether you could attach, not by which
+  // way the pane went away.
+  it("sorts dormant sessions after live ones, like dead ones", () => {
+    const dormantRecent = session("dormant", {
+      status: "Dormant",
+      last_focused_at: "2026-06-01T00:00:00Z",
+    });
+    const liveStale = session("live", { last_focused_at: "2020-01-01T00:00:00Z" });
+    expect(orderSessionsForBar([dormantRecent, liveStale]).map((s) => s.id)).toEqual([
+      "live",
+      "dormant",
+    ]);
+  });
+
   it("treats a null last_focused_at as never focused", () => {
     const nulled = session("nulled", { last_focused_at: null });
     const stamped = session("stamped", { last_focused_at: "2020-01-01T00:00:00Z" });

web/src/commandBar.ts

@@ -142,8 +142,10 @@ function createdAt(s: Session): number {
  *  matcher's last tie-break preserves. */
 export function orderSessionsForBar(sessions: readonly Session[]): Session[] {
   return [...sessions].sort((a, b) => {
-    const deadA = a.status === "Dead" ? 1 : 0;
-    const deadB = b.status === "Dead" ? 1 : 0;
+    // docs/COMMAND-BAR.md: anything with no live pane — dead or dormant (#162)
+    // — sorts after the sessions you could actually attach to.
+    const deadA = a.status === "Running" ? 0 : 1;
+    const deadB = b.status === "Running" ? 0 : 1;
     if (deadA !== deadB) return deadA - deadB;
 
     const focusA = focusedAt(a);
@@ -350,7 +352,7 @@ function renderRow(result: BarResult, index: number): HTMLElement {
   row.dataset.kind = candidate.kind;
   if (candidate.kind === "session") {
     row.dataset.sessionId = candidate.session.id;
-    if (candidate.session.status === "Dead") row.classList.add("is-dead");
+    if (candidate.session.status !== "Running") row.classList.add("is-dead");
   } else if (isActionCandidate(candidate)) {
     row.dataset.actionId = candidate.action.id;
   } else if (candidate.kind === "command") {

web/src/commands.test.ts

@@ -4,14 +4,17 @@ import { describe, expect, it, vi } from "vitest";
 import {
   COMMAND_SPECS,
   CommandSet,
+  commandSpecs,
   DEFAULT_LEADER,
   canonicalizeKey,
+  controlByte,
   defineCommands,
   isBarTypingTarget,
   isTerminalTextarea,
   isTypingTarget,
   keyCaps,
   publishedCommands,
+  type Command,
 } from "./commands.js";
 
 function key(k: string, init: KeyboardEventInit = {}): KeyboardEvent {
@@ -163,6 +166,37 @@ describe("the leader", () => {
     expect(DEFAULT_LEADER).toBe("ctrl-a");
   });
 
+  // #159: the leader is the operator's, served on `/api/info`. Every chord
+  // behind it is built from it, so a rebound leader carries its escape hatches
+  // with it instead of leaving them on a stale ctrl-a.
+  it("builds the chords behind it from the configured leader", () => {
+    const byId = new Map(commandSpecs("ctrl-b").map((s) => [s.id, s]));
+    expect(byId.get("pane.literalCtrlK")?.keys).toEqual(["ctrl-b ctrl-k"]);
+    expect(byId.get("pane.literalLeader")?.keys).toEqual(["ctrl-b ctrl-b"]);
+    // Commands that do not hang off the leader are untouched.
+    expect(byId.get("bar.open")?.keys).toEqual(["ctrl-k"]);
+  });
+
+  it("dispatches a configured leader's chord and not the default's", () => {
+    const literalCtrlK = vi.fn();
+    const set = new CommandSet(defineCommands({ "pane.literalCtrlK": literalCtrlK }, "ctrl-b"), {
+      leader: "ctrl-b",
+    });
+    set.handle(key("b", { ctrlKey: true }));
+    expect(set.handle(key("k", { ctrlKey: true }))).toBe(true);
+    expect(literalCtrlK).toHaveBeenCalledTimes(1);
+
+    // The old leader is an ordinary key again: it holds nothing, and the chord
+    // that used to follow it runs nothing.
+    set.handle(key("a", { ctrlKey: true }));
+    set.handle(key("k", { ctrlKey: true }));
+    expect(literalCtrlK).toHaveBeenCalledTimes(1);
+  });
+
+  it("sends the configured leader's own byte for the doubled chord", () => {
+    expect(controlByte("ctrl-b")).toBe("\x02");
+  });
+
   it("holds the leader as a partial chord instead of selecting the page", () => {
     const set = new CommandSet(defineCommands({ "spawn.open": vi.fn() }), {
       leader: DEFAULT_LEADER,
@@ -307,3 +341,62 @@ describe("ctrl-k over a focused pane (#152)", () => {
     expect(spec?.keys).toEqual([`${DEFAULT_LEADER} ctrl-k`]);
   });
 });
+
+describe("leader pressed twice (#158)", () => {
+  it("sends one literal leader byte and clears the pending chord", () => {
+    const literal = vi.fn();
+    const run = vi.fn();
+    const set = new CommandSet(
+      defineCommands({ "pane.literalLeader": literal, "spawn.open": run }),
+      { leader: DEFAULT_LEADER },
+    );
+    const target = el('<textarea class="xterm-helper-textarea"></textarea>');
+    expect(pressOn(set, target, "a", { ctrlKey: true })).toBe(true);
+    expect(pressOn(set, target, "a", { ctrlKey: true })).toBe(true);
+    expect(literal).toHaveBeenCalledTimes(1);
+    // The chord is cleared, not still held: the next key is ordinary again.
+    expect(set.handle(key("n"))).toBe(true);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
+  it("binds the escape hatch behind the default leader", () => {
+    const spec = COMMAND_SPECS.find((s) => s.id === "pane.literalLeader");
+    expect(spec?.keys).toEqual([`${DEFAULT_LEADER} ${DEFAULT_LEADER}`]);
+  });
+
+  // Not just the default: the chord is resolved from whatever leader this
+  // set was constructed with, so a rebound leader carries the escape hatch
+  // with it — the same proof #156 wrote for the TUI. The web has no config
+  // for this yet (#159), but the mechanism must not be hardcoded to ctrl-a.
+  it("follows a rebound leader, not just the default", () => {
+    const literal = vi.fn();
+    const rebound: Command = {
+      id: "pane.literalLeader",
+      label: "Send a literal leader key to the pane",
+      group: "Pane",
+      scope: "global",
+      keys: ["ctrl-b ctrl-b"],
+      run: literal,
+    };
+    const set = new CommandSet([rebound], { leader: "ctrl-b" });
+    const target = el('<textarea class="xterm-helper-textarea"></textarea>');
+    expect(pressOn(set, target, "b", { ctrlKey: true })).toBe(true);
+    expect(pressOn(set, target, "b", { ctrlKey: true })).toBe(true);
+    expect(literal).toHaveBeenCalledTimes(1);
+    // The old leader no longer does anything special.
+    expect(pressOn(set, target, "a", { ctrlKey: true })).toBe(false);
+  });
+});
+
+describe("controlByte", () => {
+  it("computes the raw control byte from a plain ctrl chord", () => {
+    expect(controlByte("ctrl-a")).toBe("\x01");
+    expect(controlByte("ctrl-k")).toBe("\x0b");
+  });
+
+  it("rejects anything that isn't a single plain ctrl chord", () => {
+    expect(() => controlByte("ctrl-shift-a")).toThrow();
+    expect(() => controlByte("a")).toThrow();
+    expect(() => controlByte("ctrl-a ctrl-a")).toThrow();
+  });
+});

web/src/commands.ts

@@ -32,13 +32,26 @@ export interface Command extends CommandSpec {
   run: () => void;
 }
 
-/** Default leader, mirroring the TUI's `[tui].leader`. `ctrl-a` is select-all
- *  in a browser, so a set that owns the leader `preventDefault`s it. */
+/** Leader used when the daemon does not name one — an older daemon, or an
+ *  unreachable `/api/info`. Mirrors the TUI's `[tui].leader` default. `ctrl-a`
+ *  is select-all in a browser, so a set that owns the leader
+ *  `preventDefault`s it. */
 export const DEFAULT_LEADER = "ctrl-a";
 
-/** Every command the web client has. The single list this issue exists to
- *  create: labels, chords and grouping live here and nowhere else. */
-export const COMMAND_SPECS: readonly CommandSpec[] = [
+/** Every command the web client has, for one leader. The single list: labels,
+ *  chords and grouping live here and nowhere else. Chords behind the leader are
+ *  built from it (#159), so the configured leader — served on `/api/info` as
+ *  `leader` — is what the overlay renders and the sets dispatch. */
+export function commandSpecs(leader: string = DEFAULT_LEADER): readonly CommandSpec[] {
+  return SPECS.map(({ leaderKeys, ...spec }) =>
+    leaderKeys ? { ...spec, keys: leaderKeys(leader) } : spec,
+  );
+}
+
+/** A spec whose chords are fixed, or a spec that builds them from the leader. */
+type SpecSource = CommandSpec & { leaderKeys?: (leader: string) => string[] };
+
+const SPECS: readonly SpecSource[] = [
   {
     id: "spawn.open",
     label: "Open the spawn form",
@@ -65,6 +78,15 @@ export const COMMAND_SPECS: readonly CommandSpec[] = [
     label: "Send a literal Ctrl-K to the pane",
     group: "Pane",
     keys: [`${DEFAULT_LEADER} ctrl-k`],
+    leaderKeys: (leader) => [`${leader} ctrl-k`],
+    scope: "global",
+  },
+  {
+    id: "pane.literalLeader",
+    label: "Send a literal leader key to the pane",
+    group: "Pane",
+    keys: [`${DEFAULT_LEADER} ${DEFAULT_LEADER}`],
+    leaderKeys: (leader) => [`${leader} ${leader}`],
     scope: "global",
   },
   {
@@ -153,13 +175,20 @@ export const COMMAND_SPECS: readonly CommandSpec[] = [
   },
 ];
 
-const SPEC_BY_ID = new Map(COMMAND_SPECS.map((s) => [s.id, s]));
+/** The command list under the default leader. Iteration order everywhere else
+ *  (the help overlay, the bar) comes from here. */
+export const COMMAND_SPECS: readonly CommandSpec[] = commandSpecs();
 
 /** Attach handlers to specs, by id. Throws on an unknown id, so a typo is a
- *  test failure rather than a key that silently does nothing. */
-export function defineCommands(handlers: Record<string, () => void>): Command[] {
+ *  test failure rather than a key that silently does nothing. `leader` picks
+ *  the chords behind the leader; omit it for a set that has none. */
+export function defineCommands(
+  handlers: Record<string, () => void>,
+  leader: string = DEFAULT_LEADER,
+): Command[] {
+  const byId = new Map(commandSpecs(leader).map((s) => [s.id, s]));
   return Object.entries(handlers).map(([id, run]) => {
-    const spec = SPEC_BY_ID.get(id);
+    const spec = byId.get(id);
     if (!spec) throw new Error(`unknown command id: ${id}`);
     return { ...spec, run };
   });
@@ -227,6 +256,15 @@ export function canonicalizeKey(e: KeyboardEvent): string | null {
   return out + e.key.toLowerCase();
 }
 
+/** The raw control byte for a canonical `ctrl-<letter>` chord — `ctrl-a` is
+ *  `0x01` — mirroring the TUI's `encode_key`. Built from the chord string
+ *  itself so a different leader sends its own byte, not a hardcoded one. */
+export function controlByte(chord: string): string {
+  const m = /^ctrl-([a-z])$/.exec(chord);
+  if (!m) throw new Error(`not a plain ctrl chord: ${chord}`);
+  return String.fromCharCode(m[1].charCodeAt(0) - 96);
+}
+
 const MOD_PREFIX = /^(ctrl|alt|meta|shift)-/;
 
 /** True when a chord carries a modifier or more than one key. Plain single-key

web/src/connections.ts

@@ -25,8 +25,13 @@ export interface PoolOptions {
   /** Fired when a connection's socket closes on its own (session ended/dropped),
    *  not via an intentional close/eviction. The embedder closes the pane. */
   onClosed?: (id: Uuid) => void;
+  /** Fired when a connection's handshake never completed and so was never
+   *  retried (see `AttachOptions.onNeverAttached`). Unlike `onClosed`, the
+   *  embedder should not assume the session is gone — a dormant session's
+   *  pane wants its resume affordance, not teardown. */
+  onNeverAttached?: (id: Uuid) => void;
   /** Forwarded to each connection: should a dropped socket be retried? */
-  shouldReconnect?: (id: Uuid, code: number) => boolean;
+  shouldReconnect?: (id: Uuid, code: number, everOpened: boolean) => boolean;
 }
 
 /**
@@ -85,7 +90,9 @@ export class ConnectionPool {
         {
           onRequestClose: (sid) => this.opts.onRequestClose?.(sid),
           onClosed: (sid) => this.opts.onClosed?.(sid),
-          shouldReconnect: (sid, code) => this.opts.shouldReconnect?.(sid, code) ?? false,
+          onNeverAttached: (sid) => this.opts.onNeverAttached?.(sid),
+          shouldReconnect: (sid, code, everOpened) =>
+            this.opts.shouldReconnect?.(sid, code, everOpened) ?? false,
         },
         info,
       );

web/src/fastForward.test.ts

@@ -34,12 +34,14 @@ describe("resolveFastForward (#67)", () => {
     const res = resolveFastForward(projects, presets, "amber-falcon");
     expect(res.project?.path).toBe("/repos/fresh");
     expect(res.command).toBe("aider");
-    expect(res.name).toBe("amber-falcon");
+    expect(res.handle).toBe("amber-falcon");
 
     const req = buildFastForwardRequest(res)!;
     expect(req.cwd).toBe("/repos/fresh");
     expect(req.command).toBe("aider");
-    expect(req.metadata).toEqual({ name: "amber-falcon" });
+    // No name (#131): the daemon names the session after its first prompt,
+    // and a name here would collide with the branch handle.
+    expect(req.metadata).toBeUndefined();
     expect(req.worktree).toEqual({
       base_repo: "/repos/fresh",
       branch: "amber-falcon",
@@ -88,9 +90,9 @@ describe("resolveFastForward (#67)", () => {
     expect(buildFastForwardRequest(res)).toBeNull();
   });
 
-  it("downgrades to a draft when the generated name is missing", () => {
+  it("downgrades to a draft when the generated handle is missing", () => {
     const res = resolveFastForward([project({ last_command: "claude" })], presets);
-    expect(res.name).toBeUndefined();
+    expect(res.handle).toBeUndefined();
     expect(buildFastForwardRequest(res)).toBeNull();
   });
 
@@ -108,6 +110,17 @@ describe("resolveFastForward (#67)", () => {
     });
   });
 
+  it("seeds the handle as the branch and leaves the name field empty (#131)", () => {
+    const res = resolveFastForward(
+      [project({ path: "/repos/p", base_repo: "/repos/p", last_command: "aider" })],
+      presets,
+      "amber-falcon",
+    );
+    const seed = fastForwardSeed(res);
+    expect(seed.name).toBe("");
+    expect(seed.worktreeBranch).toBe("amber-falcon");
+  });
+
   it("leaves the worktree default alone when not even a project resolved", () => {
     // Not `false`: the form defaults the toggle on and a false would stick,
     // so the fallback draft would disagree with a normally-opened draft and

web/src/fastForward.ts

@@ -10,19 +10,21 @@ import { sortProjects } from "./projectList.js";
 export interface FastForwardResolution {
   project?: Project;
   command?: string;
-  name?: string;
+  /** A generated handle for the worktree branch (#131). Not a session name:
+   *  the fast path names no session. */
+  handle?: string;
 }
 
 /** The defaults: the currently focused session's project when it's still a
  *  known project, else the most recent one (fresh-first, same ordering the
  *  picker shows) — so `N` lands where the operator currently is, matching
  *  what plain `n` seeds from `spawnSimilarProjectSeed`. Its last command
- *  falls back to the first non-custom preset, and the name is freshly
- *  generated when the daemon supplied one. */
+ *  falls back to the first non-custom preset, and the branch handle is
+ *  freshly generated when the daemon supplied one. */
 export function resolveFastForward(
   projects: Project[],
   presets: SpawnPreset[],
-  name?: string,
+  handle?: string,
   focusedCwd?: string,
 ): FastForwardResolution {
   const project =
@@ -30,41 +32,45 @@ export function resolveFastForward(
   const lastCommand = project?.last_command?.trim();
   const command =
     lastCommand || presets.find((p) => p.command !== "")?.command || undefined;
-  return { project, command, name: name || undefined };
+  return { project, command, handle: handle || undefined };
 }
 
 /** The immediate spawn request — worktree on, new branch named after the
- *  generated session name — or `null` when any default is missing. */
+ *  generated handle — or `null` when any default is missing.
+ *
+ *  The request carries no name (#131): the daemon assigns a provisional one
+ *  and replaces it once the session sees its first prompt. A name here would
+ *  also collide with the branch handle's own session. */
 export function buildFastForwardRequest(
   res: FastForwardResolution,
 ): CreateSessionRequest | null {
-  const { project, command, name } = res;
-  if (!project || !command?.trim() || !name) return null;
+  const { project, command, handle } = res;
+  if (!project || !command?.trim() || !handle) return null;
   return {
     cwd: project.path,
     command,
-    metadata: { name },
     worktree: {
       base_repo: project.base_repo ?? project.path,
-      branch: name,
+      branch: handle,
       create_branch: true,
     },
   };
 }
 
 /** Seed for the fallback spawn form: whatever did resolve goes into the
- *  form; the rest stays with its own defaults. */
+ *  form; the rest stays with its own defaults. The name field stays empty
+ *  (#131) — the handle seeds the branch, not the session name. */
 export function fastForwardSeed(res: FastForwardResolution) {
   return {
     cwd: res.project?.path ?? "",
     command: res.command ?? "",
-    name: res.name ?? "",
+    name: "",
     // Left undefined rather than false when nothing resolved: the form
     // defaults the toggle on, and `false` would stick, so the fallback form
     // would disagree with both a normally-opened form and the TUI's fast path
     // (#67 review).
     worktreeEnabled: res.project ? true : undefined,
     worktreeBranch:
-      res.project && res.name ? res.name : undefined,
+      res.project && res.handle ? res.handle : undefined,
   };
 }

web/src/help.test.ts

@@ -1,7 +1,7 @@
 // @vitest-environment happy-dom
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
-import { keyCaps, publishedCommands } from "./commands.js";
+import { defineCommands, keyCaps, publishCommands, publishedCommands } from "./commands.js";
 import { closeHelp, groupedCommands, installHelpKeybind, isHelpOpen, openHelp } from "./help.js";
 
 beforeEach(() => {
@@ -44,6 +44,33 @@ describe("help overlay", () => {
       .toEqual(publishedCommands().map((c) => c.id));
   });
 
+  // #159: the leader comes from the daemon, so the overlay must render the
+  // configured chord — a hardcoded `Ctrl A` is the visible half of the bug.
+  it("renders the configured leader's chord, not a hardcoded Ctrl A", () => {
+    const bound = defineCommands(
+      { "pane.literalCtrlK": () => {}, "pane.literalLeader": () => {} },
+      "ctrl-b",
+    );
+    publishCommands(bound);
+    try {
+      openHelp();
+      const keysOf = (id: string) =>
+        [
+          ...(document.querySelector(`.help-row[data-command-id="${id}"]`) as HTMLElement)
+            .querySelectorAll("kbd"),
+        ]
+          .map((k) => k.textContent)
+          .join(" ");
+      expect(keysOf("pane.literalCtrlK")).toBe("Ctrl B then Ctrl K");
+      expect(keysOf("pane.literalLeader")).toBe("Ctrl B then Ctrl B");
+    } finally {
+      // Leave the registry as the rest of the suite expects it.
+      publishCommands(
+        defineCommands({ "pane.literalCtrlK": () => {}, "pane.literalLeader": () => {} }),
+      );
+    }
+  });
+
   it("opens on ? and closes on a second ?", () => {
     press("?", { shiftKey: true });
     expect(isHelpOpen()).toBe(true);

web/src/killDialog.ts

@@ -1,14 +1,44 @@
 /**
- * Forced-kill prompt (#81).
+ * The two kill prompts (#81, #160).
  *
- * The daemon refuses to kill a session whose worktree still holds uncommitted
- * or unpushed work. `confirm()` can only ask the same question twice, so the
- * refusal gets its own dialog: it names what is in the way and offers the
- * override the daemon's `force=true` already implements. A kill the daemon
- * accepts never reaches here — there is nothing to warn about.
+ * A kill is destructive and unattended agents live in these sessions, so both
+ * clients ask before one goes through — the TUI's `KillConfirm`, and
+ * `openKillConfirmDialog` here (#160). Where the session's worktree still
+ * holds uncommitted or unpushed work, the confirmation says so up front, the
+ * same way the TUI's does.
+ *
+ * The daemon decides the rest: it refuses a kill over such a worktree, and
+ * that refusal needs an answer the confirmation cannot give — a forced kill.
+ * `openForceKillDialog` is that second prompt. A kill the daemon accepts never
+ * reaches it.
  */
 import { formatInTheWay, type InTheWay } from "./types.js";
 
+/** What both prompts need: a target to name and a button that acts on it. */
+interface KillDialogSpec {
+  /** Session name, as the sidebar shows it. */
+  name: string;
+  /** Sentence under the title. */
+  body: string;
+  /** Label on the acting button. */
+  confirmLabel: string;
+  /** Extra class on the acting button, so tests and styles can find it. */
+  confirmClass: string;
+  /** Run it. A rejection is rendered in the dialog, which stays open so the
+   *  press can be retried. */
+  onConfirm: () => Promise<void>;
+}
+
+export interface KillConfirmPrompt {
+  name: string;
+  /** What the card last saw in the way, when anything was. Shown before the
+   *  attempt, so "this will be refused" is not a surprise. */
+  blockers: InTheWay | null;
+  /** Run the plain kill. Opening a further dialog from here is allowed: the
+   *  confirmation only closes itself if it is still the one on screen. */
+  onKill: () => Promise<void>;
+}
+
 export interface ForceKillPrompt {
   /** Session name, as the sidebar shows it. */
   name: string;
@@ -30,9 +60,9 @@ export function closeForceKillDialog(): void {
   open = null;
 }
 
-/** Mount the prompt. Opening while one is up replaces it, so a second refusal
- *  can never stack two dialogs. */
-export function openForceKillDialog(p: ForceKillPrompt): HTMLElement {
+/** Mount one of the prompts. Opening while one is up replaces it, so the
+ *  confirmation and a refusal that follows it can never stack. */
+function mount(p: KillDialogSpec): HTMLElement {
   closeForceKillDialog();
 
   const el = document.createElement("div");
@@ -50,9 +80,7 @@ export function openForceKillDialog(p: ForceKillPrompt): HTMLElement {
 
   const body = document.createElement("p");
   body.className = "kill-dialog-body";
-  body.textContent = p.blockers
-    ? `Its worktree still has ${formatInTheWay(p.blockers)}. Forcing the kill removes the session and leaves the worktree on disk.`
-    : `${p.reason} Forcing the kill removes the session and leaves the worktree on disk.`;
+  body.textContent = p.body;
 
   const error = document.createElement("p");
   error.className = "kill-dialog-error";
@@ -65,22 +93,27 @@ export function openForceKillDialog(p: ForceKillPrompt): HTMLElement {
   cancel.className = "btn btn-ghost kill-dialog-cancel";
   cancel.textContent = "Cancel";
   cancel.addEventListener("click", closeForceKillDialog);
-  const force = document.createElement("button");
-  force.type = "button";
-  force.className = "btn btn-danger kill-dialog-force";
-  force.textContent = "Force kill";
-  force.addEventListener("click", () => {
-    force.disabled = true;
+  const confirm = document.createElement("button");
+  confirm.type = "button";
+  confirm.className = `btn btn-danger ${p.confirmClass}`;
+  confirm.textContent = p.confirmLabel;
+  confirm.addEventListener("click", () => {
+    confirm.disabled = true;
     void p
-      .onForce()
-      .then(closeForceKillDialog)
+      .onConfirm()
+      .then(() => {
+        // A handler that opened the refusal prompt has already replaced this
+        // dialog; closing here would take that one down with it.
+        if (open?.el === el) closeForceKillDialog();
+      })
       .catch((e: unknown) => {
-        force.disabled = false;
+        if (open?.el !== el) return;
+        confirm.disabled = false;
         error.hidden = false;
         error.textContent = `Failed to kill: ${(e as Error).message}`;
       });
   });
-  actions.append(cancel, force);
+  actions.append(cancel, confirm);
 
   panel.append(title, body, error, actions);
 
@@ -99,6 +132,34 @@ export function openForceKillDialog(p: ForceKillPrompt): HTMLElement {
   };
   window.addEventListener("keydown", onKeydown, true);
   open = { el, onKeydown };
+  // Cancel takes the focus in both prompts: a kill is never one keystroke
+  // away from whatever asked for the dialog.
   cancel.focus();
   return el;
 }
+
+/** Ask before a kill the daemon has not seen yet (#160). */
+export function openKillConfirmDialog(p: KillConfirmPrompt): HTMLElement {
+  return mount({
+    name: p.name,
+    body: p.blockers
+      ? `Its worktree still has ${formatInTheWay(p.blockers)}. The kill will be refused unless it is forced.`
+      : "The session and everything running in it go away. Its worktree stays on disk.",
+    confirmLabel: "Kill",
+    confirmClass: "kill-dialog-kill",
+    onConfirm: p.onKill,
+  });
+}
+
+/** Offer the override after the daemon refuses a guarded kill (#81). */
+export function openForceKillDialog(p: ForceKillPrompt): HTMLElement {
+  return mount({
+    name: p.name,
+    body: p.blockers
+      ? `Its worktree still has ${formatInTheWay(p.blockers)}. Forcing the kill removes the session and leaves the worktree on disk.`
+      : `${p.reason} Forcing the kill removes the session and leaves the worktree on disk.`,
+    confirmLabel: "Force kill",
+    confirmClass: "kill-dialog-force",
+    onConfirm: p.onForce,
+  });
+}

web/src/main.ts

@@ -7,7 +7,7 @@ import { ConnectionPool } from "./connections.js";
 import { installDrawer, installDrawerSwipe, requestToggleDrawer } from "./drawer.js";
 import { installHudKeybind } from "./debug.js";
 import { installHelpKeybind, isHelpOpen } from "./help.js";
-import { CommandSet, DEFAULT_LEADER, defineCommands, isBarTypingTarget } from "./commands.js";
+import { CommandSet, DEFAULT_LEADER, controlByte, defineCommands, isBarTypingTarget } from "./commands.js";
 import { isCommandBarOpen, openCommandBar, SPAWN_DIRECTORY_EVENT } from "./commandBar.js";
 import { DaemonLink } from "./daemonLink.js";
 import { CatalogStore } from "./events.js";
@@ -19,6 +19,7 @@ import {
   getDaemonInfo,
   gitRoot,
   projects as fetchProjects,
+  resumeSession,
 } from "./api.js";
 import {
   buildFastForwardRequest,
@@ -36,6 +37,7 @@ import { createPreviewSchedule } from "./previewSchedule.js";
 import {
   FOCUS_PANE_EVENT,
   FOCUS_SIDEBAR_EVENT,
+  OPEN_COMMAND_BAR_EVENT,
   OPEN_SPAWN_EVENT,
   SESSION_SELECT_EVENT,
   SPAWN_SIMILAR_EVENT,
@@ -86,9 +88,15 @@ const store = new CatalogStore();
 // Absolute paths are a fine fallback until it lands.
 let homeDir: string | undefined;
 void getDaemonInfo()
-  .then((info) => (homeDir = info.home_dir))
+  .then((info) => {
+    homeDir = info.home_dir;
+    // The leader is the operator's, not this module's (#159): a daemon that
+    // names one rebinds the chords hanging off it, and the `?` overlay and the
+    // command bar re-render from the rebuilt set.
+    if (info.leader) useLeader(info.leader);
+  })
   .catch(() => {
-    /* absolute paths are a fine fallback */
+    /* absolute paths and the default leader are fine fallbacks */
   });
 
 // The daemon's identity and liveness: names the release in the sidebar's status
@@ -165,17 +173,42 @@ const pool = new ConnectionPool({
   // pane is never left lying around.
   onRequestClose: (id) => closePane(id),
   onClosed: (id) => closePane(id),
-  shouldReconnect: (id, code) => shouldRetryClose(id, code, store.snapshot().sessions),
+  // #168 review: a handshake that never opened (a dormant session's `409
+  // not_attachable`, most likely) isn't "the session is gone" — drop the dead
+  // connection and re-render so the leaf gets a fresh attempt if the catalog
+  // still says Running, or the resume affordance if it doesn't.
+  onNeverAttached: (id) => {
+    pool.close(id);
+    mv?.render();
+  },
+  shouldReconnect: (id, code, everOpened) =>
+    shouldRetryClose(id, code, store.snapshot().sessions, everOpened),
 });
 
 // Session death used to reach the UI on two uncoordinated channels — the row
 // from the events socket, the pane from `ws.onclose` — so either could happen
 // without the other. The catalog is the authority: a pane for a session that is
 // no longer listed gets closed here.
+//
+// A pane can also be showing the dormant placeholder (or, briefly, a dead
+// socket) rather than a live attach (#168): when an *open* session's
+// Running-ness flips — most commonly a resume completing — the pane and the
+// placeholder need to swap without waiting on an unrelated layout change.
+let lastOpenRunning = new Map<string, boolean>();
 store.subscribe((state) => {
   for (const id of mv?.openSessions() ?? []) {
     if (!state.sessions.has(id)) closePane(id);
   }
+  const open = mv?.openSessions() ?? new Set<string>();
+  const nextRunning = new Map<string, boolean>();
+  let runningChanged = false;
+  for (const id of open) {
+    const running = state.sessions.get(id)?.status === "Running";
+    nextRunning.set(id, running);
+    if (lastOpenRunning.get(id) !== running) runningChanged = true;
+  }
+  lastOpenRunning = nextRunning;
+  if (runningChanged) mv?.render();
 });
 
 function closePane(id: string): void {
@@ -268,6 +301,8 @@ mv = createMultiView({
   // catalog (no sessions) to attach.
   onOpenSessionsChange: updateShellRoute,
   onLayoutChange: scheduleSave,
+  sessionFor: (id) => store.snapshot().sessions.get(id),
+  onResume: (id) => resumeSession(id),
 });
 let contentShowsMv = false;
 /** Put the multi-view in the content pane, without rendering it. A preview
@@ -349,14 +384,14 @@ async function spawnPresets(): Promise<SpawnPreset[]> {
 }
 
 async function requestFastForward(): Promise<void> {
-  const [discovered, name] = await Promise.all([
+  const [discovered, handle] = await Promise.all([
     fetchProjects().catch(() => [] as Project[]),
     fetchNames(1)
       .then((batch) => batch.names[0])
       .catch(() => undefined),
   ]);
   const presets = await spawnPresets();
-  const resolved = resolveFastForward(discovered, presets, name, focusedProjectCwd());
+  const resolved = resolveFastForward(discovered, presets, handle, focusedProjectCwd());
   const req = buildFastForwardRequest(resolved);
   if (req) {
     try {
@@ -383,7 +418,7 @@ async function requestFastForward(): Promise<void> {
 // one outside any repo spawns without a worktree, since there is no repo to cut
 // a branch from. Anything still unresolved opens the pre-filled form.
 async function requestSpawnInDirectory(path: string): Promise<void> {
-  const [discovered, name] = await Promise.all([
+  const [discovered, handle] = await Promise.all([
     fetchProjects().catch(() => [] as Project[]),
     fetchNames(1)
       .then((batch) => batch.names[0])
@@ -392,7 +427,7 @@ async function requestSpawnInDirectory(path: string): Promise<void> {
   const presets = await spawnPresets();
   const known = discovered.find((p) => p.path === path);
   const project: Project = known ?? { path, name: path.split("/").filter(Boolean).pop() ?? path };
-  const resolved = resolveFastForward([project], presets, name, path);
+  const resolved = resolveFastForward([project], presets, handle, path);
   const req = buildFastForwardRequest(resolved);
   if (req) {
     const inRepo =
@@ -438,41 +473,68 @@ const spawnKeys = new CommandSet(
 // terminal owns every plain keystroke, so nothing unmodified could ever get
 // the focus back out of it.
 //
-// This set also owns the leader (`ctrl-a`, the TUI's default): it holds the
-// key as a partial chord and takes select-all off it, so the escape hatch
-// docs/COMMAND-BAR.md describes has somewhere to land (#149).
-const focusKeys = new CommandSet(
-  defineCommands({
-    "focus.toggle": () => {
-      if (sidebar.hasListFocus()) {
-        pool.focusTerminal();
-      } else {
-        drawer.open(); // no-op on desktop; on mobile the list is off-canvas
-        sidebar.focusList();
-      }
-    },
-    // The escape hatch: binding ctrl-k takes readline's kill-to-end-of-line
-    // away from every pane, and leader ctrl-k gives it back as the literal
-    // 0x0B byte (docs/COMMAND-BAR.md). It resolves in this set, ahead of the
-    // bar's, so the chord never opens the bar.
-    "pane.literalCtrlK": () => pool.sendToFocused("\x0b"),
-  }),
-  { leader: DEFAULT_LEADER },
-);
+// This set also owns the leader (`[tui].leader`, `ctrl-a` by default, served
+// on `/api/info`): it holds the key as a partial chord and takes select-all off
+// it, so the escape hatch docs/COMMAND-BAR.md describes has somewhere to land
+// (#149).
+let currentLeader = DEFAULT_LEADER;
+
+function buildFocusKeys(leader: string): CommandSet {
+  return new CommandSet(
+    defineCommands(
+      {
+        "focus.toggle": () => {
+          if (sidebar.hasListFocus()) {
+            pool.focusTerminal();
+          } else {
+            drawer.open(); // no-op on desktop; on mobile the list is off-canvas
+            sidebar.focusList();
+          }
+        },
+        // The escape hatch: binding ctrl-k takes readline's
+        // kill-to-end-of-line away from every pane, and leader ctrl-k gives it
+        // back as the literal 0x0B byte (docs/COMMAND-BAR.md). It resolves in
+        // this set, ahead of the bar's, so the chord never opens the bar.
+        "pane.literalCtrlK": () => pool.sendToFocused("\x0b"),
+        // The leader itself, pressed twice, tmux-style: sends one literal
+        // leader byte and clears the pending chord instead of resolving as a
+        // dead chord (docs/COMMAND-BAR.md, #158). Built from the leader, not a
+        // hardcoded byte, so a rebound leader sends its own.
+        "pane.literalLeader": () => pool.sendToFocused(controlByte(leader)),
+      },
+      leader,
+    ),
+    { leader },
+  );
+}
+
+let focusKeys = buildFocusKeys(DEFAULT_LEADER);
+
+/** Rebind the leader-owning set to the daemon's leader. Re-registering the
+ *  same command ids replaces them, so the help overlay and the command bar —
+ *  both of which render the published registry when they open — show the
+ *  configured chord rather than the default. */
+function useLeader(leader: string): void {
+  if (leader === currentLeader) return;
+  currentLeader = leader;
+  focusKeys = buildFocusKeys(leader);
+}
 
 // Ctrl+K opens the command bar (docs/COMMAND-BAR.md). It is a registry command
 // like any other, so the `?` overlay lists it without a second list.
-const barKeys = new CommandSet(
-  defineCommands({
-    "bar.open": () => {
-      // Opening while a session is previewed discards the preview first, like
-      // any other real change (docs/PREVIEW.md): the bar is not previewed into.
-      schedulePreview.cancel();
-      mv?.previewSession(null);
-      openCommandBar({ sessions: [...store.snapshot().sessions.values()], homeDir });
-    },
-  }),
-);
+const openBar = () => {
+  // Opening while a session is previewed discards the preview first, like
+  // any other real change (docs/PREVIEW.md): the bar is not previewed into.
+  schedulePreview.cancel();
+  mv?.previewSession(null);
+  openCommandBar({ sessions: [...store.snapshot().sessions.values()], homeDir });
+};
+
+const barKeys = new CommandSet(defineCommands({ "bar.open": () => openBar() }));
+
+// The sidebar's search field is the touch entry point (#157): no `ctrl-k` on a
+// phone, so the field the operator already reaches for opens the same bar.
+document.addEventListener(OPEN_COMMAND_BAR_EVENT, () => openBar());
 
 // Capture phase: an attached xterm swallows every keystroke it is given, so the
 // bar's binding has to be seen ahead of the terminal (docs/COMMAND-BAR.md).

web/src/multiview.test.ts

@@ -45,7 +45,7 @@ function fakeSidebar(): SidebarHandle {
   };
 }
 
-function makeMv(layout: Layout): MultiView {
+function makeMv(layout: Layout, overrides: Partial<Parameters<typeof createMultiView>[0]> = {}): MultiView {
   return createMultiView({
     pool: fakePool(),
     layout,
@@ -53,6 +53,7 @@ function makeMv(layout: Layout): MultiView {
     infoFor: () => ({ name: "sess", command: "bash" }),
     onDisconnect: () => {},
     renderWelcome: () => document.createElement("div"),
+    ...overrides,
   });
 }
 
@@ -87,6 +88,102 @@ describe("multiview empty panes", () => {
   });
 });
 
+// #168 review: highlighting a dormant session used to open a pane and attempt
+// a live attach, which the daemon answers with 404/409 and the socket dies
+// with WS 1006. A dormant leaf must never reach the pool at all — it gets the
+// resume affordance instead.
+describe("multiview dormant gating (#168)", () => {
+  beforeEach(() => {
+    stubFetch();
+    document.body.replaceChildren();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  function dormantSession(id: string) {
+    return {
+      id,
+      cwd: "/home/n/work",
+      command: "claude",
+      env: {},
+      metadata: { name: "worker" },
+      status: "Dormant" as const,
+      created_at: "2026-08-24T10:00:00Z",
+    };
+  }
+
+  it("never hands a dormant session's leaf to the pool, and shows a resume affordance", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    tab.focusedLeafId = splitLeaf(tab, "", "d1", "row", true);
+    const setVisible = vi.fn();
+    const pool = { setVisible, setFocus() {} } as unknown as ConnectionPool;
+    const mv = createMultiView({
+      pool,
+      layout,
+      sidebar: fakeSidebar(),
+      infoFor: () => ({ name: "worker", command: "claude" }),
+      onDisconnect: () => {},
+      renderWelcome: () => document.createElement("div"),
+      sessionFor: (id) => (id === "d1" ? dormantSession("d1") : undefined),
+    });
+    document.body.appendChild(mv.el);
+    mv.render();
+    await flush();
+
+    expect(setVisible).toHaveBeenCalledWith([], expect.anything());
+    const pane = mv.el.querySelector('[data-leaf-id]') as HTMLElement;
+    expect(pane.querySelector(".mv-pane-dormant")).toBeTruthy();
+    expect(pane.textContent).toContain("worker");
+    expect(pane.textContent).toContain("/home/n/work");
+    expect(pane.querySelector(".mv-dormant-resume")).toBeTruthy();
+  });
+
+  it("still attaches a Running session's leaf normally", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    tab.focusedLeafId = splitLeaf(tab, "", "r1", "row", true);
+    const setVisible = vi.fn();
+    const pool = { setVisible, setFocus() {} } as unknown as ConnectionPool;
+    const mv = createMultiView({
+      pool,
+      layout,
+      sidebar: fakeSidebar(),
+      infoFor: () => ({ name: "worker", command: "claude" }),
+      onDisconnect: () => {},
+      renderWelcome: () => document.createElement("div"),
+      sessionFor: (id) => ({ ...dormantSession(id), status: "Running" }),
+    });
+    document.body.appendChild(mv.el);
+    mv.render();
+    await flush();
+
+    expect(setVisible).toHaveBeenCalledWith(
+      [expect.objectContaining({ id: "r1" })],
+      expect.anything(),
+    );
+  });
+
+  it("clicking resume calls back with the session id", async () => {
+    const layout = emptyLayout();
+    const tab = layout.tabs[0];
+    tab.focusedLeafId = splitLeaf(tab, "", "d1", "row", true);
+    const onResume = vi.fn().mockResolvedValue(undefined);
+    const mv = makeMv(layout, {
+      sessionFor: (id) => (id === "d1" ? dormantSession("d1") : undefined),
+      onResume,
+    });
+    document.body.appendChild(mv.el);
+    mv.render();
+    await flush();
+
+    mv.el.querySelector<HTMLButtonElement>(".mv-dormant-resume")?.click();
+    expect(onResume).toHaveBeenCalledWith("d1");
+  });
+});
+
 describe("multiview pane-drag swap", () => {
   beforeEach(() => {
     stubFetch();

web/src/multiview.ts

@@ -6,6 +6,10 @@
 
 import type { SidebarHandle } from "./catalog.js";
 import type { ConnectionPool } from "./connections.js";
+import { activityDurationLabel, activityHeldMs } from "./activity.js";
+import { escapeHtml } from "./html.js";
+import { sessionName } from "./types.js";
+import type { Session } from "./types.js";
 import {
   activeTab,
   addTab,
@@ -34,6 +38,14 @@ export interface MultiViewOptions {
   onDisconnect: (sessionId: string) => void;
   /** Welcome content for an empty tab. */
   renderWelcome: () => HTMLElement;
+  /** The session behind a leaf, when known — used to gate a live attach on
+   *  `status === "Running"` (#168 review) and to fill in the dormant pane's
+   *  resume affordance. A leaf whose session this returns `undefined` for
+   *  (unknown to the caller) attaches as before, so callers that don't wire
+   *  this up see no change in behaviour. */
+  sessionFor?: (sessionId: string) => Session | undefined;
+  /** Resume a dormant session (#166/#168), from its pane's own affordance. */
+  onResume?: (sessionId: string) => Promise<unknown>;
   /** Called when a spawn fills a pane with a new session, so the shell can
    *  re-evaluate its route (sidebar vs attach layout). */
   onOpenSessionsChange?: () => void;
@@ -215,6 +227,20 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     return fl?.sessionId ?? null;
   }
 
+  /** The session the operator actually picked — what `focusedLeafSession()`
+   *  would return with the preview undone. A preview moves the active tab and
+   *  its focus, but it is a view: the accent stays on the row the operator
+   *  chose until they choose another (docs/PREVIEW.md). */
+  function realFocusedSession(): string | null {
+    const p = preview;
+    if (!p) return focusedLeafSession();
+    const tab = layout.tabs.find((t) => t.id === p.prevActiveTabId) ?? activeTab(layout);
+    const leafId =
+      p.prevFocus && p.prevFocus.tabId === tab.id ? p.prevFocus.leafId : tab.focusedLeafId;
+    const fl = leafId ? findLeaf(tab.root, leafId) : null;
+    return fl?.sessionId ?? null;
+  }
+
   /** Update focus styling + pool focus + sidebar highlights without rebuilding
    *  the DOM (cheap path for click-to-focus). */
   function syncFocus(): void {
@@ -233,7 +259,7 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     if (!preview) pool.setFocus(focusedLeafSession());
     sidebar.setHighlights({
       open: realOpenSessions(),
-      focused: focusedLeafSession(),
+      focused: realFocusedSession(),
     });
     // The row the preview came from wears the same colour, so the sidebar and
     // the pane read as one thing rather than two unrelated highlights.
@@ -248,6 +274,44 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     persist();
   }
 
+  // ---- dormant panes (#168 review) ----
+
+  /** The session behind `sessionId` when it is known and not `Running` —
+   *  what gates a leaf away from a live attach and towards the resume
+   *  affordance instead. */
+  function dormantSessionFor(sessionId: string): Session | undefined {
+    const s = opts.sessionFor?.(sessionId);
+    return s && s.status !== "Running" ? s : undefined;
+  }
+
+  /** docs/PREVIEW.md / docs/SIDEBAR.md: what the content pane can honestly
+   *  show for a session with no pane behind it — its metadata and a resume
+   *  affordance, never a live terminal that would just die with WS 1006. */
+  function renderDormantPane(host: HTMLElement, session: Session): void {
+    const heldMs = activityHeldMs(session.last_activity_at ?? session.created_at, Date.now());
+    const age = heldMs !== null ? activityDurationLabel(heldMs) : null;
+    const wrap = document.createElement("div");
+    wrap.className = "mv-pane-dormant";
+    wrap.innerHTML = `
+      <div class="mv-dormant-glyph" aria-hidden="true">◌</div>
+      <div class="mv-dormant-name">${escapeHtml(sessionName(session))}</div>
+      <div class="mv-dormant-cwd" title="${escapeHtml(session.cwd)}">${escapeHtml(session.cwd)}</div>
+      <div class="mv-dormant-detail">dormant${age ? ` for ${escapeHtml(age)}` : ""} — nothing running behind it</div>
+      <button type="button" class="btn btn-primary mv-dormant-resume">Resume</button>
+    `;
+    const btn = wrap.querySelector(".mv-dormant-resume") as HTMLButtonElement;
+    btn.addEventListener("click", () => {
+      btn.disabled = true;
+      btn.textContent = "Resuming…";
+      opts.onResume?.(session.id)?.catch((e: Error) => {
+        btn.disabled = false;
+        btn.textContent = "Resume";
+        alert(`Failed to resume: ${e.message}`);
+      });
+    });
+    host.replaceChildren(wrap);
+  }
+
   // ---- pane + split DOM ----
 
   function buildPane(leaf: Extract<Node, { kind: "leaf" }>): {
@@ -364,7 +428,12 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     if (node.kind === "leaf") {
       const pane = buildPane(node);
       if (node.sessionId) {
-        hosts.push({ id: node.sessionId, host: pane.host, info: infoFor(node.sessionId) });
+        const dormant = dormantSessionFor(node.sessionId);
+        if (dormant) {
+          renderDormantPane(pane.host, dormant);
+        } else {
+          hosts.push({ id: node.sessionId, host: pane.host, info: infoFor(node.sessionId) });
+        }
       }
       return pane.el;
     }
@@ -602,13 +671,17 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     wrap.appendChild(pane.el);
     canvas.appendChild(wrap);
 
+    const dormant = focused.sessionId ? dormantSessionFor(focused.sessionId) : undefined;
+    if (dormant) renderDormantPane(pane.host, dormant);
     // Only the focused leaf's session is live on mobile; the rest park.
     pool.setVisible(
-      focused.sessionId ? [{ id: focused.sessionId, pane: pane.host, info: infoFor(focused.sessionId) }] : [],
+      focused.sessionId && !dormant
+        ? [{ id: focused.sessionId, pane: pane.host, info: infoFor(focused.sessionId) }]
+        : [],
       { focus: !preview && !quietRender },
     );
     if (!preview) pool.setFocus(focused.sessionId ?? null);
-    sidebar.setHighlights({ open: realOpenSessions(), focused: focused.sessionId ?? null });
+    sidebar.setHighlights({ open: realOpenSessions(), focused: realFocusedSession() });
     sidebar.setPreview(preview?.sessionId ?? null);
   }
 
@@ -817,7 +890,7 @@ export function createMultiView(opts: MultiViewOptions): MultiView {
     openSessions: realOpenSessions,
     beginSessionDrag,
     render,
-    focusedSessionId: focusedLeafSession,
+    focusedSessionId: realFocusedSession,
     previewSession,
     previewedSessionId: () => preview?.sessionId ?? null,
   };

web/src/preview.test.ts

@@ -47,12 +47,20 @@ function fakePool(): Spy {
 
 /** Last value the controller pushed to `SidebarHandle.setPreview`. */
 const previewRow: { id: string | null } = { id: null };
+/** Last highlights the controller pushed to `SidebarHandle.setHighlights`. */
+const rowHighlights: { open: Set<string>; focused: string | null } = {
+  open: new Set(),
+  focused: null,
+};
 
 function fakeSidebar(): SidebarHandle {
   return {
     el: document.createElement("aside"),
     setActive() {},
-    setHighlights() {},
+    setHighlights(h) {
+      rowHighlights.open = h.open;
+      rowHighlights.focused = h.focused;
+    },
     setPreview(id: string | null) {
       previewRow.id = id;
     },
@@ -95,6 +103,8 @@ describe("sidebar preview", () => {
     stubFetch();
     document.body.replaceChildren();
     previewRow.id = null;
+    rowHighlights.open = new Set();
+    rowHighlights.focused = null;
   });
 
   afterEach(() => {
@@ -134,6 +144,28 @@ describe("sidebar preview", () => {
     expect(mv.el.querySelectorAll(".mv-pane.is-preview")).toHaveLength(0);
   });
 
+  it("leaves the accent on the session the pane actually holds", () => {
+    const layout = twoTabs();
+    const spy = fakePool();
+    const mv = makeMv(layout, spy.pool);
+    expect(rowHighlights.focused).toBe("s2");
+
+    // Walking past other rows never moves the accent off what the operator
+    // picked: only a real open does (docs/PREVIEW.md).
+    mv.previewSession("s1");
+    expect(rowHighlights.focused).toBe("s2");
+    expect(mv.focusedSessionId()).toBe("s2");
+
+    mv.previewSession("s9");
+    expect(rowHighlights.focused).toBe("s2");
+
+    mv.previewSession(null);
+    expect(rowHighlights.focused).toBe("s2");
+
+    mv.openSession("s1");
+    expect(rowHighlights.focused).toBe("s1");
+  });
+
   it("shows a session no pane holds in a throwaway tab that leaves no trace", () => {
     const layout = twoTabs();
     const before = serializeLayout(layout);

web/src/reconnect.test.ts

@@ -47,6 +47,13 @@ describe("shouldRetryClose", () => {
   it("never retries a clean close", () => {
     expect(shouldRetryClose("a", 1000, running)).toBe(false);
   });
+
+  // #168 review: a handshake that never opened is a rejection (e.g. a
+  // dormant session's 409 not_attachable), not a dropped stream. Retrying it
+  // loops forever if the catalog status hasn't caught up yet.
+  it("never retries a socket that never opened, even if the catalog still says running", () => {
+    expect(shouldRetryClose("a", 1006, running, false)).toBe(false);
+  });
 });
 
 describe("backoff bounds", () => {

web/src/reconnect.ts

@@ -26,7 +26,15 @@ export function shouldRetryClose(
   sessionId: Uuid,
   code: number,
   sessions: ReadonlyMap<Uuid, Session>,
+  /** Did this socket ever reach `open`? A handshake that never completed is
+   *  the daemon rejecting the attach (dormant/unknown) rather than a dropped
+   *  stream — retrying it spins in place until the catalog updates, which for
+   *  a dormant session it never will (#168 review). Defaults to `true` so
+   *  existing callers that only track drops of an established link are
+   *  unaffected. */
+  everOpened = true,
 ): boolean {
   if (code >= APPLICATION_CLOSE || code === CLEAN_CLOSE) return false;
+  if (!everOpened) return false;
   return sessions.get(sessionId)?.status === "Running";
 }

web/src/routes.ts

@@ -37,6 +37,12 @@ export function sessionFocus(id: Uuid): string {
   return `${session(id)}/focus`;
 }
 
+/** `POST /api/sessions/:id/resume` (#166/#168): respawn a dormant session
+ * under its own uuid and sidecar. */
+export function sessionResume(id: Uuid): string {
+  return `${session(id)}/resume`;
+}
+
 /** 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/sidebarNav.test.ts

@@ -143,7 +143,7 @@ describe("sidebar keyboard navigation", () => {
     field!.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
   });
 
-  it("x kills the highlighted session", async () => {
+  it("x kills the highlighted session, once confirmed (#160)", async () => {
     const { el } = twoFolders();
     const killed: string[] = [];
     window.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
@@ -153,6 +153,8 @@ describe("sidebar keyboard navigation", () => {
 
     press(tree(el), "j");
     press(tree(el), "x");
+    expect(killed.some((r) => r.startsWith("DELETE"))).toBe(false);
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
     await Promise.resolve();
     expect(killed.some((r) => r.startsWith("DELETE") && r.includes(A))).toBe(true);
   });

web/src/sidebarSearch.test.ts

@@ -0,0 +1,135 @@
+// @vitest-environment happy-dom
+//
+// The sidebar's search field is the touch entry point to the command bar
+// (#157, docs/COMMAND-BAR.md "Touch entry"): tapping or focusing it asks the
+// shell to open the bar with an empty query, instead of filtering the tree.
+import { beforeAll, describe, expect, it } from "vitest";
+
+import { OPEN_COMMAND_BAR_EVENT, renderSidebar } from "./catalog.js";
+import { sessionBarCandidates } from "./commandBar.js";
+import { matchAndRank } from "./matcher.js";
+import type { CatalogListener, CatalogStore } from "./events.js";
+import type { Session } from "./types.js";
+
+beforeAll(() => {
+  Object.defineProperty(window, "localStorage", {
+    value: { getItem: () => null, setItem: () => {} },
+  });
+  window.fetch = () => Promise.reject(new Error("offline"));
+});
+
+function session(id: string, cwd: string): Session {
+  return {
+    id,
+    name: id,
+    cwd,
+    command: "claude",
+    env: {},
+    metadata: {},
+    status: "Running",
+    created_at: "2026-08-24T10:00:00Z",
+  } as Session;
+}
+
+function storeWith(sessions: Session[]): CatalogStore {
+  const state = { sessions: new Map(sessions.map((s) => [s.id, s])) };
+  return {
+    snapshot: () => state,
+    subscribe: (fn: CatalogListener) => {
+      fn(state);
+      return () => {};
+    },
+  } as unknown as CatalogStore;
+}
+
+function mount(sessions: Session[] = [session("alpha", "/home/n/alpha")]) {
+  const handle = renderSidebar(storeWith(sessions));
+  document.body.appendChild(handle.el);
+  const search = handle.el.querySelector<HTMLInputElement>(".search")!;
+  const opens: number[] = [];
+  const listener = () => opens.push(1);
+  document.addEventListener(OPEN_COMMAND_BAR_EVENT, listener);
+  return {
+    handle,
+    search,
+    opens,
+    dispose: () => {
+      document.removeEventListener(OPEN_COMMAND_BAR_EVENT, listener);
+      handle.dispose();
+      handle.el.remove();
+    },
+  };
+}
+
+describe("sidebar search field opens the command bar (#157)", () => {
+  it("asks the shell to open the bar when the field is focused", () => {
+    const t = mount();
+    t.search.dispatchEvent(new FocusEvent("focus"));
+    expect(t.opens).toHaveLength(1);
+    t.dispose();
+  });
+
+  it("opens on a tap, where a focus event may never arrive", () => {
+    const t = mount();
+    t.search.dispatchEvent(new Event("pointerdown", { bubbles: true }));
+    expect(t.opens).toHaveLength(1);
+    t.dispose();
+  });
+
+  it("does not trap the keyboard in the field: it gives focus up on open", () => {
+    const t = mount();
+    t.search.focus();
+    expect(document.activeElement).not.toBe(t.search);
+    t.dispose();
+  });
+
+  it("opens the bar with an empty query — the field never holds one", () => {
+    const t = mount();
+    t.search.focus();
+    expect(t.search.value).toBe("");
+    t.dispose();
+  });
+
+  it("is readonly: no on-screen keyboard over a field nothing is typed into", () => {
+    const t = mount();
+    expect(t.search.readOnly).toBe(true);
+    t.dispose();
+  });
+
+  it("no longer filters the tree in place", () => {
+    const t = mount([session("alpha", "/home/n/alpha"), session("beta", "/home/n/beta")]);
+    t.search.value = "alpha";
+    t.search.dispatchEvent(new Event("input"));
+    expect(t.handle.el.querySelectorAll(".tree-leaf")).toHaveLength(2);
+    t.dispose();
+  });
+
+  it("has no 'No matches' state left: an empty catalog is empty, not filtered", () => {
+    const t = mount([]);
+    expect(t.handle.el.querySelector(".empty-title")?.textContent).toBe("No sessions yet");
+    t.dispose();
+  });
+});
+
+// The inline filter matched a session on its name and its directory, case- and
+// whitespace-insensitively. That behaviour did not go away with the field — it
+// moved into the bar, which ranks the same two fields (docs/COMMAND-BAR.md).
+describe("what the retired inline filter did, the bar now does", () => {
+  it("matches a session on both its name and its directory", () => {
+    const sessions = [session("alpha", "/home/n/alpha"), session("beta", "/home/n/beta")];
+    const candidates = sessionBarCandidates(sessions, "/home/n");
+
+    const byName = matchAndRank("alpha", candidates).map((r) => r.candidate.session.id);
+    expect(byName).toEqual(["alpha"]);
+
+    const byDir = matchAndRank("beta", candidates).map((r) => r.candidate.session.id);
+    expect(byDir).toEqual(["beta"]);
+  });
+
+  it("ignores case and surrounding whitespace, and shows nothing on no match", () => {
+    const candidates = sessionBarCandidates([session("alpha", "/home/n/Alpha")], "/home/n");
+
+    expect(matchAndRank("  ALPHA  ", candidates)).toHaveLength(1);
+    expect(matchAndRank("zzz", candidates)).toHaveLength(0);
+  });
+});

web/src/styles.css

@@ -1202,18 +1202,24 @@ textarea {
 }
 
 /* 5. The row the content pane is previewing right now. Last, so previewing a
-   session that is already open still reads as provisional. */
-.tree-leaf:where(.is-previewing) {
+   session that is already open still reads as provisional — except the session
+   already mounted in the pane (tier 4). Previewing that one changes nothing on
+   screen, so its accent stays put instead of blinking out under the pointer. */
+.tree-leaf:where(.is-previewing):where(:not(.is-active)) {
   background: var(--preview-tint);
 }
 
 /* Exited sessions recede: dimmed name + an "exited" badge carry status, so it's
-   never the running tint's absence alone doing the work. */
-.tree-leaf[data-status="dead"] {
+   never the running tint's absence alone doing the work. A dormant session
+   (#168, docs/SIDEBAR.md) reads the same muted way — it is known, not gone,
+   but there is nothing running behind it either. */
+.tree-leaf[data-status="dead"],
+.tree-leaf.is-dormant {
   color: var(--muted);
 }
 
-.tree-leaf[data-status="dead"] .leaf-name {
+.tree-leaf[data-status="dead"] .leaf-name,
+.tree-leaf.is-dormant .leaf-name {
   color: var(--muted);
   font-weight: 400;
 }
@@ -1558,7 +1564,10 @@ input.leaf-rename:focus {
 }
 
 /* Phone: the bottom-sheet treatment the spawn modal already uses. */
-@media (max-width: 600px) {
+/* Bottom sheet at phone width, the same treatment (and the same 599px break)
+   the spawn modal uses: the bar is reached by thumb here, through the sidebar's
+   search field (#157), so it rides the bottom of the screen. */
+@media (max-width: 599px) {
   .cmdbar-overlay {
     grid-template-rows: 1fr auto;
     padding: 0;
@@ -1567,9 +1576,21 @@ input.leaf-rename:focus {
   .cmdbar-panel {
     grid-row: 2;
     width: 100%;
-    max-height: 70vh;
+    max-height: 70dvh;
     border-radius: var(--r-3) var(--r-3) 0 0;
     border-bottom: 0;
+    padding-bottom: env(safe-area-inset-bottom, 0px);
+  }
+
+  /* Thumb-sized rows and a field that clears the on-screen keyboard's
+     zoom-on-focus threshold (16px). */
+  .cmdbar-input {
+    font-size: var(--fs-17);
+    min-height: 44px;
+  }
+
+  .cmdbar-row {
+    min-height: 44px;
   }
 }
 
@@ -1737,7 +1758,8 @@ input.leaf-rename:focus {
   }
 }
 
-.leaf-clone:hover {
+.leaf-clone:hover,
+.leaf-resume:hover {
   color: var(--accent);
   background: var(--accent-tint);
   border-color: color-mix(in oklab, var(--accent) 40%, transparent);
@@ -3248,6 +3270,42 @@ input.leaf-rename:focus {
   font-size: var(--fs-13);
 }
 
+/* #168: what a pane shows for a dormant session — its metadata and a resume
+   action, in place of the live terminal there is nothing to attach to. */
+.mv-pane-dormant {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: var(--sp-2);
+  padding: var(--sp-4);
+  text-align: center;
+  color: var(--muted);
+}
+.mv-dormant-glyph {
+  font-size: 28px;
+  color: var(--faint);
+}
+.mv-dormant-name {
+  font-size: var(--fs-15);
+  font-weight: 500;
+  color: var(--ink);
+}
+.mv-dormant-cwd {
+  font-size: var(--fs-12);
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.mv-dormant-detail {
+  font-size: var(--fs-12);
+}
+.mv-dormant-resume {
+  margin-top: var(--sp-2);
+}
+
 /* pane tools cluster (disconnect / split / close), top-right corner. The attach
    header's own disconnect button is hidden — ⏻ lives here as the leftmost tool. */
 .mv-pane-tools {

web/src/tree.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { buildTree, mergeLinear, type TreeFolder, type TreeNode } from "./tree.js";
+import { buildTree, compareNodes, mergeLinear, type TreeFolder, type TreeNode } from "./tree.js";
 import type { Session } from "./types.js";
 
 function session(id: string, cwd: string, command = "bash"): Session {
@@ -26,7 +26,6 @@ describe("buildTree", () => {
     const root = buildTree(
       [session("a", "/home/n/work"), session("b", "/home/n/work")],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(names(root)).toEqual(["~/work"]);
@@ -35,7 +34,7 @@ describe("buildTree", () => {
   });
 
   it("collapses a linear chain into one folder", () => {
-    const root = buildTree([session("a", "/home/n/git/naps62/maestro")], "/home/n", "") as TreeFolder;
+    const root = buildTree([session("a", "/home/n/git/naps62/maestro")], "/home/n") as TreeFolder;
     expect(names(root)).toEqual(["~/git/naps62/maestro"]);
   });
 
@@ -43,7 +42,6 @@ describe("buildTree", () => {
     const root = buildTree(
       [session("a", "/home/n/subvisual/bullish"), session("b", "/home/n/tea/maestro")],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(names(root).sort()).toEqual(["~/subvisual/bullish", "~/tea/maestro"]);
@@ -53,7 +51,6 @@ describe("buildTree", () => {
     const root = buildTree(
       [session("a", "/home/n/git/one"), session("b", "/home/n/git/two")],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(names(root)).toEqual(["~/git"]);
@@ -65,29 +62,46 @@ describe("buildTree", () => {
     const root = buildTree(
       [session("loose", ""), session("nested", "/home/n/work")],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(root.children[0].kind).toBe("folder");
     expect(root.children[1].kind).toBe("leaf");
   });
 
-  it("filters on both session name and directory", () => {
-    const sessions = [session("a", "/home/n/alpha", "claude"), session("b", "/home/n/beta", "bash")];
-
-    const byDir = buildTree(sessions, "/home/n", "alpha") as TreeFolder;
-    expect(names(byDir)).toEqual(["~/alpha"]);
-
-    const byCommand = buildTree(sessions, "/home/n", "claude") as TreeFolder;
-    expect(names(byCommand)).toEqual(["~/alpha"]);
-
-    const noMatch = buildTree(sessions, "/home/n", "zzz") as TreeFolder;
-    expect(noMatch.children).toEqual([]);
+  // #168, docs/SIDEBAR.md: a dormant session takes the lowest precedence in
+  // the ordering, so live work always sorts above it, even a name that would
+  // otherwise sort first.
+  it("sorts a dormant session after live ones in the same folder, name notwithstanding", () => {
+    const dormant = { ...session("aaa-dormant", "/home/n/work"), status: "Dormant" } as Session;
+    const live = session("zzz-live", "/home/n/work");
+    const root = buildTree([dormant, live], "/home/n") as TreeFolder;
+    const folder = root.children[0] as TreeFolder;
+    const ids = folder.children.map((c) => (c.kind === "leaf" ? c.session.id : c.name));
+    expect(ids).toEqual(["zzz-live", "aaa-dormant"]);
   });
 
-  it("ignores case and surrounding whitespace in the filter", () => {
-    const root = buildTree([session("a", "/home/n/Alpha")], "/home/n", "  ALPHA  ") as TreeFolder;
-    expect(root.children).toHaveLength(1);
+  it("still sorts dormant sessions by name against each other", () => {
+    const a = {
+      ...session("a", "/home/n/work"),
+      status: "Dormant",
+      metadata: { name: "a" },
+    } as Session;
+    const b = {
+      ...session("b", "/home/n/work"),
+      status: "Dormant",
+      metadata: { name: "b" },
+    } as Session;
+    const root = buildTree([b, a], "/home/n") as TreeFolder;
+    const folder = root.children[0] as TreeFolder;
+    const ids = folder.children.map((c) => (c.kind === "leaf" ? c.session.id : c.name));
+    expect(ids).toEqual(["a", "b"]);
+  });
+
+  it("exposes the leaf/name precedence directly via compareNodes", () => {
+    const dormant: TreeNode = { kind: "leaf", session: { ...session("a", "/x"), status: "Dormant" } };
+    const live: TreeNode = { kind: "leaf", session: session("b", "/x") };
+    expect(compareNodes(dormant, live)).toBeGreaterThan(0);
+    expect(compareNodes(live, dormant)).toBeLessThan(0);
   });
 });
 
@@ -127,7 +141,6 @@ describe("worktree sessions group under their repository (#99)", () => {
         ),
       ],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(topFolders(root)).toEqual(["~/tea/agent-skills"]);
@@ -147,7 +160,6 @@ describe("worktree sessions group under their repository (#99)", () => {
         ),
       ],
       "/home/n",
-      "",
     ) as TreeFolder;
 
     expect(topFolders(root)).toEqual(["~/tea/agent-skills"]);
@@ -157,7 +169,7 @@ describe("worktree sessions group under their repository (#99)", () => {
   });
 
   it("leaves a session without a worktree where it is", () => {
-    const root = buildTree([session("a", "/home/n/tea/arr")], "/home/n", "") as TreeFolder;
+    const root = buildTree([session("a", "/home/n/tea/arr")], "/home/n") as TreeFolder;
     expect(topFolders(root)).toEqual(["~/tea/arr"]);
   });
 });

web/src/tree.ts

@@ -18,26 +18,29 @@ export interface TreeLeaf {
 
 export type TreeNode = TreeFolder | TreeLeaf;
 
+/** docs/SIDEBAR.md: a dormant session takes the lowest precedence in the
+ * ordering, so live work always sorts above it regardless of name. */
+function dormantRank(node: TreeNode): number {
+  return node.kind === "leaf" && node.session.status === "Dormant" ? 1 : 0;
+}
+
 export function compareNodes(a: TreeNode, b: TreeNode): number {
   if (a.kind !== b.kind) return a.kind === "folder" ? -1 : 1;
+  const rank = dormantRank(a) - dormantRank(b);
+  if (rank !== 0) return rank;
   const an = a.kind === "folder" ? a.name : sessionName(a.session);
   const bn = b.kind === "folder" ? b.name : sessionName(b.session);
   return an.localeCompare(bn);
 }
 
-export function buildTree(sessions: Session[], home: string | undefined, filter: string): TreeNode {
+export function buildTree(sessions: Session[], home: string | undefined): TreeNode {
   const root: TreeFolder = { kind: "folder", name: "", path: "", children: [] };
-  const lc = filter.trim().toLowerCase();
 
   for (const s of sessions) {
     // Grouped by repository, so a worktree session lands under its repo
     // rather than in a folder of its own (#99).
     const cwd = sessionTreePath(s);
     const dir = cwd ? abbreviateCwd(cwd, home) : "";
-    if (lc) {
-      const haystack = `${sessionName(s)} ${dir}`.toLowerCase();
-      if (!haystack.includes(lc)) continue;
-    }
     const parts = dir ? dir.split("/").filter(Boolean) : [];
     let cursor = root;
     for (const part of parts) {

web/src/types.ts

@@ -6,7 +6,10 @@ import { escapeHtml } from "./html.js";
 export type Uuid = string;
 export type IsoTimestamp = string;
 
-export type SessionStatus = "Running" | "Dead";
+/** `Dormant` (#162) is a session the daemon knows only from its sidecar —
+ * recovered after the tmux server died under it, so there is no pane behind it
+ * and nothing to attach to. Listed, never live. */
+export type SessionStatus = "Running" | "Dead" | "Dormant";
 
 /** Daemon-inferred activity dimension, orthogonal to `SessionStatus` (NAP-340).
  * Absent on payloads from daemons that predate the field. `Error` is only set
@@ -98,6 +101,10 @@ export interface DaemonInfo {
    * value across a reconnect means the daemon restarted. Absent on older
    * daemons, which the restart flow treats as "cannot tell". */
   instance?: string;
+  /** Canonical leader key the operator configured (`[tui].leader`, default
+   * `ctrl-a`), so the web binds the same chord the TUI does (#159). Absent or
+   * empty on an older daemon; the client then keeps its own default. */
+  leader?: string;
 }
 
 /** Build provenance of the running daemon: what the status indicator names in