@@ -71,6 +71,11 @@ prompt, not run: exactly as typed with the zsh hook (`dingger install
   zsh`, then source the file it names from your `.zshrc`), otherwise the
   program's arguments. An agent or program that exits within a minute
   before tmux stops (a shutdown) is still restored.
+  When tmux stops, the panel (first row: "↺ Restore 9 sessions · 22
+  agents", or "Not now"), the menu (all, or one session at a time), and the
+  status line (`↺9`, clickable) offer the restore; it runs through your
+  login shell, like a terminal starting tmux, and a notification
+  summarizes (full report: `~/.local/state/dingger/restore.log`).
 - All shortcuts live in `~/.config/dingger/config.toml` (menu bar,
   Settings…), reloaded on save.
 - **tmux status line** (`packaging/tmux/dingger.tmux`): the same summary after

@@ -2,9 +2,9 @@ # Roadmap
 
 In priority order.
 
-1. **Restore after a crash or shutdown.** Bring back tmux sessions, windows,
-   and panes (names, layout, directories) and resume each agent's own
-   session (`pi --session <file>`, `claude --resume <id>`, ...).
+1. ~~**Restore after a crash or shutdown.**~~ Done for pi (see the README).
+   Next: other agents' session references (claude's session id through its
+   hooks, `claude --resume <id>`; codex, ...).
 2. **Raise the right window.** Jumping to an agent activates the terminal
    app; with several windows (several Ghostty windows, say) it should raise
    the exact window that holds the tmux client, not whichever was last used.

@@ -72,6 +72,12 @@ from: Option<String>,
         /// Restore only these sessions.
         #[arg(long = "session")]
         sessions: Vec<String>,
+        /// Write the report to restore.log and notify a summary.
+        #[arg(long)]
+        report: bool,
+        /// Stop offering the saved layout (it can still be restored).
+        #[arg(long)]
+        dismiss: bool,
     },
     /// Install integrations: an agent's hook extension (state and session
     /// reports), or `zsh` (command lines for restore to retype).
@@ -90,11 +96,16 @@ Update,
 }
 
 fn main() {
+    platform::default_sigpipe();
+    let cli = Cli::parse();
+    // The daemon logs its work; commands print their own output and only
+    // log problems.
+    let default_level = if matches!(cli.command, Command::Watch { .. }) { "info" } else { "warn" };
     tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| default_level.into()))
         .init();
 
-    match Cli::parse().command {
+    match cli.command {
         Command::Watch {
             interval_secs,
             no_sounds,
@@ -134,8 +145,14 @@ Command::Poke => {
             // Best effort: a stopped watcher just means nothing to wake.
             let _ = hooks::poke();
         }
-        Command::Restore { dry_run, list, from, sessions } => {
-            let result = if list { restore::list() } else { restore::run(from.as_deref(), &sessions, dry_run) };
+        Command::Restore { dry_run, list, from, sessions, report, dismiss } => {
+            let result = if list {
+                restore::list()
+            } else if dismiss {
+                restore::dismiss()
+            } else {
+                restore::run(from.as_deref(), &sessions, dry_run, report)
+            };
             if let Err(err) = result {
                 eprintln!("dingger: {err}");
                 std::process::exit(1);

@@ -63,6 +63,19 @@ }
     }
 }
 
+/// Deliver a notification and wait for it: for short-lived commands, whose
+/// exit would cut a background delivery short.
+pub fn send_message_blocking(title: &str, body: &str) {
+    info!(title, body, "notifying");
+    if let Ok(command) = std::env::var("DINGGER_NOTIFIER") {
+        let _ = std::process::Command::new("sh").args(["-c", &command, title, body]).status();
+        return;
+    }
+    if let Err(err) = mac_notification_sys::Notification::new().title(title).message(body).send() {
+        warn!(%err, "failed to deliver macOS notification");
+    }
+}
+
 /// Deliver a macOS notification without blocking the caller: the delivery
 /// call waits on Notification Center for seconds, and the watcher must keep
 /// updating the UI meanwhile.

@@ -1,4 +1,21 @@
-//! macOS process inspection.
+//! macOS process inspection and process setup.
+
+/// Exit quietly when stdout closes early (`dingger restore --list | head`),
+/// like other command-line tools, instead of panicking: Rust ignores
+/// SIGPIPE by default.
+#[cfg(unix)]
+pub fn default_sigpipe() {
+    extern "C" {
+        fn signal(signum: std::os::raw::c_int, handler: usize) -> usize;
+    }
+    const SIGPIPE: std::os::raw::c_int = 13;
+    const SIG_DFL: usize = 0;
+    // SAFETY: resets one signal to its default disposition before any
+    // threads start.
+    unsafe {
+        signal(SIGPIPE, SIG_DFL);
+    }
+}
 
 /// A process's exact argument vector, from the kernel (`KERN_PROCARGS2`):
 /// unlike `ps`, it keeps arguments that contain spaces intact.

@@ -18,6 +18,27 @@
 use crate::snapshot::{self, shell_quote, PaneSnap, SessionSnap, Snapshot, WindowSnap};
 use crate::tmux;
 
+thread_local! {
+    static REPORT: std::cell::RefCell<Vec<String>> = const { std::cell::RefCell::new(Vec::new()) };
+}
+
+/// Print a report line, and keep it for `--report`.
+fn say(line: String) {
+    println!("{line}");
+    REPORT.with(|report| report.borrow_mut().push(line));
+}
+
+/// What a restore did, for the summary notification.
+#[derive(Debug, Default)]
+pub struct Summary {
+    pub sessions: usize,
+    pub failed: usize,
+    pub agents: usize,
+    pub resumed: usize,
+    pub interrupted: usize,
+    pub typed: usize,
+}
+
 /// What restore types into a rebuilt pane.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Typed {
@@ -239,7 +260,7 @@
 /// Wait for each new shell's prompt, then resume agents (spaced out) and
 /// type the other command lines without running them; report which agents
 /// did not start.
-fn type_commands(rebuilt: &[Rebuilt]) {
+fn type_commands(rebuilt: &[Rebuilt], summary: &mut Summary) {
     let work: Vec<(&Rebuilt, Typed)> =
         rebuilt.iter().filter_map(|r| typed_for(&r.pane).map(|typed| (r, typed))).collect();
     if work.is_empty() {
@@ -266,21 +287,23 @@ match typed {
             Typed::Resume(command) => {
                 let _ = tmux::run(&["send-keys", "-t", &r.pane_id, "-l", command]);
                 let _ = tmux::run(&["send-keys", "-t", &r.pane_id, "Enter"]);
-                println!("resume   {}  {command}", r.label);
+                say(format!("resume   {}  {command}", r.label));
                 resumed.push(*r);
                 // Agents start one at a time.
                 std::thread::sleep(Duration::from_millis(500));
             }
             Typed::Retype(command) => {
                 let _ = tmux::run(&["send-keys", "-t", &r.pane_id, "-l", command]);
-                println!("type     {}  {command}  (press Enter to run)", r.label);
+                say(format!("type     {}  {command}  (press Enter to run)", r.label));
+                summary.typed += 1;
             }
         }
     }
     for (r, _) in &work {
         if let Some(agent) = r.pane.agent.as_ref().filter(|agent| agent.state == "working") {
             let name = if agent.name.is_empty() { &agent.agent } else { &agent.name };
-            println!("interrupted  {}  {name}: it was working, its turn was cut short", r.label);
+            say(format!("interrupted  {}  {name}: it was working, its turn was cut short", r.label));
+            summary.interrupted += 1;
         }
     }
     if resumed.is_empty() {
@@ -297,9 +320,11 @@ .map(|command| is_shell(command.trim()))
                 .unwrap_or(true)
         });
     }
-    println!("resumed {} of {} agents", resumed.len() - not_running.len(), resumed.len());
+    summary.agents = resumed.len();
+    summary.resumed = resumed.len() - not_running.len();
+    say(format!("resumed {} of {} agents", summary.resumed, summary.agents));
     for r in not_running {
-        println!("not running  {}: check the pane for the error", r.label);
+        say(format!("not running  {}: check the pane for the error", r.label));
     }
 }
 
@@ -348,9 +373,59 @@ .map(|out| String::from_utf8_lossy(&out.stdout).trim().to_string())
         .unwrap_or_else(|_| ms.to_string())
 }
 
-/// Restore missing sessions (all, or only `only`).
-pub fn run(from: Option<&str>, only: &[String], dry_run: bool) -> Result<(), String> {
+/// Restore missing sessions (all, or only `only`). With `report`, also
+/// write the report to `restore.log` and notify a summary.
+pub fn run(from: Option<&str>, only: &[String], dry_run: bool, report: bool) -> Result<(), String> {
+    let result = restore(from, only, dry_run);
+    if report && !dry_run {
+        let lines = REPORT.with(|report| report.borrow().join("\n"));
+        let _ = std::fs::write(snapshot::state_dir().join("restore.log"), format!("{lines}\n"));
+        let (title, body) = match &result {
+            Ok(summary) => summary_message(summary),
+            Err(err) => ("tmux restore failed".to_string(), err.clone()),
+        };
+        crate::notify::send_message_blocking(&title, &body);
+    }
+    let _ = crate::hooks::poke();
+    result.map(|_| ())
+}
+
+fn plural(n: usize, one: &str, many: &str) -> String {
+    format!("{n} {}", if n == 1 { one } else { many })
+}
+
+pub fn summary_message(summary: &Summary) -> (String, String) {
+    let title = format!("Restored {}", plural(summary.sessions, "tmux session", "tmux sessions"));
+    let mut parts = Vec::new();
+    if summary.agents > 0 {
+        parts.push(format!("resumed {} of {}", summary.resumed, plural(summary.agents, "agent", "agents")));
+    }
+    if summary.interrupted > 0 {
+        parts.push(format!("{} mid-turn", plural(summary.interrupted, "was", "were")));
+    }
+    if summary.typed > 0 {
+        parts.push(format!("{} typed, not run", plural(summary.typed, "command", "commands")));
+    }
+    if summary.failed > 0 {
+        parts.push(format!("{} failed", plural(summary.failed, "session", "sessions")));
+    }
+    if parts.is_empty() {
+        parts.push("nothing else to resume".into());
+    }
+    (title, parts.join(" · "))
+}
+
+/// Mark the restore candidate dismissed: no more offers for it.
+pub fn dismiss() -> Result<(), String> {
+    snapshot::set_candidate_status("dismissed")?;
+    let _ = crate::hooks::poke();
+    println!("dismissed; `dingger restore` still restores it");
+    Ok(())
+}
+
+fn restore(from: Option<&str>, only: &[String], dry_run: bool) -> Result<Summary, String> {
     let snapshot = source(from)?;
+    let mut summary = Summary::default();
     let existing = existing_sessions();
     let mut failures = 0;
     let mut rebuilt = Vec::new();
@@ -364,19 +439,19 @@ };
         let what = windows_and_panes(session);
         let verb = match plan {
             Plan::Keep => {
-                println!("keep     {name}: it exists");
+                say(format!("keep     {name}: it exists"));
                 continue;
             }
             Plan::Create => "create",
             Plan::Replace => "replace",
         };
         if dry_run {
-            println!("{verb:<8} {name}: {what}");
+            say(format!("{verb:<8} {name}: {what}"));
             for window in &session.windows {
                 for pane in &window.panes {
                     match typed_for(pane) {
-                        Some(Typed::Resume(command)) => println!("  resume  {}  {command}", window.name),
-                        Some(Typed::Retype(command)) => println!("  type    {}  {command}", window.name),
+                        Some(Typed::Resume(command)) => say(format!("  resume  {}  {command}", window.name)),
+                        Some(Typed::Retype(command)) => say(format!("  type    {}  {command}", window.name)),
                         None => {}
                     }
                 }
@@ -388,23 +463,124 @@ Plan::Replace => replace_session(session, &mut rebuilt),
             _ => build_session(session, &name, &mut rebuilt).map(|_| ()),
         };
         match result {
-            Ok(()) => println!("{verb:<8} {name}: {what}"),
+            Ok(()) => {
+                summary.sessions += 1;
+                say(format!("{verb:<8} {name}: {what}"));
+            }
             Err(err) => {
                 failures += 1;
-                println!("FAILED   {name}: {err}");
+                say(format!("FAILED   {name}: {err}"));
             }
         }
     }
     if !rebuilt.is_empty() {
-        type_commands(&rebuilt);
+        type_commands(&rebuilt, &mut summary);
     }
-    if dry_run || from.is_some() {
-        return if failures == 0 { Ok(()) } else { Err(format!("{failures} sessions failed")) };
+    summary.failed = failures;
+    if !dry_run && from.is_none() && missing(&snapshot, &existing_sessions()).is_empty() {
+        let _ = snapshot::set_candidate_status("restored");
+    }
+    if failures == 0 { Ok(summary) } else { Err(format!("{failures} sessions failed")) }
+}
+
+/// One session restore would bring back, as offered to the user.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub struct OfferedSession {
+    pub name: String,
+    pub windows: usize,
+    pub panes: usize,
+    pub agents: usize,
+}
+
+/// The restore offer the menu bar app shows (`offer.json`).
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub struct Offer {
+    pub saved_at: u64,
+    pub sessions: Vec<OfferedSession>,
+    pub agents: usize,
+    /// Agents that were mid-turn when tmux stopped.
+    pub interrupted: usize,
+}
+
+pub fn offer(snapshot: &Snapshot, existing: &[Existing]) -> Option<Offer> {
+    let missing = missing(snapshot, existing);
+    let sessions: Vec<&SessionSnap> =
+        snapshot.sessions.iter().filter(|session| missing.contains(&session.name)).collect();
+    if sessions.is_empty() {
+        return None;
     }
-    if missing(&snapshot, &existing_sessions()).is_empty() {
-        let _ = snapshot::set_candidate_status("restored");
+    let panes = |session: &&SessionSnap| session.windows.iter().flat_map(|w| &w.panes).cloned().collect::<Vec<_>>();
+    let agents = sessions.iter().flat_map(panes).filter(|pane| pane.agent.is_some()).count();
+    let interrupted = sessions
+        .iter()
+        .flat_map(panes)
+        .filter(|pane| pane.agent.as_ref().is_some_and(|agent| agent.state == "working"))
+        .count();
+    Some(Offer {
+        saved_at: snapshot.saved_at,
+        sessions: sessions
+            .iter()
+            .map(|session| OfferedSession {
+                name: session.name.clone(),
+                windows: session.windows.len(),
+                panes: session.windows.iter().map(|w| w.panes.len()).sum(),
+                agents: panes(session).iter().filter(|pane| pane.agent.is_some()).count(),
+            })
+            .collect(),
+        agents,
+        interrupted,
+    })
+}
+
+/// Keeps `offer.json` and the `@dingger_restore` option current; called by
+/// the watcher every loop.
+#[derive(Default)]
+pub struct OfferPublisher {
+    candidate: Option<(std::time::SystemTime, Option<snapshot::Candidate>)>,
+    published: Option<Option<Offer>>,
+}
+
+impl OfferPublisher {
+    pub fn tick(&mut self) {
+        let path = snapshot::state_dir().join("restore.json");
+        let modified = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
+        let stale = match (&self.candidate, modified) {
+            (Some((at, _)), Some(modified)) => *at != modified,
+            (None, _) => true,
+            (Some(_), None) => true,
+        };
+        if stale {
+            self.candidate = Some((modified.unwrap_or(std::time::UNIX_EPOCH), snapshot::candidate()));
+        }
+        let offered = self
+            .candidate
+            .as_ref()
+            .and_then(|(_, candidate)| candidate.as_ref())
+            .filter(|candidate| candidate.status == "offered");
+        let offer = offered.and_then(|candidate| offer(&candidate.snapshot, &existing_sessions()));
+        if self.published.as_ref() == Some(&offer) {
+            return;
+        }
+        let file = snapshot::state_dir().join("offer.json");
+        match &offer {
+            Some(offer) => {
+                if let Ok(json) = serde_json::to_string_pretty(offer) {
+                    let tmp = file.with_extension("tmp");
+                    if std::fs::write(&tmp, json).is_ok() {
+                        let _ = std::fs::rename(&tmp, &file);
+                    }
+                }
+                let set = tmux::run(&["set-option", "-g", "@dingger_restore", &offer.sessions.len().to_string()]);
+                tracing::info!(sessions = offer.sessions.len(), agents = offer.agents, ok = set.is_ok(), "restore offered");
+            }
+            None => {
+                let _ = std::fs::remove_file(&file);
+                let unset = tmux::run(&["set-option", "-g", "-u", "@dingger_restore"]);
+                tracing::info!(?unset, "restore offer withdrawn");
+            }
+        }
+        self.published = Some(offer);
     }
-    if failures == 0 { Ok(()) } else { Err(format!("{failures} sessions failed")) }
 }
 
 #[cfg(test)]
@@ -491,6 +667,33 @@ agent.session = None;
         }
         pane.command = Some("pi --model x".into());
         assert_eq!(typed_for(&pane), Some(Typed::Retype("pi --model x".into())), "no session: retyped");
+    }
+
+    #[test]
+    fn offers_only_missing_sessions_with_their_agents() {
+        let mut saved = snapshot(&["0", "work"]);
+        saved.sessions[1].windows[0].panes[0].agent = Some(AgentSnap {
+            agent: "pi".into(),
+            name: "x".into(),
+            state: "working".into(),
+            session: None,
+        });
+        let offer = offer(&saved, &[Existing { name: "0".into(), bare: false }]).expect("work is missing");
+        assert_eq!(offer.sessions.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["work"]);
+        assert_eq!((offer.agents, offer.interrupted, offer.sessions[0].panes), (1, 1, 2));
+        assert_eq!(super::offer(&saved, &[
+            Existing { name: "0".into(), bare: false },
+            Existing { name: "work".into(), bare: false },
+        ]), None, "nothing missing, no offer");
+    }
+
+    #[test]
+    fn summarizes_a_restore() {
+        let summary = Summary { sessions: 9, agents: 22, resumed: 21, interrupted: 1, typed: 3, failed: 0 };
+        assert_eq!(
+            summary_message(&summary),
+            ("Restored 9 tmux sessions".into(), "resumed 21 of 22 agents · 1 was mid-turn · 3 commands typed, not run".into())
+        );
     }
 
     #[test]

@@ -182,6 +182,7 @@
 pub struct Watcher {
     tracks: HashMap<String, PaneTrack>,
     snapshots: crate::snapshot::Recorder,
+    offer: crate::restore::OfferPublisher,
     /// Last published (queue, blocked, done, working); avoids rewriting the
     /// global options every tick.
     last_published: Option<(String, usize, usize, usize)>,
@@ -195,6 +196,7 @@ pub fn new(interval_secs: u64, sounds: bool, notifications: bool) -> Self {
         Self {
             tracks: HashMap::new(),
             snapshots: Default::default(),
+            offer: Default::default(),
             last_published: None,
             interval_secs: interval_secs.max(1),
             sounds,
@@ -226,6 +228,7 @@ }
             }
             // After the tick, so snapshots carry the states it just wrote.
             self.snapshots.tick(unix_now());
+            self.offer.tick();
             debug!(ms = started.elapsed().as_millis() as u64, "tick");
             hooks::wait_for_wake(std::time::Duration::from_secs(self.interval_secs));
         }

@@ -25,6 +25,10 @@ //                    print what agent search would list for <query>, then exit
 //   --snapshot-search <png> <query> [<down>]
 //                    render agent search offscreen, then exit
 //   --click <pane>   perform a row click for <pane>, then exit
+//   --restore [<session>...]
+//                    restore saved tmux sessions as the panel and menu do
+//                    (through the login shell), then exit
+//   --dismiss-offer  dismiss the restore offer as "Not now" does, then exit
 //   --selftest       check the panel and search rules, then exit
 
 import AppKit
@@ -33,6 +37,17 @@ func log(_ message: String) {
     FileHandle.standardError.write(Data("\(Date()) \(message)\n".utf8))
 }
 
+/// Restore saved tmux sessions (all when `sessions` is empty) through the
+/// login shell, and log the report. Blocks until done.
+@discardableResult
+func performRestore(sessions: [String]) -> Bool {
+    let args = ["restore", "--report"] + sessions.flatMap { ["--session", $0] }
+    let result = runDinggerInLoginShell(args)
+    let lines = result.output.split(separator: "\n").filter { !$0.contains("can't change option: zle") }
+    log("restore: \(result.ok ? "done" : "failed")\n" + lines.map { "  \($0)" }.joined(separator: "\n"))
+    return result.ok
+}
+
 final class Menubar: NSObject, NSApplicationDelegate, NSMenuDelegate {
     private let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
     private let menu = NSMenu()
@@ -49,6 +64,8 @@ private var searchHotkey: Hotkey?
     private var searchHotkeyRegistered = false
     private var prefersFull = UserDefaults.standard.bool(forKey: "panelFull")
     private var rows: [Row] = []
+    private var restoreOffer: RestoreOffer?
+    private var restoring = false
 
     /// The panel settings; the first run after the on/off split migrates the
     /// old three-way mode.
@@ -71,7 +88,9 @@ menu.delegate = self
         item.menu = menu
         panel = PanelController(
             onClick: { [weak self] paneId in self?.jump(to: paneId) },
-            onToggleFull: { [weak self] in self?.toggleFull() })
+            onToggleFull: { [weak self] in self?.toggleFull() },
+            onRestore: { [weak self] in self?.restore(sessions: []) },
+            onDismissRestore: { [weak self] in self?.dismissRestore() })
         searchWindow = SearchController(onJump: { [weak self] paneId in self?.jump(to: paneId) })
         Settings.ensureFile()
         reloadSettings()
@@ -124,6 +143,8 @@ item.button?.toolTip = tipText
         item.button?.setAccessibilityLabel("dingger, " + tipText)
 
         visibility.anyWaiting = rows.contains(where: \.waiting)
+        restoreOffer = fetchRestoreOffer()
+        visibility.restoreOffered = restoreOffer != nil
         applyPanel()
         searchWindow.update(rows: rows)
     }
@@ -141,7 +162,8 @@
     private var panelContent: PanelContent {
         PanelContent(rows: rows,
                      full: panelShowsFull(policy: visibility.policy, prefersFull: prefersFull),
-                     canToggle: visibility.policy == .always)
+                     canToggle: visibility.policy == .always,
+                     offer: restoreOffer, restoring: restoring)
     }
 
     private func applyPanel() {
@@ -163,6 +185,7 @@
     private var panelState: String {
         "\(visibility.enabled ? "on" : "off"), \(visibility.policy.rawValue), "
             + (visibility.anyWaiting ? "agents waiting" : "nothing waiting")
+            + (visibility.restoreOffered ? ", restore offered" : "")
     }
 
     /// The shortcut and the menu item: turn the panel on or off, persistently.
@@ -188,6 +211,33 @@ DispatchQueue.main.async { self.refresh() }
         }
     }
 
+    /// Restore saved tmux sessions (all when `sessions` is empty).
+    func restore(sessions: [String], completion: (() -> Void)? = nil) {
+        guard !restoring else { return }
+        restoring = true
+        applyPanel()
+        log("restore: \(sessions.isEmpty ? "all sessions" : sessions.joined(separator: ", "))")
+        DispatchQueue.global().async {
+            performRestore(sessions: sessions)
+            DispatchQueue.main.async {
+                self.restoring = false
+                self.refresh()
+                completion?()
+            }
+        }
+    }
+
+    /// "Not now": stop offering this saved layout.
+    @objc private func dismissRestore() {
+        let result = runReporting(dinggerBinary, ["restore", "--dismiss"])
+        log("restore: dismissed (\(result.ok ? "ok" : result.output))")
+        refresh()
+    }
+
+    @objc private func restoreFromMenu(_ sender: NSMenuItem) {
+        restore(sessions: (sender.representedObject as? String).map { [$0] } ?? [])
+    }
+
     @objc private func selectPolicy(_ sender: NSMenuItem) {
         guard let raw = sender.representedObject as? String, let policy = PanelPolicy(rawValue: raw) else { return }
         visibility.policy = policy
@@ -213,6 +263,37 @@
     func menuNeedsUpdate(_ menu: NSMenu) {
         menu.removeAllItems()
         rows = fetchRows()
+        restoreOffer = fetchRestoreOffer()
+        if let offer = restoreOffer {
+            let item = NSMenuItem(title: restoring ? "Restoring tmux Sessions…" : "↺ \(offer.title)",
+                                  action: nil, keyEquivalent: "")
+            if !restoring {
+                let submenu = NSMenu()
+                let all = NSMenuItem(title: "Restore All", action: #selector(restoreFromMenu(_:)), keyEquivalent: "")
+                all.target = self
+                submenu.addItem(all)
+                submenu.addItem(.separator())
+                for session in offer.sessions {
+                    var detail = "\(session.windows) \(session.windows == 1 ? "window" : "windows")"
+                    if session.agents > 0 { detail += ", \(session.agents) \(session.agents == 1 ? "agent" : "agents")" }
+                    let one = NSMenuItem(title: session.name, action: #selector(restoreFromMenu(_:)), keyEquivalent: "")
+                    one.subtitle = detail
+                    one.target = self
+                    one.representedObject = session.name
+                    submenu.addItem(one)
+                }
+                submenu.addItem(.separator())
+                let later = NSMenuItem(title: "Not Now", action: #selector(dismissRestore), keyEquivalent: "")
+                later.target = self
+                submenu.addItem(later)
+                item.submenu = submenu
+            } else {
+                item.isEnabled = false
+            }
+            item.subtitle = offer.detail
+            menu.addItem(item)
+            menu.addItem(.separator())
+        }
         if rows.isEmpty {
             let none = NSMenuItem(title: "No agents", action: nil, keyEquivalent: "")
             none.isEnabled = false
@@ -321,9 +402,18 @@ exit(0)
 }
 if arguments.contains("--print-panel") {
     let full = arguments.contains("--full")
-    print(PanelContent(rows: fetchRows(), full: full, canToggle: full || arguments.contains("--toggle")).plainText)
+    print(PanelContent(rows: fetchRows(), full: full, canToggle: full || arguments.contains("--toggle"),
+                       offer: fetchRestoreOffer()).plainText)
     exit(0)
 }
+if let index = arguments.firstIndex(of: "--restore") {
+    exit(performRestore(sessions: Array(arguments[(index + 1)...])) ? 0 : 1)
+}
+if arguments.contains("--dismiss-offer") {
+    let result = runReporting(dinggerBinary, ["restore", "--dismiss"])
+    print(result.output)
+    exit(result.ok ? 0 : 1)
+}
 if let index = arguments.firstIndex(of: "--snapshot-panel"), index + 1 < arguments.count {
     _ = NSApplication.shared
     let controller = PanelController(persistFrame: false, onClick: { _ in }, onToggleFull: {})
@@ -332,7 +422,7 @@ controller.render(PanelContent(rows: [Row(
         paneId: "%stale", agent: "pi", name: "STALE ROW FROM A PREVIOUS RENDER", status: .blocked,
         session: "old", window: "old", since: 0)]))
     let full = arguments.contains("--full")
-    controller.render(PanelContent(rows: fetchRows(), full: full, canToggle: full))
+    controller.render(PanelContent(rows: fetchRows(), full: full, canToggle: full, offer: fetchRestoreOffer()))
     exit(controller.snapshot(to: arguments[index + 1]) ? 0 : 1)
 }
 if let index = arguments.firstIndex(of: "--print-search") {

@@ -165,6 +165,58 @@ }
 
 let dinggerBinary = environment["DINGGER_BIN"] ?? (NSHomeDirectory() + "/.local/bin/dingger")
 
+// MARK: restore offer
+
+/// tmux sessions the daemon offers to restore after tmux stopped
+/// (`offer.json`, written by `dingger watch`).
+struct RestoreOffer: Decodable, Equatable {
+    struct Session: Decodable, Equatable {
+        let name: String
+        let windows: Int
+        let panes: Int
+        let agents: Int
+    }
+    let saved_at: Int
+    let sessions: [Session]
+    let agents: Int
+    let interrupted: Int
+
+    /// "Restore 9 sessions · 22 agents"
+    var title: String {
+        var text = "Restore \(sessions.count) \(sessions.count == 1 ? "session" : "sessions")"
+        if agents > 0 { text += " · \(agents) \(agents == 1 ? "agent" : "agents")" }
+        return text
+    }
+
+    /// "saved 13:01 · 1 was mid-turn"
+    var detail: String {
+        let formatter = DateFormatter()
+        let saved = Date(timeIntervalSince1970: TimeInterval(saved_at) / 1000)
+        formatter.dateFormat = Calendar.current.isDateInToday(saved) ? "HH:mm" : "MMM d, HH:mm"
+        var parts = ["tmux stopped · saved \(formatter.string(from: saved))"]
+        if interrupted > 0 { parts.append("\(interrupted) \(interrupted == 1 ? "was" : "were") mid-turn") }
+        return parts.joined(separator: " · ")
+    }
+}
+
+let stateDirectory = environment["DINGGER_STATE_DIR"] ?? (NSHomeDirectory() + "/.local/state/dingger")
+
+func fetchRestoreOffer() -> RestoreOffer? {
+    guard let data = FileManager.default.contents(atPath: stateDirectory + "/offer.json") else { return nil }
+    return try? JSONDecoder().decode(RestoreOffer.self, from: data)
+}
+
+/// Run `dingger <args>` through the user's login shell, the way a terminal
+/// starts tmux: restored panes inherit this environment (PATH, LANG), and
+/// launchd's is bare. DINGGER_RESTORE_DIRECT runs it directly (tests).
+func runDinggerInLoginShell(_ args: [String]) -> (ok: Bool, output: String) {
+    if environment["DINGGER_RESTORE_DIRECT"] != nil {
+        return runReporting(dinggerBinary, args)
+    }
+    let shell = getpwuid(getuid()).flatMap { String(validatingUTF8: $0.pointee.pw_shell) } ?? "/bin/zsh"
+    return runReporting(shell, ["--login", "-i", "-c", "exec \"$0\" \"$@\"", dinggerBinary] + args)
+}
+
 private let home = NSHomeDirectory()
 
 /// Every agent pane, in herdr's priority order, oldest waiting first.

@@ -36,13 +36,15 @@
     var enabled = true
     var policy: PanelPolicy = .whenWaiting
     var anyWaiting = false
+    /// tmux stopped and its sessions can be restored.
+    var restoreOffered = false
     /// Turning the panel on with nothing to show shows it briefly, so the
     /// shortcut visibly did something.
     var peekUntil: Date?
 
     func visible(at now: Date) -> Bool {
         guard enabled else { return false }
-        if policy == .always || anyWaiting { return true }
+        if policy == .always || anyWaiting || restoreOffered { return true }
         return peekUntil.map { now < $0 } ?? false
     }
 
@@ -84,7 +86,15 @@ let full: Bool
     /// Whether the panel offers the compact/full toggle (shown always).
     let canToggle: Bool
 
-    init(rows all: [Row], full: Bool = false, canToggle: Bool = false) {
+    /// Sessions to restore, shown first.
+    let offer: RestoreOffer?
+    /// A restore is running.
+    let restoring: Bool
+
+    init(rows all: [Row], full: Bool = false, canToggle: Bool = false,
+         offer: RestoreOffer? = nil, restoring: Bool = false) {
+        self.offer = offer
+        self.restoring = restoring
         let waiting = all.filter(\.waiting)
         if full {
             rows = all
@@ -127,14 +137,28 @@ }
 
     var toggleLabel: String { full ? "Show less ▴" : "Show all ▾" }
 
+    /// The offer row's title: what restore will do, or that it runs.
+    var offerTitle: String? {
+        guard let offer else { return nil }
+        return restoring ? "Restoring \(offer.sessions.count) \(offer.sessions.count == 1 ? "session" : "sessions")…" : offer.title
+    }
+
+    /// The summary line is noise when tmux is gone and only the offer shows.
+    var showsSummary: Bool { offer == nil || working + idle + rows.count > 0 }
+
     var plainText: String {
         var lines: [String] = []
+        if let offer, let offerTitle {
+            lines.append("↺ \(offerTitle)\t\(offer.detail)" + (restoring ? "" : "\t[Not now]"))
+        }
         for (index, row) in rows.enumerated() {
             if index == separatorBefore { lines.append("---") }
             lines.append("\(row.status.symbol) \(row.status.rawValue)\t\(row.label)\t\(row.subtitle)")
         }
         if overflow > 0 { lines.append("+\(overflow) more waiting") }
-        lines.append(summary.string + (canToggle ? "\t[\(toggleLabel)]" : ""))
+        if showsSummary {
+            lines.append(summary.string + (canToggle ? "\t[\(toggleLabel)]" : ""))
+        }
         return lines.joined(separator: "\n")
     }
 }
@@ -272,6 +296,43 @@ NSBezierPath(roundedRect: bounds, xRadius: 6, yRadius: 6).fill()
     }
 }
 
+/// The restore offer: "↺ Restore 9 sessions · 22 agents", what it was.
+private final class OfferView: ClickView {
+    init(title: String, detail: String, onClick: @escaping () -> Void) {
+        super.init(frame: .zero)
+        self.onClick = onClick
+        let font = NSFont.menuFont(ofSize: 0)
+        let text = NSMutableAttributedString(string: "↺  ", attributes: [
+            .font: NSFont.monospacedSystemFont(ofSize: font.pointSize, weight: .bold), .foregroundColor: mochaBlue,
+        ])
+        text.append(NSAttributedString(string: title, attributes: [.font: font, .foregroundColor: mochaText]))
+        let titleLabel = singleLine(NSTextField(labelWithAttributedString: text))
+        let detailLabel = NSTextField(labelWithString: detail)
+        detailLabel.font = .systemFont(ofSize: 11)
+        detailLabel.textColor = mochaSubtext
+        let stack = NSStackView(views: [titleLabel, singleLine(detailLabel)])
+        stack.orientation = .vertical
+        stack.alignment = .leading
+        stack.spacing = 1
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(stack)
+        NSLayoutConstraint.activate([
+            stack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 8),
+            stack.trailingAnchor.constraint(lessThanOrEqualTo: trailingAnchor, constant: -8),
+            stack.topAnchor.constraint(equalTo: topAnchor, constant: 5),
+            stack.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -5),
+        ])
+    }
+
+    required init?(coder: NSCoder) { fatalError("not used") }
+
+    override func draw(_ dirtyRect: NSRect) {
+        guard hovered else { return }
+        NSColor.white.withAlphaComponent(0.08).setFill()
+        NSBezierPath(roundedRect: bounds, xRadius: 6, yRadius: 6).fill()
+    }
+}
+
 /// "Show all ▾" / "Show less ▴".
 private final class ToggleView: ClickView {
     private let label: NSTextField
@@ -302,11 +363,16 @@ private let panel: NSPanel
     private let stack = NSStackView()
     private let onClick: (String) -> Void
     private let onToggleFull: () -> Void
+    private let onRestore: () -> Void
+    private let onDismissRestore: () -> Void
     private var rendered: String?
 
-    init(persistFrame: Bool = true, onClick: @escaping (String) -> Void, onToggleFull: @escaping () -> Void) {
+    init(persistFrame: Bool = true, onClick: @escaping (String) -> Void, onToggleFull: @escaping () -> Void,
+         onRestore: @escaping () -> Void = {}, onDismissRestore: @escaping () -> Void = {}) {
         self.onClick = onClick
         self.onToggleFull = onToggleFull
+        self.onRestore = onRestore
+        self.onDismissRestore = onDismissRestore
         panel = NSPanel(contentRect: NSRect(x: 0, y: 0, width: panelWidth, height: 60),
                         styleMask: [.nonactivatingPanel, .borderless],
                         backing: .buffered, defer: false)
@@ -356,6 +422,10 @@ stack.arrangedSubviews.forEach { view in
             stack.removeArrangedSubview(view)
             view.removeFromSuperview()
         }
+        if let offer = content.offer, let title = content.offerTitle {
+            add(offerLine(title: title, detail: offer.detail, restoring: content.restoring), fullWidth: true)
+            if content.showsSummary || !content.rows.isEmpty { add(separatorLine()) }
+        }
         for (index, row) in content.rows.enumerated() {
             if index == content.separatorBefore { add(separatorLine()) }
             add(PanelRowView(row: row, onClick: onClick), fullWidth: true)
@@ -365,7 +435,7 @@ add(caption(NSAttributedString(
                 string: "+\(content.overflow) more waiting, see the menu bar",
                 attributes: [.font: NSFont.systemFont(ofSize: 11), .foregroundColor: mochaSubtext])))
         }
-        add(summaryLine(content), fullWidth: true)
+        if content.showsSummary { add(summaryLine(content), fullWidth: true) }
 
         // Grow or shrink downward from the top edge.
         stack.layoutSubtreeIfNeeded()
@@ -413,6 +483,34 @@ ])
         return box
     }
 
+    /// The offer row, with "Not now" beside it (a row takes every click
+    /// inside it, so the link cannot be inside).
+    private func offerLine(title: String, detail: String, restoring: Bool) -> NSView {
+        let box = NSView()
+        let row = OfferView(title: title, detail: detail, onClick: restoring ? {} : onRestore)
+        row.translatesAutoresizingMaskIntoConstraints = false
+        box.addSubview(row)
+        var constraints = [
+            row.leadingAnchor.constraint(equalTo: box.leadingAnchor),
+            row.topAnchor.constraint(equalTo: box.topAnchor),
+            row.bottomAnchor.constraint(equalTo: box.bottomAnchor),
+        ]
+        if restoring {
+            constraints.append(row.trailingAnchor.constraint(equalTo: box.trailingAnchor))
+        } else {
+            let dismiss = ToggleView(text: "Not now", onClick: onDismissRestore)
+            dismiss.translatesAutoresizingMaskIntoConstraints = false
+            box.addSubview(dismiss)
+            constraints += [
+                dismiss.trailingAnchor.constraint(equalTo: box.trailingAnchor, constant: -8),
+                dismiss.centerYAnchor.constraint(equalTo: box.centerYAnchor),
+                row.trailingAnchor.constraint(equalTo: dismiss.leadingAnchor, constant: -8),
+            ]
+        }
+        NSLayoutConstraint.activate(constraints)
+        return box
+    }
+
     /// Summary on the left, the compact/full toggle on the right.
     private func summaryLine(_ content: PanelContent) -> NSView {
         let box = caption(content.summary)
@@ -511,6 +609,12 @@ "migration: always")
     check(PanelVisibility.migrated(fromMode: "auto") == PanelVisibility(enabled: true, policy: .whenWaiting),
           "migration: when waiting")
 
+    var offered = PanelVisibility(enabled: true, policy: .whenWaiting)
+    offered.restoreOffered = true
+    check(offered.visible(at: t0), "a restore offer shows the panel")
+    offered.toggle(at: t0)
+    check(!offered.visible(at: at(10)), "off: a restore offer does not show it")
+
     check(!panelShowsFull(policy: .whenWaiting, prefersFull: true), "layout: compact when only waiting")
     check(panelShowsFull(policy: .always, prefersFull: true), "layout: full in always when chosen")
     check(!panelShowsFull(policy: .always, prefersFull: false), "layout: compact in always by default")
@@ -529,5 +633,19 @@ check(PanelContent(rows: [row("x", .working)], full: true).separatorBefore == nil,
           "full: no separator without waiting agents")
     check(full.plainText.hasSuffix("[Show less ▴]") && !compact.plainText.contains("Show"),
           "toggle offered only when allowed, labelled by layout")
+
+    let offer = RestoreOffer(saved_at: 0, sessions: [
+        .init(name: "a", windows: 2, panes: 3, agents: 2), .init(name: "b", windows: 1, panes: 1, agents: 0),
+    ], agents: 2, interrupted: 1)
+    let afterReboot = PanelContent(rows: [], offer: offer)
+    check(afterReboot.plainText.hasPrefix("↺ Restore 2 sessions · 2 agents\t")
+          && afterReboot.plainText.contains("1 was mid-turn") && afterReboot.plainText.hasSuffix("[Not now]"),
+          "offer: first, with what it brings back and a way to dismiss it")
+    check(!afterReboot.plainText.contains("No agents"), "offer: no empty summary when tmux is gone")
+    let running = PanelContent(rows: [], offer: offer, restoring: true)
+    check(running.plainText.hasPrefix("↺ Restoring 2 sessions…") && !running.plainText.contains("Not now"),
+          "offer: while restoring, no dismiss")
+    check(PanelContent(rows: many, offer: offer).plainText.contains("○ 1 idle"),
+          "offer: the summary stays when there are agents")
     return failures
 }

@@ -4,9 +4,15 @@ # Clicking the status line jumps to the top waiting agent, like the top row
 # of the menu bar: blocked first, then the longest-done (FIFO), skipping the
 # window you are already looking at.
 #
+# After tmux restarts, `↺N` (blue) offers to restore N saved sessions:
+# clicking it runs `dingger restore`; a notification summarizes, the full
+# report is in ~/.local/state/dingger/restore.log.
+#
 # Source this from your tmux config:  source-file /path/to/dingger.tmux
-set -g status-right '%d-%b %H:%M#{?#{e|>:#{@dingger_blocked},0}, #[fg=#f38ba8#,bold]×#{@dingger_blocked}#[default],}#{?#{e|>:#{@dingger_done},0}, #[fg=#94e2d5]✓#{@dingger_done}#[default],}#{?#{e|>:#{@dingger_working},0}, #[fg=#f9e2af]◐#{@dingger_working}#[default],}'
-bind -n MouseDown1StatusRight run-shell "$HOME/.local/bin/dingger focus --client '#{client_name}'"
+set -g status-right '#{?@dingger_restore,#[range=user|restore]#[fg=#89b4fa#,bold]↺#{@dingger_restore}#[norange default] ,}%d-%b %H:%M#{?#{e|>:#{@dingger_blocked},0}, #[fg=#f38ba8#,bold]×#{@dingger_blocked}#[default],}#{?#{e|>:#{@dingger_done},0}, #[fg=#94e2d5]✓#{@dingger_done}#[default],}#{?#{e|>:#{@dingger_working},0}, #[fg=#f9e2af]◐#{@dingger_working}#[default],}'
+bind -n MouseDown1StatusRight if -F '#{==:#{mouse_status_range},restore}' \
+  'run-shell -b "$HOME/.local/bin/dingger restore --report"' \
+  "run-shell \"$HOME/.local/bin/dingger focus --client '#{client_name}'\""
 # Tell dingger the moment you look somewhere else (it marks what you see as
 # attended). Index 77 keeps your own hooks and makes reloading idempotent.
 set-hook -g 'client-session-changed[77]' 'run-shell -b "$HOME/.local/bin/dingger poke"'

@@ -37,7 +37,7 @@ cleanup() {
   [ -n "${DAEMON_PID:-}" ] && kill "$DAEMON_PID" 2>/dev/null
   [ -n "${DAEMON2_PID:-}" ] && kill "$DAEMON2_PID" 2>/dev/null
   t kill-server 2>/dev/null
-  tmux -L "$SOCK-restore" kill-server 2>/dev/null
+  tmux -L "$SOCK-restore-$$" kill-server 2>/dev/null
   rm -rf "$DIR"
 }
 trap cleanup EXIT
@@ -226,6 +226,11 @@ t source-file "$ROOT/packaging/tmux/dingger.tmux"
 segment=$(t display -p -c "$CLIENT" '#{T:status-right}' | sed 's/#\[[^]]*\]//g')
 case "$segment" in *"×1"*"✓1"*) pass "segment shows ×1 ✓1 ($segment)";; *) fail "segment: [$segment]";; esac
 expect "mouse binding installed" "t list-keys -T root | grep MouseDown1StatusRight | grep -c 'dingger focus'" 1
+expect "clicking the restore offer runs restore" "t list-keys -T root | grep MouseDown1StatusRight | grep -c 'restore --report'" 1
+t set -g @dingger_restore 3
+segment=$(t display -p -c "$CLIENT" '#{T:status-right}' | sed 's/#\[[^]]*\]//g')
+case "$segment" in "↺3 "*"×1"*) pass "segment offers to restore 3 sessions ($segment)";; *) fail "restore segment: [$segment]";; esac
+t set -gu @dingger_restore
 # same run-shell + #{client_name} expansion as the mouse binding, via a key
 t bind -n F12 run-shell "DINGGER_TMUX_SOCKET=$SOCK $DINGGER focus --client '#{client_name}'"
 t send-keys -t viewer: F12
@@ -351,7 +356,7 @@ # --- 16. restore after the tmux server goes away ------------------------------
 # A second server and daemon. "viewer" hosts a client the way a terminal
 # does: Ghostty runs `tmux new-session -As 0`.
 echo "16. restore"
-R="$SOCK-restore"
+R="$SOCK-restore-$$"
 STATE2="$DIR/state2"
 # tmux gives new windows the environment of the client that creates them:
 # both the test and restore run with the fake pi first on PATH.
@@ -410,7 +415,10 @@ r list-panes -a -F '#{session_name}|#{window_index}|#{?automatic-rename,(auto),#{window_name}}|#{window_active}|#{window_zoomed_flag}|#{automatic-rename}|#{pane_index}|#{pane_active}|#{pane_left},#{pane_top},#{pane_width}x#{pane_height}|#{pane_current_path}' \
     | grep -E '^(0|work)\|'
 }
 BEFORE=$(fingerprint)
-renv "$DINGGER" watch --interval-secs 1 --no-sounds --no-notifications >>"$DIR/daemon2.log" 2>&1 &
+# Started directly, not through a function: $! must be the daemon itself.
+env PATH="$DIR/rbin:$PATH" DINGGER_TMUX_SOCKET="$R" DINGGER_AGENT_SOCKET="$DIR/hook2.sock" \
+  DINGGER_STATE_DIR="$STATE2" DINGGER_TMUX_CONFIG=/dev/null \
+  "$DINGGER" watch --interval-secs 1 --no-sounds --no-notifications >>"$DIR/daemon2.log" 2>&1 &
 DAEMON2_PID=$!
 latest_snapshot() { ls "$STATE2"/snapshots/*.json 2>/dev/null | tail -1; }
 expect "a snapshot of both sessions" "grep -c '\"name\": \"work\"' \"\$(latest_snapshot)\" 2>/dev/null" 1 80
@@ -452,7 +460,16 @@ expect "the candidate survives the new server's snapshots" \
   "python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))[\"snapshot\"][\"server\"] != json.load(open(sys.argv[2]))[\"server\"])' $STATE2/restore.json \"\$(latest_snapshot)\"" True 80
 expect "dry run plans: replace 0, keep keep and viewer, create work" \
   "renv \"$DINGGER\" restore --dry-run | grep -v '^  ' | cut -c1-14 | sort | tr '\n' ';'" "create   work:;keep     keep:;keep     viewe;replace  0: 2 ;"
-renv "$DINGGER" restore >"$DIR/restore.out" 2>&1
+mbr() { renv DINGGER_BIN="$DINGGER" DINGGER_RESTORE_DIRECT=1 \
+  DINGGER_NOTIFIER="echo \"\$0|\$1\" >> $DIR/notes2" "$MENUBAR" "$@"; }
+expect "the daemon offers to restore 0 and work" \
+  "python3 -c 'import json,sys; o=json.load(open(sys.argv[1])); print([s[\"name\"] for s in o[\"sessions\"]], o[\"agents\"], o[\"interrupted\"])' $STATE2/offer.json 2>/dev/null" \
+  "['0', 'work'] 2 1" 80
+expect "and tells the status line" "r show -gv @dingger_restore" 2
+expect "the panel offers it first" "mbr --print-panel | head -1 | cut -f1,3" "↺ Restore 2 sessions · 2 agents	[Not now]"
+expect "with what was interrupted" "mbr --print-panel | head -1 | cut -f2 | grep -o '1 was mid-turn'" "1 was mid-turn"
+mbr --restore
+cp "$STATE2/restore.log" "$DIR/restore.out" 2>/dev/null
 expect "restore succeeds" "grep -c FAILED $DIR/restore.out" 0
 expect "agents resumed with their session files" "grep -- --session $DIR/pi-args | sort" "--session $W/sessions/a b.jsonl
 --session $W/sessions/gone.jsonl"
@@ -463,6 +480,8 @@ expect "the interrupted turn is reported" "grep -c '^interrupted  work:agent' $DIR/restore.out" 1
 typed_line() { r capture-pane -p -t "$1" | grep -v '^ *$' | tail -1; }
 expect "a command is retyped with its quoting" "typed_line '=work:cmd' | grep -o \"sh -c 'sleep 100000; :' 'two words'\$\"" "sh -c 'sleep 100000; :' 'two words'"
 expect "the zsh hook's text is retyped" "typed_line '=work:hooked' | grep -o 'slp 200000 | cat\$'" "slp 200000 | cat"
+expect "a notification summarizes" "cat $DIR/notes2" "Restored 2 tmux sessions|resumed 2 of 2 agents · 1 was mid-turn · 2 commands typed, not run"
+expect "the offer is gone" "ls $STATE2/offer.json 2>/dev/null; r show -gv @dingger_restore 2>/dev/null; mbr --print-panel | grep -c '↺'" "0"
 expect "neither runs: the shell waits for Enter" \
   "r display -p -t '=work:cmd' '#{pane_current_command}'; r display -p -t '=work:hooked' '#{pane_current_command}'" "bash
 bash"
@@ -479,6 +498,30 @@ renv "$DINGGER" restore >"$DIR/restore2.out" 2>&1
 expect "restoring again changes nothing" "fingerprint" "$BEFORE"
 expect "restoring again plans nothing" "grep -cvE '^keep ' $DIR/restore2.out" 0
 [ "$FAILS" -gt 0 ] && { echo "--- restore output:"; cat "$DIR/restore.out"; echo "--- before:"; echo "$BEFORE"; echo "--- after:"; fingerprint; }
+
+# Again, now with no tmux running at all (after a reboot, before a terminal
+# opens): restoring starts the server. Then "Not now" stays dismissed.
+names() { r list-panes -a -F '#{session_name}|#{window_index}|#{?automatic-rename,(auto),#{window_name}}|#{pane_index}|#{pane_current_path}' 2>/dev/null | grep "^$1|"; }
+WORK_BEFORE=$(names work)
+r kill-server
+expect "a new offer: all four sessions, tmux is not running" \
+  "python3 -c 'import json,sys; print(len(json.load(open(sys.argv[1]))[\"sessions\"]))' $STATE2/offer.json 2>/dev/null" 4 80
+mbr --restore work
+expect "restoring with no server starts it and rebuilds the session" "names work" "$WORK_BEFORE"
+expect "the offer shrinks to what is still missing" \
+  "python3 -c 'import json,sys; print(sorted(s[\"name\"] for s in json.load(open(sys.argv[1]))[\"sessions\"]))' $STATE2/offer.json 2>/dev/null" \
+  "['0', 'keep', 'viewer']" 80
+mbr --dismiss-offer >/dev/null
+expect "Not now: the offer is gone" "ls $STATE2/offer.json 2>/dev/null | wc -l | tr -d ' '" 0
+expect "and the status line is told" "r show -gv @dingger_restore 2>/dev/null" ""
+start_viewer
+sleep 2
+expect "it stays dismissed when a terminal starts tmux" "ls $STATE2/offer.json 2>/dev/null | wc -l | tr -d ' '" 0
+expect "the layout can still be restored by hand" "renv \"$DINGGER\" restore --dry-run | grep -c '^create   keep'" 1
+
+# Every daemon this run started must stop with it.
+kill "$DAEMON_PID" "$DAEMON2_PID" 2>/dev/null
+expect "the test daemons stop" "ps -o pid= -p $DAEMON_PID,$DAEMON2_PID | wc -l | tr -d ' '" 0
 
 echo
 echo "$PASSES passed, $FAILS failed"