feat(maestro): skip the tmux probe on a detected host reboot

Recovery could not tell a daemon restart from a host reboot: both
looked like "some sessions were not in tmux list-sessions", so the
tmux probe ran unconditionally and the logs said nothing useful when
it was actually a reboot.

Record /proc/sys/kernel/random/boot_id in the state directory on
every recover(). When it differs from the stored value, every session
from the previous boot is provably dead, so the tmux probe is skipped
and the second recovery pass registers them dormant directly, logging
"host rebooted, sessions dormant" with the count. A missing stored
value or an unreadable boot id (non-Linux, restricted /proc) falls
back to today's probe-based recovery.

The boot id source is injected via a BootIdSource trait so tests can
simulate a changed or unreadable boot id without rebooting the
machine.

Refs #164

crates/maestro-cli/src/sessions.rs

@@ -253,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,7 +28,6 @@ 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

@@ -313,19 +313,16 @@ 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,
         },
     ]
 }
@@ -337,7 +334,6 @@ pub fn custom_preset() -> SpawnPreset {
         id: CUSTOM_PRESET_ID.into(),
         label: "Custom…".into(),
         command: String::new(),
-        resume_command: None,
     }
 }
 
@@ -511,18 +507,6 @@ 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.
@@ -531,7 +515,6 @@ auto_install = false
                 id: "fish".into(),
                 label: "fish".into(),
                 command: "fish".into(),
-                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -568,7 +551,6 @@ auto_install = false
                 id: "  ".into(),
                 label: "x".into(),
                 command: "x".into(),
-                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -579,7 +561,6 @@ auto_install = false
                 id: "x".into(),
                 label: "x".into(),
                 command: "".into(),
-                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -597,13 +578,11 @@ 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()
@@ -618,7 +597,6 @@ auto_install = false
                 id: "custom".into(),
                 label: "Custom".into(),
                 command: "whatever".into(),
-                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -654,27 +632,6 @@ 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.

crates/maestro-daemon/src/boot_id.rs

@@ -0,0 +1,62 @@
+//! 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: a difference means every session from
+//! before is provably dead, so the tmux probe can be skipped and those
+//! sessions registered dormant directly instead of relying on tmux reporting
+//! an empty list.
+
+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,11 @@ 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,
-    ));
+    ))
+    .with_boot_id(
+        config.boot_id_path(),
+        std::sync::Arc::new(crate::boot_id::ProcBootId),
+    );
     // 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));

crates/maestro-daemon/src/config.rs

@@ -112,6 +112,12 @@ impl DaemonConfig {
     pub fn spawn_history_path(&self) -> PathBuf {
         self.state_dir.join("spawn-history.jsonl")
     }
+
+    /// 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

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;

crates/maestro-daemon/src/local_api.rs

@@ -307,7 +307,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();

crates/maestro-daemon/src/session.rs

@@ -19,6 +19,7 @@ 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::sidecar::{SidecarError, SidecarStore};
@@ -179,6 +180,25 @@ struct Inner {
     /// 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>,
+}
+
+/// 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 {
@@ -221,6 +241,7 @@ impl SessionManager {
                 events,
                 viewports: Mutex::new(Viewports::new()),
                 next_viewport: AtomicU64::new(0),
+                boot_id: None,
             }),
         }
     }
@@ -250,6 +271,21 @@ 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.
+    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
+    }
+
     /// 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
@@ -491,6 +527,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) {
@@ -664,9 +701,21 @@ 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: when the kernel's boot id has changed since the last run, the
+    /// tmux probe below is skipped entirely — a reboot kills the tmux server,
+    /// so every previous session is already dead and there is nothing tmux
+    /// could truthfully adopt. [`Self::register_dormant`] then registers all
+    /// of them directly.
     pub async fn recover(&self) -> Result<usize, SessionError> {
         tokio::fs::create_dir_all(&self.inner.fifo_dir).await?;
-        let live = {
+        let rebooted = self.check_boot_id().await;
+        let live = if rebooted {
+            // #164: every session from the previous boot is provably dead —
+            // no tmux server survives a reboot — so there is nothing to gain
+            // from asking it and no session it could honestly report back.
+            Vec::new()
+        } else {
             let tmux = self.inner.tmux.clone();
             tmux_blocking(move || tmux.list_sessions()).await?
         };
@@ -696,6 +745,7 @@ 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"));
@@ -735,10 +785,39 @@ impl SessionManager {
                 .send(CatalogEvent::SessionAdded { session });
             adopted += 1;
         }
-        self.register_dormant().await;
+        self.register_dormant(rebooted).await;
         Ok(adopted)
     }
 
+    /// 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", which is today's behaviour: fall back to probing tmux.
+    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.
     ///
@@ -754,7 +833,17 @@ impl SessionManager {
     ///
     /// 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.
-    async fn register_dormant(&self) {
+    ///
+    /// #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.
+    async fn register_dormant(&self, rebooted: bool) {
         let stored = match self.inner.sidecar.load_all() {
             Ok(stored) => stored,
             Err(e) => {
@@ -763,6 +852,7 @@ impl SessionManager {
             }
         };
         let mut registered = Vec::new();
+        let mut pruned = 0usize;
         {
             let mut sessions = self.inner.sessions.lock().await;
             for mut session in stored {
@@ -770,6 +860,13 @@ impl SessionManager {
                     // 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");
+                    }
+                    pruned += 1;
+                    continue;
+                }
                 let id = session.id;
                 session.status = SessionStatus::Dormant;
                 session.foreground = None;
@@ -797,12 +894,20 @@ impl SessionManager {
                 registered.push(session);
             }
         }
-        if !registered.is_empty() {
+        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");
+        }
         for session in registered {
             let _ = self
                 .inner
@@ -969,11 +1074,18 @@ 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. It is
+    /// written once — the first report that carries one wins — and the
+    /// sidecar is only rewritten on that transition, never on every report,
+    /// since an agent's session id never changes mid-session.
     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;
@@ -989,7 +1101,16 @@ impl SessionManager {
                 state,
                 self.inner.report_ttl,
             ));
-            changed.then(|| rec.session.clone())
+            let newly_identified =
+                rec.session.agent_session_id.is_none() && agent_session_id.is_some();
+            if newly_identified {
+                rec.session.agent_session_id = agent_session_id;
+                self.inner
+                    .sidecar
+                    .write(&rec.session)
+                    .map_err(SessionError::Sidecar)?;
+            }
+            (changed || newly_identified).then(|| rec.session.clone())
         };
         if let Some(session) = updated {
             let _ = self

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,55 @@ 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: a session id does not change mid-session, so once set it is never
+/// overwritten by a later report — even one that names a different id.
+#[tokio::test]
+async fn a_reported_session_id_is_written_once_and_never_replaced() {
+    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-first"));
+}
+
+#[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"));
+}

crates/maestro-daemon/tests/local_api.rs

@@ -526,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/session_manager.rs

@@ -234,6 +234,222 @@ async fn recover_does_not_mark_adopted_sessions_dormant() {
     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))),
+    )
+}
+
+/// #164: a changed boot id means every session from the previous boot is
+/// already dead, so recovery must not trust tmux to say so — it skips the
+/// probe outright. Proven by leaving the tmux session alive: if the probe
+/// ran, it would come back `Running`, not `Dormant`.
+#[tokio::test]
+async fn recover_skips_tmux_probe_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 — a probe would find it if one ran.
+    let revived = revive_with_boot_id(&fx, boot_id_path.clone(), Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0, "reboot detected: nothing adopted live");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1);
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+
+    // 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: 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.

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-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.
@@ -212,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
@@ -517,11 +529,8 @@ 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>,
 }
 
 /// Build provenance of the running daemon: the commit it was compiled
@@ -893,6 +902,7 @@ mod tests {
             current_cwd: Some(PathBuf::from("/home/naps62/projects/maestro/crates")),
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -1062,6 +1072,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));
 

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

@@ -1898,6 +1898,7 @@ mod tests {
                     current_cwd: None,
                     blocked_work: None,
                     last_focused_at: None,
+                    agent_session_id: None,
                 })
                 .collect(),
         });
@@ -2079,6 +2080,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::SidebarNext);
@@ -2106,6 +2108,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -3214,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 {
@@ -3492,6 +3496,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::KillHighlighted);
@@ -3527,6 +3532,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
+                agent_session_id: 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

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

crates/maestro-tui/src/draft.rs

@@ -1705,7 +1705,6 @@ mod tests {
             id: "aider".into(),
             label: "Aider".into(),
             command: "aider".into(),
-            resume_command: None,
         }]);
         assert_eq!(
             draft.command(),
@@ -1728,13 +1727,11 @@ mod tests {
                 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");
@@ -1754,7 +1751,6 @@ mod tests {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
-            resume_command: None,
         }]);
         assert!(draft.is_custom());
         assert_eq!(draft.command(), "bash -l");

crates/maestro-tui/src/fast_forward.rs

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

crates/maestro-tui/src/sidebar.rs

@@ -506,6 +506,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
+            agent_session_id: None,
         }
     }
 
@@ -1305,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],