Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

36.7 KB
Raw Blame
//! A daemon can acquire a new identity after sign-in without hn exiting. Treat that
//! transition explicitly: first sign-in keeps local work; a different account gets
//! its own desk, inventories and in-flight requests. No process is stopped here.
use super::*;

#[derive(Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct Identity { machine: String, #[serde(default)] local_only: bool }

fn identity(value: &Value) -> Option<Identity> {
    serde_json::from_value::<Identity>(value.clone()).ok().filter(|id| !id.machine.is_empty() && !crate::local::is_local(&id.machine))
}

fn remove_views(tabs: &mut Vec<Tab>, removed: &HashSet<u64>) {
    tabs.retain_mut(|tab| {
        let had_panes = tab.root.is_some();
        for id in removed {
            if !tab.panes().contains(id) { continue }
            tab.lose(*id);
            tab.root = tab.root.take().and_then(|root| root.remove(*id));
        }
        if tab.root.is_none() { tab.focus = None; tab.zoomed = false; }
        !had_panes || tab.root.is_some()
    });
    if tabs.is_empty() { tabs.push(Tab::home()); }
}

impl App {
    pub(crate) fn saved_identity(&self) -> Value { json!(self.daemon_identity) }

    /// [machine] is this computer's daemon: the machine it last said it is, or the one listed as this
    /// computer. Not `fleet.local_id` alone, which is hn's own shells while the daemon is down: this
    /// computer's own redials were counted as remote_connect then (measure.rs).
    pub(crate) fn this_computer(&self, machine: &str) -> bool {
        if crate::local::is_local(machine) { return false }
        machine == self.fleet.local_id || self.daemon_identity.as_ref().is_some_and(|id| id.machine == machine)
            || self.fleet.machine(machine).is_some_and(|m| m.local)
    }

    pub(super) fn reconcile_account_machines(&mut self, rows: &[Value], stale: bool) {
        // An older outage cache cannot prove a removal or undo a confirmed one.
        // Keep live views until a fresh inventory supplies the authoritative list.
        if stale { return }
        let ids: HashSet<_> = rows.iter().filter_map(|r| r["machineId"].as_str()).collect();
        self.removed_machines.retain(|id| !ids.contains(id.as_str()));
        let removed: Vec<_> = self.fleet.machines.iter().filter(|m| !m.local && !crate::local::is_local(&m.id) && !ids.contains(m.id.as_str())).map(|m| m.id.clone()).collect();
        for machine in removed { self.forget_account_machine(&machine); }
    }

    /// Removing a computer closes its local views and data connection, never its agents.
    /// This also invalidates callbacks and menus captured before the inventory changed.
    pub(crate) fn forget_account_machine(&mut self, machine: &str) {
        if machine == self.fleet.local_id || crate::local::is_local(machine) { return }
        self.removed_machines.insert(machine.into());
        let removed: HashSet<_> = self.panes.iter().filter(|(_, p)| p.machine_id == machine).map(|(id, _)| *id).collect();
        let front = self.tab().id.clone();
        remove_views(&mut self.tabs, &removed);
        self.active = self.tabs.iter().position(|t| t.id == front).unwrap_or(0);
        for session in &mut self.sessions {
            let active = session.tabs.get(session.active).map(|t| t.id.clone());
            remove_views(&mut session.tabs, &removed);
            session.active = active.and_then(|id| session.tabs.iter().position(|t| t.id == id)).unwrap_or(0);
            session.lastw.retain(|id| session.tabs.iter().any(|t| &t.id == id));
            session.nums.retain(|id, _| session.tabs.iter().any(|t| &t.id == id));
        }
        for pane in removed { self.drop_pane(pane); }
        self.lastw.retain(|id| self.tabs.iter().any(|t| &t.id == id));
        self.nums.retain(|id, _| self.tabs.iter().any(|t| &t.id == id));
        if let Some(mut state) = self.links.remove(machine) { if let Some(link) = state.link.take() { link.close(); } }
        self.fleet.machines.retain(|m| m.id != machine);
        self.fleet.agents.retain(|(m, _), _| m != machine);
        self.shells.retain(|(m, _)| m != machine);
        self.homes.remove(machine); self.usage.remove(machine); self.usage_asked.remove(machine); self.rtt.remove(machine);
        self.pending_questions.retain(|(m, _, _)| m != machine);
        self.home_order.borrow_mut().clear(); self.fleet_marked = false;
        self.fit_panes(); self.redraw_all = true; self.server_dirty = true;
    }

    pub(crate) fn account_machine_removed(&mut self, machine: &str) {
        // An older in-flight list may still contain the machine whose delete just committed.
        self.machines_request = self.machines_request.wrapping_add(1);
        self.forget_account_machine(machine);
    }

    /// Session files predate account-aware restoration. The roster's public owner ID
    /// identifies those older files without reading credentials or adopting its agents.
    pub(super) fn restore_saved_identity(&mut self, doc: &Value) {
        if self.daemon_identity.is_some() { return }
        self.daemon_identity = identity(&doc["harnessIdentity"]).or_else(|| {
            doc["sessions"].as_array().into_iter().flatten().find_map(|r| identity(&r["harnessIdentity"]))
        }).or_else(|| crate::fleet::cached_owner().map(|machine| Identity { machine, local_only:false }));
    }

    /// Other hn clients may still advertise a session from the previous account.
    /// Keep local PTYs and local work across sign-in/sign-out; distinct accounts stay separate.
    pub(crate) fn scoped_window(&self, win: &Value) -> Option<Value> {
        let mut win = win.clone();
        let old = identity(&win["harnessIdentity"]);
        let changed = old.as_ref().zip(self.daemon_identity.as_ref()).filter(|(old, current)| old.machine != current.machine);
        let removed = win["panes"].as_array().into_iter().flatten().any(|pane| pane.get(0).and_then(Value::as_str).is_some_and(|id| self.removed_machines.contains(id)));
        if changed.is_none() && !removed { return Some(win) }
        let original = win["panes"].as_array()?.clone();
        let kept: Vec<_> = original.iter().enumerate().filter_map(|(i, pane)| {
            let host = pane.get(0)?.as_str()?;
            if self.removed_machines.contains(host) { return None }
            if crate::local::is_local(host) { return Some((i, pane.clone())) }
            let Some((old, current)) = changed else { return Some((i, pane.clone())) };
            if !(old.local_only || current.local_only) || host != old.machine { return None }
            let mut pane = pane.clone(); pane[0] = json!(current.machine); Some((i, pane))
        }).collect();
        if kept.is_empty() { return None }
        if kept.len() != original.len() {
            let ids: Vec<_> = original.iter().enumerate().map(|(i, p)| p.get(3).and_then(Value::as_u64).unwrap_or(i as u64 + 1)).collect();
            let layout = win["layout"].as_str().unwrap_or_default();
            let (w, h) = Node::tmux_size(layout).unwrap_or(self.size);
            let mut root = Node::from_tmux(layout, &ids, w, h);
            for (_, id) in ids.into_iter().enumerate().filter(|(index, _)| !kept.iter().any(|(i, _)| i == index)) {
                root = root.and_then(|root| root.remove(id));
            }
            win["layout"] = json!(root.map(|root| root.to_tmux()).unwrap_or_default());
            let focus = win["focus"].as_u64().unwrap_or(0) as usize;
            win["focus"] = json!(kept.iter().position(|(i, _)| *i == focus).unwrap_or(0));
            win["zoomed"] = json!(win["zoomed"] == true && kept.len() > 1);
        }
        win["panes"] = json!(kept.into_iter().map(|(_, p)| p).collect::<Vec<_>>());
        win["harnessIdentity"] = self.saved_identity();
        Some(win)
    }

    pub(crate) fn scoped_session(&self, row: &Value) -> Option<Value> {
        let mut row = row.clone();
        let Some(current) = &self.daemon_identity else { return Some(row) };
        let old = identity(&row["harnessIdentity"]);
        let different = old.as_ref().is_some_and(|old| old.machine != current.machine)
            || row["windows"].as_array().into_iter().flatten().any(|win| identity(&win["harnessIdentity"]).is_some_and(|old| old.machine != current.machine));
        let removed = row["windows"].as_array().into_iter().flatten().flat_map(|win| win["panes"].as_array().into_iter().flatten()).any(|pane| pane.get(0).and_then(Value::as_str).is_some_and(|id| self.removed_machines.contains(id)));
        if different || removed {
            if different && row["desk"] == true { return None }
            let original = row["windows"].as_array()?;
            let kept: Vec<_> = original.iter().enumerate().filter_map(|(i, win)| {
                let mut win = win.clone();
                if identity(&win["harnessIdentity"]).is_none() { win["harnessIdentity"] = json!(old); }
                self.scoped_window(&win).map(|win| (i, win))
            }).collect();
            if kept.is_empty() { return None }
            let active = row["active"].as_u64().unwrap_or(0) as usize;
            let last: Vec<_> = row["last"].as_array().into_iter().flatten().filter_map(|n| kept.iter().position(|(i, _)| Some(*i as u64) == n.as_u64())).collect();
            row["active"] = json!(kept.iter().position(|(i, _)| *i == active).unwrap_or(0));
            row["last"] = json!(last);
            row["windows"] = json!(kept.into_iter().map(|(_, win)| win).collect::<Vec<_>>());
            row["harnessIdentity"] = self.saved_identity();
        }
        Some(row)
    }

    pub(super) fn adopt_daemon_identity(&mut self, status: &Value) {
        let Some(machine) = status["machineId"].as_str().filter(|id| !id.is_empty()) else { return };
        if self.daemon_identity.as_ref().is_some_and(|old| old.machine == machine) { return }
        // signedIn is read live from the credentials, before the old daemon has necessarily
        // restarted. Its computerId still identifies the anonymous daemon in that interval.
        let local_only = status["signedIn"] == false || status["computerId"].as_str() == Some(machine);
        let next = Identity { machine:machine.into(), local_only };
        let Some(old) = self.daemon_identity.replace(next) else { return };
        self.account_epoch = self.account_epoch.wrapping_add(1);
        // Another account, even with no sign-out between: none of the last one's measurement is its.
        crate::measure::account_changed(self);
        self.removed_machines.clear();
        let migrate = (old.local_only || local_only || status["computerId"].as_str() == Some(old.machine.as_str())).then_some(old.machine.as_str());

        crate::shell_context::account_changed(self, &old.machine, machine, migrate.is_some());
        crate::mirror::leave(self);
        self.mirror = None; self.mirror_attached = 0;
        for session in &mut self.sessions { session.mirror = None; }
        self.remote.borrow_mut().stamp = None;
        self.sessions_sig.clear();

        let links: Vec<_> = self.links.keys().filter(|m| !crate::local::is_local(m)).cloned().collect();
        for id in links { if let Some(mut state) = self.links.remove(&id) { if let Some(link) = state.link.take() { link.close(); } } }
        let mut removed = HashSet::new();
        for (id, pane) in &mut self.panes {
            if migrate == Some(pane.machine_id.as_str()) {
                pane.machine_id = machine.into();
                pane.stream = None; pane.opening = false; pane.open_token = pane.open_token.wrapping_add(1);
                pane.takeover_pending = false; pane.phase = Phase::Connecting("Connecting to your account…".into()); pane.dirty = true;
                crate::ids::desk_set(crate::ids::Kind::Pane, &format!("{machine}:{}", pane.agent_id), *id);
            } else if !crate::local::is_local(&pane.machine_id) { removed.insert(*id); }
        }
        let front_had_views = self.tabs.iter().any(|t| t.root.is_some());
        let front = self.tab().id.clone();
        remove_views(&mut self.tabs, &removed);
        self.active = self.tabs.iter().position(|t| t.id == front).unwrap_or(0);
        for session in &mut self.sessions {
            let front = session.tabs.get(session.active).map(|t| t.id.clone());
            remove_views(&mut session.tabs, &removed);
            session.active = front.and_then(|id| session.tabs.iter().position(|t| t.id == id)).unwrap_or(0);
            session.lastw.retain(|id| session.tabs.iter().any(|t| &t.id == id));
            session.nums.retain(|id, _| session.tabs.iter().any(|t| &t.id == id));
        }
        for id in removed { self.drop_pane(id); }
        self.lastw.retain(|id| self.tabs.iter().any(|t| &t.id == id));
        self.nums.retain(|id, _| self.tabs.iter().any(|t| &t.id == id));
        self.shells = self.shells.drain().filter_map(|(m, a)| {
            if migrate == Some(m.as_str()) { Some((machine.to_string(), a)) }
            else { crate::local::is_local(&m).then_some((m, a)) }
        }).collect();
        let old_local = self.fleet.machine(&old.machine).cloned();
        let mut kept = HashMap::new();
        for ((m, id), mut agent) in self.fleet.agents.drain() {
            if migrate == Some(m.as_str()) { agent.machine_id = machine.into(); kept.insert((machine.into(), id), agent); }
            else if crate::local::is_local(&m) { kept.insert((m, id), agent); }
        }
        self.fleet.agents = kept;
        self.fleet.machines.retain(|m| crate::local::is_local(&m.id));
        if let Some(mut host) = old_local { host.id = machine.into(); host.local = true; host.shared = false; host.reach = Reach::Unknown; self.fleet.machines.insert(0, host); }
        self.fleet.local_id = machine.into();

        self.local_tabs_to_sync.clear();
        for (desk, tabs) in std::iter::once((self.session_desk, &mut self.tabs)).chain(self.sessions.iter_mut().map(|s| (s.desk, &mut s.tabs))) {
            for tab in tabs {
                tab.on_desk = false; tab.desk_panes.clear(); tab.desk_layout = json!({});
                if migrate.is_some() && desk && tab.panes().iter().any(|id| self.panes.get(id).is_some_and(|p| p.machine_id == machine)) {
                    self.local_tabs_to_sync.insert(tab.id.clone());
                }
            }
        }
        self.desk_revision = -1; self.desk_loaded = false; self.desk_answered = false;
        self.desk_inflight = false; self.desk_stale = false; self.desk_no_tmux = false;
        self.desk_pending.clear(); self.desk_layouts.clear(); self.desk_acked_layouts.clear();
        self.desk_windows_saved.clear(); self.desk_active_saved = None;
        self.orphans.clear(); self.orphan_exits.clear(); self.last_focus_sent = None;
        self.recent.clear(); self.home_external.clear(); self.said.clear(); self.said_for.clear(); self.said_want.clear();
        self.said_generation = self.said_generation.wrapping_add(1); self.said_pending = 0; self.said_due = None;
        self.tails.clear(); self.tails_asked.clear(); self.pending_questions.clear();
        self.dsh.clear(); self.rtt.clear(); self.homes.clear(); self.usage.clear(); self.usage_checked = None; self.usage_asked.clear();
        self.prs.clear(); self.pr_asking.clear(); self.prs_read = None; self.seen_rostered.clear(); self.enriching = 0;
        self.home_order.borrow_mut().clear(); self.fleet_marked = false;
        self.agent_errors.clear(); self.launch_failed = None; self.away = None;
        self.last_harness = None; self.loop_pane = None; self.loop_seen.clear();
        self.session_close = Default::default(); self.agent_switch = Default::default();
        self.hardware = Default::default(); self.controls = Default::default(); self.dial = Default::default();
        let runner = self.devices.runner.take(); self.devices = Default::default(); self.devices.runner = runner;
        crate::new_harness::account_changed(self, migrate, machine);
        if migrate.is_none() {
            // A saved ordinary session may have been the previous account's only view.
            // Return to this account's desk instead of leaving that empty session selected.
            if !self.session_desk && front_had_views && self.tabs.iter().all(|t| t.root.is_none()) {
                self.session_group = None;
                if let Some(id) = self.sessions.iter().find(|s| s.desk).map(|s| s.id) { self.swap_session(id); }
                else { self.session_alias = None; self.session_path = None; }
            }
            self.sessions.retain(|s| s.desk || s.tabs.iter().any(|t| t.root.is_some()));
            if self.session_desk { self.session_alias = None; self.session_path = None; }
            for session in &mut self.sessions { if session.desk { session.alias = None; session.path = None; } }
        }
        // (The Models view a Set up's sign-in brought back stays: its Set up goes on under the new account.)
        let setting_up = matches!(self.modal, Some(Modal::Picker { kind: crate::modal::PickerKind::Models, .. })) && self.models_view.set_up_after_sign_in;
        if !setting_up && !matches!(self.modal, Some(Modal::NewHarness(_)) | Some(Modal::Picker { kind:crate::modal::PickerKind::Account, .. })) { self.modal = None; }
        crate::account::identity_changed(self);
        crate::models::account_changed(self);
        self.fit_panes(); self.redraw_all = true; self.server_dirty = true;
    }

    /// Join the signed-in desk only after reading its baseline. Local tabs keep their
    /// window/pane identities and geometry, and do not overwrite the account's other tabs.
    pub(super) fn sync_local_tabs_after_sign_in(&mut self) {
        if self.local_tabs_to_sync.is_empty() || !self.desk_syncs() || !self.session_desk { return }
        let ids = std::mem::take(&mut self.local_tabs_to_sync);
        let mut ops = Vec::new(); let mut agents = HashSet::new();
        for (index, tab) in self.tabs.iter_mut().enumerate().filter(|(_, t)| ids.contains(&t.id)) {
            // A standalone PTY is local to hn, even if it shares a tab with a daemon pane.
            if tab.panes().iter().any(|id| self.panes.get(id).is_some_and(|p| crate::local::is_local(&p.machine_id))) { continue }
            let panes: Vec<_> = tab.panes().iter().filter_map(|id| self.panes.get(id)).filter(|p| !crate::local::is_local(&p.machine_id)).collect();
            if panes.is_empty() { continue }
            tab.on_desk = true;
            ops.push(json!({"op":"tab.create","id":tab.id,"name":tab.name,"nameIsCustom":tab.named,"index":index}));
            for (at, pane) in panes.iter().enumerate() {
                ops.push(json!({"op":"pane.add","tabId":tab.id,"machineId":pane.machine_id,"agentId":pane.agent_id,"index":at}));
                agents.insert((pane.machine_id.clone(), pane.agent_id.clone()));
            }
            if let Some(root) = &tab.root {
                if !tab.layout.is_object() { tab.layout = json!({}); }
                tab.layout["tmux"] = json!(root.to_tmux());
                crate::desk_layout::Geometry::capture(root).write(&mut tab.layout);
                ops.push(json!({"op":"tab.layout","id":tab.id,"layout":tab.layout}));
            }
        }
        for (machine, agent) in agents { crate::agent_switch::retain_placement(self, &machine, &agent, &ops); }
        self.desk_ops(ops);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn status(machine: &str, signed_in: bool) -> Value { json!({"machineId":machine,"computerId":"computer","signedIn":signed_in}) }
    fn app(machine: &str, signed_in: bool) -> App {
        let (sink, _) = tokio::sync::mpsc::unbounded_channel();
        let mut app = App::new(0, sink, (100, 30));
        app.desk_mode = DeskMode::Sync; app.session_desk = true;
        app.fleet.local_id = machine.into();
        app.fleet.machines.push(Machine { id:machine.into(), name:"Studio".into(), local:true, shared:false, status:"running".into(), reach:Reach::Ready });
        app.adopt_daemon_identity(&status(machine, signed_in));
        app.tabs.clear();
        for (id, host, name) in [(1, machine, "Local work"), (2, "remote-old", "Old remote work"), (3, crate::local::MACHINE, "Local shell")] {
            let agent_id = format!("a{id}");
            app.fleet.agents.insert((host.into(), agent_id.clone()), fleet::agent_from(host, &json!({"id":agent_id,"engine":"codex","name":name}), None));
            app.panes.insert(id, Pane::new(id, host, &agent_id, 100, 29));
            let mut tab = Tab::with_wid(name, id); tab.id = format!("tab-{id}"); tab.root = Some(Node::new(id, 100, 29)); tab.focus = Some(id);
            tab.on_desk = id != 3; app.tabs.push(tab);
        }
        app.desk_revision = 900; app.desk_loaded = true; app.desk_inflight = true;
        app.desk_pending.push(json!({"op":"tab.rename","id":"old-tab","name":"Never replay"}));
        app
    }

    #[tokio::test]
    async fn pending_workspace_survives_restart_until_the_server_observes_its_pane() {
        let mut source = app("account-a", true);
        source.handed_over = true;
        source.tabs[0].named = true;
        source.tabs[0].zoomed = false;
        source.tabs[0].root.as_mut().unwrap().split(1, 4, Dir::Horizontal);
        source.tabs[0].focus = Some(4);
        source.panes.insert(4, Pane::new(4, "account-a", "neighbor", 50, 29));
        source.tabs[0].layout = json!({"tmux":source.tabs[0].root.as_ref().unwrap().to_tmux()});
        let ops = vec![json!({"op":"pane.add","tabId":"tab-1","machineId":"account-a","agentId":"a1","index":0})];
        crate::agent_switch::retain_placement(&mut source, "account-a", "a1", &ops);
        let saved = crate::agent_switch::saved_placements(&source);
        assert_eq!(saved.len(), 1);
        let doc = json!({"pending_workspace":saved});
        let mut restored = app("account-a", true);
        restored.handed_over = true;
        restored.tabs = vec![Tab::home()]; restored.panes.clear(); restored.desk_revision = -1;
        restored.fleet.local_id.clear(); // The private daemon has not answered startup yet.
        crate::agent_switch::restore_placements(&mut restored, &doc);
        assert_eq!(restored.tabs.len(), 1);
        assert_eq!(restored.tab().wid(), source.tabs[0].wid());
        assert_eq!(restored.tab().panes(), vec![1, 4]);
        assert_eq!(restored.tab().focus, Some(4));
        assert_eq!(restored.tab().root.as_ref().unwrap().to_tmux(), source.tabs[0].root.as_ref().unwrap().to_tmux());
        assert!(crate::agent_switch::sync_pending(&restored));
        restored.fleet.local_id = "account-a".into();
        let before = restored.desk_pending.clone();
        restored.apply_desk(&json!({"revision":1,"tabs":[{"id":"tab-1","name":"Local work","panes":[{"machineId":"account-a","agentId":"neighbor"}]}]}));
        assert!(crate::agent_switch::preserves(&restored, 1));
        assert_eq!(restored.desk_pending, before, "restoration does not send a new process request");
        assert!(restored.agent_switch.sent.is_empty());
        let claimed = crate::agent_switch::merge_saved_placements(&restored, &doc, false);
        assert_eq!(claimed.as_array().unwrap().len(), 1, "one owner claims the saved receipt without duplication");
        restored.apply_desk(&json!({"revision":2,"tabs":[{"id":"tab-1","name":"Local work","panes":[{"machineId":"account-a","agentId":"a1"},{"machineId":"account-a","agentId":"neighbor"}],"layout":restored.tab().layout}]}));
        assert!(!crate::agent_switch::sync_pending(&restored));
        assert_eq!(crate::agent_switch::merge_saved_placements(&restored, &doc, false), json!([]));
    }

    #[tokio::test]
    async fn a_pending_view_stopped_elsewhere_is_not_republished_after_restart() {
        let mut source = app("account-a", true);
        source.handed_over = true;
        crate::agent_switch::retain_placement(&mut source, "account-a", "a1", &[json!({"op":"pane.add","tabId":"tab-1","machineId":"account-a","agentId":"a1"})]);
        let doc = json!({"pending_workspace":crate::agent_switch::saved_placements(&source)});
        let mut restored = app("account-a", true);
        restored.handed_over = true;
        restored.tabs = vec![Tab::home()]; restored.panes.clear(); restored.desk_revision = -1;
        crate::agent_switch::restore_placements(&mut restored, &doc);
        // The fresh roster, rather than the saved active row, says another client stopped it.
        restored.fleet.agents.get_mut(&("account-a".into(), "a1".into())).unwrap().status = "stopped".into();
        crate::agent_switch::retry_sync(&mut restored);
        assert!(!crate::agent_switch::sync_pending(&restored));
        assert!(restored.agent_switch.sent.is_empty());
        assert_eq!(crate::agent_switch::merge_saved_placements(&restored, &doc, true), json!([]));
        restored.apply_desk(&json!({"revision":1,"tabs":[]}));
        assert!(restored.panes.is_empty());
    }

    #[tokio::test]
    async fn pending_workspace_cannot_cross_accounts_or_restore_a_removed_computer() {
        let mut source = app("account-a", true);
        source.handed_over = true;
        crate::agent_switch::retain_placement(&mut source, "remote-old", "a2", &[json!({"op":"pane.add","tabId":"tab-2","machineId":"remote-old","agentId":"a2"})]);
        let doc = json!({"pending_workspace":crate::agent_switch::saved_placements(&source)});
        for (owner, removed) in [("account-b", false), ("account-a", true)] {
            let mut restored = app(owner, true);
            restored.handed_over = true;
            restored.tabs = vec![Tab::home()]; restored.panes.clear();
            if removed { restored.removed_machines.insert("remote-old".into()); }
            crate::agent_switch::restore_placements(&mut restored, &doc);
            assert!(restored.panes.is_empty());
            assert!(!crate::agent_switch::sync_pending(&restored));
            assert!(restored.agent_switch.sent.is_empty());
        }
    }

    #[tokio::test]
    async fn saving_one_client_keeps_another_clients_pending_workspace_receipt() {
        let mut source = app("account-a", true);
        source.handed_over = true;
        crate::agent_switch::retain_placement(&mut source, "account-a", "a1", &[json!({"op":"pane.add","tabId":"tab-1","machineId":"account-a","agentId":"a1"})]);
        let mut rows = crate::agent_switch::saved_placements(&source);
        rows[0]["owner"] = json!("/tmp/hn-fixture-peer-not-running.sock");
        let doc = json!({"pending_workspace":rows});
        let mut peer = app("account-a", true);
        peer.handed_over = true;
        assert_eq!(crate::agent_switch::merge_saved_placements(&peer, &doc, false), doc["pending_workspace"]);
        peer.tabs = vec![Tab::home()]; peer.panes.clear();
        crate::agent_switch::restore_placements(&mut peer, &doc);
        assert_eq!(crate::agent_switch::merge_saved_placements(&peer, &doc, true).as_array().unwrap().len(), 1);
        peer.close_pane(1);
        assert_eq!(crate::agent_switch::merge_saved_placements(&peer, &doc, true), json!([]), "a view closed after recovery cannot reappear on another restart");
    }

    #[tokio::test]
    async fn cached_inventory_absence_keeps_a_live_remote_workspace() {
        let mut app = app("account-a", true);
        app.fleet.machines.push(Machine { id:"remote-old".into(), name:"Remote computer".into(), local:false, shared:false, status:"online".into(), reach:Reach::Ready });
        app.active = 1;
        let panes = app.tab().panes();
        let focus = app.focused();
        let operations = app.desk_pending.clone();
        let before = crate::workspace_resources::counts(&app).machines;
        // An outage may return a disk cache from before this computer joined.
        // Missing from that list is not a revocation or a user-requested removal.
        app.reconcile_account_machines(&[json!({"machineId":"account-a"})], true);
        assert!(app.fleet.machine("remote-old").is_some());
        assert!(!app.removed_machines.contains("remote-old"));
        assert_eq!(app.tab().panes(), panes);
        assert_eq!(app.focused(), focus);
        assert_eq!(crate::workspace_resources::counts(&app).machines, before);
        assert_eq!(app.desk_pending, operations);
    }

    #[tokio::test]
    async fn removed_computers_leave_no_live_views_or_counts_and_cached_lists_cannot_restore_them() {
        let mut app = app("account-a", true);
        app.fleet.machines.push(Machine { id:"remote-old".into(), name:"Removed computer".into(), local:false, shared:false, status:"online".into(), reach:Reach::Ready });
        app.active = 1;
        let before = crate::workspace_resources::counts(&app).machines;
        let operations = app.desk_pending.clone();
        app.reconcile_account_machines(&[json!({"machineId":"account-a"})], false);
        assert!(app.fleet.machine("remote-old").is_none());
        assert!(!app.panes.contains_key(&2));
        assert!(app.panes.contains_key(&1) && app.panes.contains_key(&3));
        assert_eq!(app.focused(), Some(1));
        assert_eq!(crate::workspace_resources::counts(&app).machines, before - 1);
        assert_eq!(app.desk_pending, operations, "inventory removal never stops agents or writes the desk");
        let stale_desk = json!({"revision":901,"tabs":[{"id":"old-tab","name":"Old remote work","panes":[{"machineId":"remote-old","agentId":"a2"}]}]});
        app.apply_desk(&stale_desk);
        assert!(!app.panes.values().any(|p| p.machine_id == "remote-old"));
        let rows = vec![json!({"machineId":"account-a"}), json!({"machineId":"remote-old"})];
        app.reconcile_account_machines(&rows, true);
        assert!(app.removed_machines.contains("remote-old"));
        app.reconcile_account_machines(&rows, false);
        assert!(!app.removed_machines.contains("remote-old"), "a fresh inventory can make the computer available again");
        app.account_machine_removed("remote-old");
        assert_eq!(app.machines_request, 1, "a confirmed delete invalidates older list reads");
        app.account_machine_removed("account-a");
        assert!(app.fleet.machine("account-a").is_some(), "inventory cannot remove this computer's local transport");
    }

    #[tokio::test]
    async fn first_sign_in_keeps_local_pane_geometry_then_joins_the_new_desk() {
        let mut app = app("computer", false);
        let layout = app.tabs[0].root.as_ref().unwrap().to_tmux();
        app.adopt_daemon_identity(&status("account-a", true));
        assert_eq!(app.account_epoch, 1);
        assert_eq!(app.panes[&1].machine_id, "account-a");
        assert_eq!(app.tabs[0].root.as_ref().unwrap().to_tmux(), layout);
        assert_eq!(app.tab().id, "tab-1");
        assert!(!app.panes.contains_key(&2)); assert!(app.panes.contains_key(&3));
        assert!(app.desk_pending.is_empty() && !app.desk_inflight);
        assert_eq!(app.desk_revision, -1);
        app.apply_desk(&json!({"revision":1,"tabs":[{"id":"account-tab","name":"Other computer","panes":[{"machineId":"account-remote","agentId":"remote-agent"}],"layout":{}}]}));
        assert_eq!(app.tab().id, "tab-1", "reading the account's desk does not steal focus");
        assert!(app.tabs.iter().any(|t| t.id == "account-tab"));
        assert!(app.tabs.iter().any(|t| t.id == "tab-1" && t.on_desk));
        assert!(!app.tabs.iter().find(|t| t.id == "tab-3").unwrap().on_desk);
        assert!(app.local_tabs_to_sync.is_empty());
        assert!(crate::agent_switch::preserves(&app, 1), "local view stays until the new desk confirms it");
    }

    /// The sign-in a Set up asked for can land before the daemon answers to the account: the Models view
    /// it brought back stays open through that, where the Set up goes on. Any other view still closes.
    #[test]
    fn a_set_up_s_models_view_stays_through_the_sign_in() {
        use crate::modal::{Modal, PickerKind};
        let mut app = app("computer", false);
        app.modal = Some(Modal::Picker { kind: PickerKind::Models, picker: crate::picker::Picker::new("models", "") });
        app.models_view.set_up_after_sign_in = true;
        app.models_view.set_up_signed_in = true;
        app.adopt_daemon_identity(&status("account-a", true));
        assert!(matches!(app.modal, Some(Modal::Picker { kind: PickerKind::Models, .. })));
        assert!(app.models_view.set_up_after_sign_in, "the Set up carries over to the account's machine id");

        let mut app = super::tests::app("computer", false);
        app.modal = Some(Modal::Picker { kind: PickerKind::Models, picker: crate::picker::Picker::new("models", "") });
        app.adopt_daemon_identity(&status("account-a", true));
        assert!(app.modal.is_none(), "without a Set up, the old account's view closes");
    }

    #[test]
    fn changing_accounts_drops_old_views_and_requests_but_never_stops_a_local_pty() {
        let mut app = app("account-a", true);
        app.recent.insert(("remote-old".into(), "a2".into()), json!({"private":"old account"}));
        app.adopt_daemon_identity(&status("account-b", true));
        assert_eq!(app.panes.keys().copied().collect::<Vec<_>>(), [3]);
        assert_eq!(app.fleet.local_id, "account-b");
        assert!(app.recent.is_empty() && app.desk_pending.is_empty());
        assert!(app.local_tabs_to_sync.is_empty());
        assert!(!app.quit); assert_eq!(app.tabs[0].name, "Local shell");
        assert!(app.fleet.agents.keys().all(|(m, _)| crate::local::is_local(m)));
        assert!(app.links.is_empty());
    }

    #[test]
    fn signing_out_keeps_this_computers_work_and_leaves_remote_account_views() {
        let mut app = app("account-a", true);
        app.adopt_daemon_identity(&status("computer", false));
        assert_eq!(app.panes[&1].machine_id, "computer");
        assert!(!app.panes.contains_key(&2));
        assert!(app.panes.contains_key(&3));
        assert_eq!(app.tab().id, "tab-1");
        assert!(!app.quit);
    }

    #[test]
    fn temporary_daemon_loss_and_live_signed_in_flag_do_not_change_the_identity() {
        let mut app = app("computer", false);
        app.fleet.local_id = crate::local::MACHINE.into();
        app.adopt_daemon_identity(&status("computer", true));
        assert_eq!(app.account_epoch, 0);
        assert!(app.panes.contains_key(&1));
        app.adopt_daemon_identity(&status("account-a", true));
        assert_eq!(app.panes[&1].machine_id, "account-a");
        assert_eq!(app.account_epoch, 1);
    }

    #[test]
    fn saved_identity_protects_the_first_boot_after_an_account_change() {
        let mut app = app("account-a", true);
        let saved = json!({"harnessIdentity":app.saved_identity(),"sessions":[]});
        app.daemon_identity = None;
        app.restore_saved_identity(&saved);
        app.adopt_daemon_identity(&status("account-b", true));
        assert!(!app.panes.contains_key(&1) && !app.panes.contains_key(&2));
        assert!(app.panes.contains_key(&3));
        assert_eq!(app.account_epoch, 1);
        assert_eq!(app.saved_identity()["machine"], "account-b");
    }

    #[test]
    fn importing_old_account_sessions_keeps_only_local_shells_and_their_geometry() {
        let mut app = app("account-a", true);
        let private = app.window_json(&app.tabs[0], Some(0));
        let mut mixed = app.window_json(&app.tabs[2], Some(1));
        let mut root = Node::new(3, 100, 30);
        assert!(root.split(3, 1, Dir::Horizontal));
        assert!(root.split(3, 2, Dir::Vertical));
        mixed["panes"] = json!([[crate::local::MACHINE,"a3",true,3],["account-a","a1",false,1],["remote-old","a2",false,2]]);
        mixed["layout"] = json!(root.to_tmux()); mixed["focus"] = json!(2); mixed["zoomed"] = json!(true);
        let row = json!({"name":"work","harnessIdentity":app.saved_identity(),"windows":[private,mixed],"active":1,"last":[0,1]});
        app.adopt_daemon_identity(&status("account-b", true));
        let scoped = app.scoped_session(&row).unwrap();
        let wins = scoped["windows"].as_array().unwrap();
        assert_eq!(wins.len(), 1);
        assert_eq!(wins[0]["panes"], json!([[crate::local::MACHINE,"a3",true,3]]));
        assert_eq!(wins[0]["focus"], 0); assert_eq!(wins[0]["zoomed"], false);
        assert_eq!(scoped["active"], 0); assert_eq!(scoped["last"], json!([0]));
        let layout = Node::from_tmux(wins[0]["layout"].as_str().unwrap(), &[3], 100, 30).unwrap();
        assert_eq!(layout.to_tmux(), Node::new(3, 100, 30).to_tmux());
        assert!(app.scoped_window(&row["windows"][0]).is_none());
        assert!(app.tab_from_json(&row["windows"][0]).is_none());
        assert!(app.scoped_session(&json!({"harnessIdentity":row["harnessIdentity"],"desk":true})).is_none());
    }

    #[test]
    fn another_clients_anonymous_session_can_join_but_its_remote_views_cannot() {
        let mut app = app("computer", false);
        let row = json!({"name":"local work","harnessIdentity":app.saved_identity(),"windows":[app.window_json(&app.tabs[0],Some(0)), app.window_json(&app.tabs[1],Some(1))]});
        app.adopt_daemon_identity(&status("account-a", true));
        let scoped = app.scoped_session(&row).unwrap();
        assert_eq!(scoped["windows"].as_array().unwrap().len(), 1);
        assert_eq!(scoped["windows"][0]["panes"][0][0], "account-a");
        assert_eq!(scoped["windows"][0]["panes"][0][3], 1);
        assert_eq!(scoped["harnessIdentity"], app.saved_identity());
        assert_eq!(scoped["windows"][0]["layout"], row["windows"][0]["layout"]);
    }
}