refactor: extract terminal state and runtime from panes

33 files changed, 2054 insertions, 1360 deletions

diff --git a/src/app/actions.rs b/src/app/actions.rs
index be8e1018..27ca7474 100644
--- a/src/app/actions.rs
+++ b/src/app/actions.rs
@@ -6,7 +6,7 @@ use tracing::{info, warn};
 use crate::detect::{Agent, AgentState};
 use crate::events::AppEvent;
 use crate::layout::{find_in_direction, NavDirection, PaneId};
-use crate::pane::EffectiveStateChange;
+use crate::terminal::EffectiveStateChange;
 use crate::workspace::WorkspaceGitStatus;
 
 use super::state::{AppState, Mode, ToastKind, ToastNotification, ToastTarget, ViewLayout};
@@ -91,6 +91,7 @@ pub struct PaneStateUpdate {
     pub agent_label: Option<String>,
     pub known_agent: Option<Agent>,
     pub state: AgentState,
+    pub custom_status: Option<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -406,14 +407,75 @@ impl AppState {
         self.agent_panel_scroll = self.agent_panel_scroll.min(max_scroll);
     }
 
+    pub(crate) fn terminal_ids_for_workspace(
+        &self,
+        ws_idx: usize,
+    ) -> Vec<crate::terminal::TerminalId> {
+        self.workspaces
+            .get(ws_idx)
+            .into_iter()
+            .flat_map(|ws| &ws.tabs)
+            .flat_map(|tab| tab.panes.values())
+            .map(|pane| pane.attached_terminal_id.clone())
+            .collect()
+    }
+
+    pub(crate) fn terminal_ids_for_tab(
+        &self,
+        ws_idx: usize,
+        tab_idx: usize,
+    ) -> Vec<crate::terminal::TerminalId> {
+        self.workspaces
+            .get(ws_idx)
+            .and_then(|ws| ws.tabs.get(tab_idx))
+            .into_iter()
+            .flat_map(|tab| tab.panes.values())
+            .map(|pane| pane.attached_terminal_id.clone())
+            .collect()
+    }
+
+    pub(crate) fn terminal_id_for_pane(
+        &self,
+        ws_idx: usize,
+        pane_id: PaneId,
+    ) -> Option<crate::terminal::TerminalId> {
+        self.workspaces
+            .get(ws_idx)?
+            .pane_state(pane_id)
+            .map(|pane| pane.attached_terminal_id.clone())
+    }
+
+    pub(crate) fn remove_unattached_terminal_ids(
+        &mut self,
+        terminal_ids: impl IntoIterator<Item = crate::terminal::TerminalId>,
+    ) {
+        for terminal_id in terminal_ids {
+            let still_attached = self.workspaces.iter().any(|ws| {
+                ws.tabs.iter().any(|tab| {
+                    tab.panes
+                        .values()
+                        .any(|pane| pane.attached_terminal_id == terminal_id)
+                })
+            });
+            if !still_attached {
+                self.terminals.remove(&terminal_id);
+                if let Some(runtime) = self.terminal_runtimes.remove(&terminal_id) {
+                    runtime.shutdown();
+                }
+            }
+        }
+    }
+
     pub fn close_selected_workspace(&mut self) {
         if self.workspaces.is_empty() {
             return;
         }
         self.mark_session_dirty();
+        let terminal_ids = self.terminal_ids_for_workspace(self.selected);
         let workspace_id = self.workspaces[self.selected].id.clone();
         crate::logging::workspace_closed(&workspace_id);
         self.workspaces.remove(self.selected);
+        self.remove_unattached_terminal_ids(terminal_ids);
         if self.workspaces.is_empty() {
             self.active = None;
             self.selected = 0;
@@ -529,12 +591,26 @@ impl AppState {
 
     pub fn close_pane(&mut self) {
         self.mark_session_dirty();
-        let should_close_workspace = self
-            .active
+        let active = self.active;
+        let terminal_ids = active
+            .and_then(|i| {
+                self.workspaces
+                    .get(i)
+                    .and_then(|ws| ws.focused_pane_id().map(|pane_id| (i, pane_id)))
+            })
+            .and_then(|(i, pane_id)| self.terminal_id_for_pane(i, pane_id))
+            .into_iter()
+            .collect::<Vec<_>>();
+        let should_close_workspace = active
             .and_then(|i| self.workspaces.get_mut(i))
             .is_some_and(|ws| ws.close_focused());
         if should_close_workspace {
+            if let Some(active) = active {
+                self.selected = active;
+            }
             self.close_selected_workspace();
+        } else {
+            self.remove_unattached_terminal_ids(terminal_ids);
         }
     }
 
@@ -545,16 +621,25 @@ impl AppState {
             .and_then(|i| self.workspaces.get(i))
             .is_some_and(|ws| ws.tabs.len() <= 1);
         if should_close_workspace {
+            if let Some(active) = self.active {
+                self.selected = active;
+            }
             self.close_selected_workspace();
             return;
         }
         if let Some(ws_idx) = self.active {
+            let terminal_ids = self
+                .workspaces
+                .get(ws_idx)
+                .map(|ws| self.terminal_ids_for_tab(ws_idx, ws.active_tab))
+                .unwrap_or_default();
             let Some(ws) = self.workspaces.get_mut(ws_idx) else {
                 return;
             };
             let workspace_id = ws.id.clone();
             let closing_tab_id = format!("{}:{}", workspace_id, ws.active_tab + 1);
             ws.close_active_tab();
+            self.remove_unattached_terminal_ids(terminal_ids);
             crate::logging::tab_closed(&workspace_id, &closing_tab_id);
             self.tab_scroll_follow_active = true;
             self.refresh_tab_bar_view();
@@ -572,37 +657,23 @@ impl AppState {
     }
 
     pub fn copy_selection(&mut self) {
-        let text = {
-            let sel = match self.selection.as_mut() {
-                Some(s) => {
-                    if !s.finish() {
-                        self.selection = None;
-                        return;
-                    }
-                    s
-                }
-                None => return,
-            };
-
-            let ws = match self.active.and_then(|i| self.workspaces.get(i)) {
-                Some(ws) => ws,
-                None => {
-                    self.selection = None;
-                    return;
-                }
-            };
-
-            let rt = match ws.runtime(sel.pane_id) {
-                Some(r) => r,
-                None => {
-                    self.selection = None;
-                    return;
-                }
-            };
+        let mut sel = match self.selection.take() {
+            Some(sel) => sel,
+            None => return,
+        };
+        if !sel.finish() {
+            return;
+        }
 
-            rt.extract_selection(sel)
+        let ws_idx = match self.active {
+            Some(ws_idx) if self.workspaces.get(ws_idx).is_some() => ws_idx,
+            _ => return,
         };
 
+        let text = self
+            .runtime_for_pane_in_workspace(ws_idx, sel.pane_id)
+            .and_then(|rt| rt.extract_selection(&sel));
+
         if let Some(text) = text {
             if !text.is_empty() {
                 self.request_clipboard_write = Some(text.into_bytes());
@@ -678,7 +749,9 @@ impl AppState {
                 agent,
                 state,
             } => self
-                .update_pane_state(pane_id, |pane| pane.set_detected_state(agent, state))
+                .update_terminal_state(pane_id, |terminal| {
+                    terminal.set_detected_state(agent, state)
+                })
                 .into_iter()
                 .collect(),
             AppEvent::HookStateReported {
@@ -690,8 +763,8 @@ impl AppState {
                 custom_status,
                 seq,
             } => self
-                .update_pane_state(pane_id, |pane| {
-                    pane.set_hook_authority_with_custom_status(
+                .update_terminal_state(pane_id, |terminal| {
+                    terminal.set_hook_authority_with_custom_status(
                         source,
                         agent_label,
                         state,
@@ -707,8 +780,8 @@ impl AppState {
                 source,
                 seq,
             } => self
-                .update_pane_state(pane_id, |pane| {
-                    pane.clear_hook_authority(source.as_deref(), seq)
+                .update_terminal_state(pane_id, |terminal| {
+                    terminal.clear_hook_authority(source.as_deref(), seq)
                 })
                 .into_iter()
                 .collect(),
@@ -719,8 +792,8 @@ impl AppState {
                 seq,
                 ..
             } => self
-                .update_pane_state(pane_id, |pane| {
-                    pane.release_agent(&source, &agent_label, seq)
+                .update_terminal_state(pane_id, |terminal| {
+                    terminal.release_agent(&source, &agent_label, seq)
                 })
                 .into_iter()
                 .collect(),
@@ -734,20 +807,21 @@ impl AppState {
         }
     }
 
-    fn update_pane_state<F>(&mut self, pane_id: PaneId, update: F) -> Option<PaneStateUpdate>
+    fn update_terminal_state<F>(&mut self, pane_id: PaneId, update: F) -> Option<PaneStateUpdate>
     where
-        F: FnOnce(&mut crate::pane::PaneState) -> Option<EffectiveStateChange>,
+        F: FnOnce(&mut crate::terminal::TerminalState) -> Option<EffectiveStateChange>,
     {
         let ws_idx = self
             .workspaces
             .iter()
             .position(|ws| ws.pane_state(pane_id).is_some())?;
+        let terminal_id = self.workspaces[ws_idx]
+            .pane_state(pane_id)?
+            .attached_terminal_id
+            .clone();
         let change = {
-            let pane = self.workspaces[ws_idx]
-                .tabs
-                .iter_mut()
-                .find_map(|tab| tab.panes.get_mut(&pane_id))?;
-            update(pane)?
+            let terminal = self.terminals.get_mut(&terminal_id)?;
+            update(terminal)?
         };
         let update = PaneStateUpdate {
             pane_id,
@@ -758,6 +832,7 @@ impl AppState {
             agent_label: change.agent_label.clone(),
             known_agent: change.known_agent,
             state: change.state,
+            custom_status: change.custom_status.clone(),
         };
         self.apply_pane_state_change(ws_idx, pane_id, &change);
         Some(update)
@@ -838,6 +913,8 @@ impl AppState {
             return;
         };
 
+        let pane_terminal_id = self.terminal_id_for_pane(ws_idx, pane_id);
+        let workspace_terminal_ids = self.terminal_ids_for_workspace(ws_idx);
         let should_close_workspace = {
             let ws = &mut self.workspaces[ws_idx];
             ws.remove_pane(pane_id)
@@ -846,6 +923,7 @@ impl AppState {
 
         if should_close_workspace {
             self.workspaces.remove(ws_idx);
+            self.remove_unattached_terminal_ids(workspace_terminal_ids);
             if self.workspaces.is_empty() {
                 self.active = None;
                 self.selected = 0;
@@ -862,6 +940,8 @@ impl AppState {
                     self.selected = self.workspaces.len() - 1;
                 }
             }
+        } else {
+            self.remove_unattached_terminal_ids(pane_terminal_id);
         }
     }
 }
@@ -883,6 +963,7 @@ mod tests {
             let ws = Workspace::test_new(name);
             state.workspaces.push(ws);
         }
+        state.ensure_test_terminals();
         if !state.workspaces.is_empty() {
             state.active = Some(0);
             state.mode = Mode::Terminal;
@@ -969,11 +1050,15 @@ mod tests {
     }
 
     fn mark_agent(state: &mut AppState, ws_idx: usize, tab_idx: usize, pane_id: PaneId) {
-        state.workspaces[ws_idx].tabs[tab_idx]
+        let terminal_id = state.workspaces[ws_idx].tabs[tab_idx]
             .panes
-            .get_mut(&pane_id)
+            .get(&pane_id)
             .unwrap()
-            .set_detected_state(Some(Agent::Pi), AgentState::Idle);
+            .attached_terminal_id
+            .clone();
+        if let Some(terminal) = state.terminals.get_mut(&terminal_id) {
+            terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle);
+        }
     }
 
     #[test]
@@ -987,6 +1072,7 @@ mod tests {
 
         let mut state = AppState::test_new();
         state.workspaces = vec![first, second];
+        state.ensure_test_terminals();
         state.active = Some(0);
         state.selected = 0;
         state.mode = Mode::Terminal;
@@ -1044,6 +1130,7 @@ mod tests {
 
         let mut state = AppState::test_new();
         state.workspaces = vec![first, second];
+        state.ensure_test_terminals();
         state.active = Some(0);
         state.selected = 0;
         state.mode = Mode::Terminal;
@@ -1068,6 +1155,7 @@ mod tests {
 
         let mut state = AppState::test_new();
         state.workspaces = vec![workspace];
+        state.ensure_test_terminals();
         state.active = Some(0);
         state.selected = 0;
         state.mode = Mode::Terminal;
@@ -1256,9 +1344,15 @@ mod tests {
             state: AgentState::Working,
         });
 
-        let pane = state.workspaces[0].panes.get(&pane_id).unwrap();
-        assert_eq!(pane.state, AgentState::Working);
-        assert_eq!(pane.detected_agent, Some(Agent::Pi));
+        let terminal_id = state.workspaces[0]
+            .panes
+            .get(&pane_id)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        let terminal = state.terminals.get(&terminal_id).unwrap();
+        assert_eq!(terminal.state, AgentState::Working);
+        assert_eq!(terminal.detected_agent, Some(Agent::Pi));
     }
 
     #[test]
@@ -1268,11 +1362,13 @@ mod tests {
         let bg_pane_id = *state.workspaces[1].panes.keys().next().unwrap();
 
         // First set it to Working
-        state.workspaces[1]
+        let bg_terminal_id = state.workspaces[1]
             .panes
-            .get_mut(&bg_pane_id)
+            .get(&bg_pane_id)
             .unwrap()
-            .state = AgentState::Working;
+            .attached_terminal_id
+            .clone();
+        state.terminals.get_mut(&bg_terminal_id).unwrap().state = AgentState::Working;
 
         // Now transition to Idle while in background
         state.handle_app_event(AppEvent::StateChanged {
@@ -1291,9 +1387,14 @@ mod tests {
         state.active = Some(0);
         state.outer_terminal_focus = Some(true);
         let pane_id = *state.workspaces[0].panes.keys().next().unwrap();
-        let pane = state.workspaces[0].panes.get_mut(&pane_id).unwrap();
-        pane.state = AgentState::Working;
-        pane.seen = false;
+        let terminal_id = state.workspaces[0]
+            .panes
+            .get(&pane_id)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        state.terminals.get_mut(&terminal_id).unwrap().state = AgentState::Working;
+        state.workspaces[0].panes.get_mut(&pane_id).unwrap().seen = false;
 
         state.handle_app_event(AppEvent::StateChanged {
             pane_id,
@@ -1301,8 +1402,9 @@ mod tests {
             state: AgentState::Idle,
         });
 
+        let terminal = state.terminals.get(&terminal_id).unwrap();
+        assert_eq!(terminal.state, AgentState::Idle);
         let pane = state.workspaces[0].panes.get(&pane_id).unwrap();
-        assert_eq!(pane.state, AgentState::Idle);
         assert!(pane.seen);
     }
 
@@ -1394,11 +1496,13 @@ mod tests {
         state.active = Some(0);
         state.toast_config.delivery = crate::config::ToastDelivery::Herdr;
         let bg_pane_id = *state.workspaces[1].panes.keys().next().unwrap();
-        state.workspaces[1]
+        let bg_terminal_id = state.workspaces[1]
             .panes
-            .get_mut(&bg_pane_id)
+            .get(&bg_pane_id)
             .unwrap()
-            .state = AgentState::Working;
+            .attached_terminal_id
+            .clone();
+        state.terminals.get_mut(&bg_terminal_id).unwrap().state = AgentState::Working;
 
         state.handle_app_event(AppEvent::StateChanged {
             pane_id: bg_pane_id,
@@ -1422,6 +1526,7 @@ mod tests {
         state.toast_config.delivery = crate::config::ToastDelivery::Herdr;
         state.workspaces[1].tabs[0].set_custom_name("main".into());
         let second_tab = state.workspaces[1].test_add_tab(Some("logs"));
+        state.ensure_test_terminals();
         let bg_pane_id = state.workspaces[1].tabs[second_tab].root_pane;
 
         state.handle_app_event(AppEvent::StateChanged {
@@ -1443,6 +1548,7 @@ mod tests {
         state.toast_config.delivery = crate::config::ToastDelivery::Herdr;
         state.workspaces[0].tabs[0].set_custom_name("main".into());
         let second_tab = state.workspaces[0].test_add_tab(Some("logs"));
+        state.ensure_test_terminals();
         let bg_pane_id = state.workspaces[0].tabs[second_tab].root_pane;
 
         state.handle_app_event(AppEvent::StateChanged {
@@ -1567,4 +1673,74 @@ mod tests {
         state.close_pane();
         assert_eq!(state.workspaces[0].panes.len(), 1);
     }
+
+    #[test]
+    fn close_pane_removes_unattached_terminal_state() {
+        let mut state = app_with_workspaces(&["test"]);
+        let pane_id = state.workspaces[0].test_split(Direction::Horizontal);
+        state.ensure_test_terminals();
+        let terminal_id = state.terminal_id_for_pane(0, pane_id).unwrap();
+
+        state.close_pane();
+
+        assert!(!state.terminals.contains_key(&terminal_id));
+    }
+
+    #[test]
+    fn close_tab_removes_unattached_terminal_states() {
+        let mut state = app_with_workspaces(&["test"]);
+        let tab_idx = state.workspaces[0].test_add_tab(Some("logs"));
+        state.ensure_test_terminals();
+        state.workspaces[0].switch_tab(tab_idx);
+        let pane_id = state.workspaces[0].tabs[tab_idx].root_pane;
+        let terminal_id = state.terminal_id_for_pane(0, pane_id).unwrap();
+
+        state.close_tab();
+
+        assert!(!state.terminals.contains_key(&terminal_id));
+    }
+
+    #[test]
+    fn close_workspace_removes_unattached_terminal_states() {
+        let mut state = app_with_workspaces(&["one", "two"]);
+        let terminal_id = state
+            .terminal_id_for_pane(0, state.workspaces[0].tabs[0].root_pane)
+            .unwrap();
+
+        state.close_selected_workspace();
+
+        assert!(!state.terminals.contains_key(&terminal_id));
+    }
+
+    #[test]
+    fn close_tab_last_tab_closes_active_workspace_not_selected_workspace() {
+        let mut state = app_with_workspaces(&["selected", "active"]);
+        let active_terminal_id = state
+            .terminal_id_for_pane(1, state.workspaces[1].tabs[0].root_pane)
+            .unwrap();
+        state.active = Some(1);
+        state.selected = 0;
+
+        state.close_tab();
+
+        assert_eq!(state.workspaces.len(), 1);
+        assert_eq!(state.workspaces[0].display_name(), "selected");
+        assert!(!state.terminals.contains_key(&active_terminal_id));
+    }
+
+    #[test]
+    fn close_pane_last_pane_closes_active_workspace_not_selected_workspace() {
+        let mut state = app_with_workspaces(&["selected", "active"]);
+        let active_terminal_id = state
+            .terminal_id_for_pane(1, state.workspaces[1].tabs[0].root_pane)
+            .unwrap();
+        state.active = Some(1);
+        state.selected = 0;
+
+        state.close_pane();
+
+        assert_eq!(state.workspaces.len(), 1);
+        assert_eq!(state.workspaces[0].display_name(), "selected");
+        assert!(!state.terminals.contains_key(&active_terminal_id));
+    }
 }
diff --git a/src/app/agents.rs b/src/app/agents.rs
index 35e26c42..f9e410f5 100644
--- a/src/app/agents.rs
+++ b/src/app/agents.rs
@@ -77,19 +77,19 @@ impl App {
             }
         }
 
-        let Some(ws) = self.state.workspaces.get_mut(resolved.ws_idx) else {
-            return Err(AgentRenameError::Target(TerminalTargetError::NotFound {
-                target: target.to_string(),
-            }));
-        };
-        let Some(pane_state) = ws.pane_state_mut(resolved.pane_id) else {
+        let Some(terminal) = self
+            .state
+            .terminals
+            .values_mut()
+            .find(|terminal| terminal.id.to_string() == resolved.terminal_id)
+        else {
             return Err(AgentRenameError::Target(TerminalTargetError::NotFound {
                 target: target.to_string(),
             }));
         };
         match normalized_name {
-            Some(name) => pane_state.set_manual_label(name),
-            None => pane_state.clear_manual_label(),
+            Some(name) => terminal.set_manual_label(name),
+            None => terminal.clear_manual_label(),
         }
         self.state.mark_session_dirty();
         self.agent_info(resolved.ws_idx, resolved.pane_id)
@@ -185,13 +185,17 @@ impl App {
             )?
         };
 
-        let Some(ws) = self.state.workspaces.get_mut(ws_idx) else {
-            return Err(AgentStartError::SpawnFailed("workspace disappeared".into()));
-        };
-        let Some(pane_state) = ws.pane_state_mut(pane_id) else {
-            return Err(AgentStartError::SpawnFailed("pane disappeared".into()));
+        let terminal_id = self
+            .state
+            .workspaces
+            .get(ws_idx)
+            .and_then(|ws| ws.terminal_id(pane_id))
+            .cloned()
+            .ok_or_else(|| AgentStartError::SpawnFailed("terminal disappeared".into()))?;
+        let Some(terminal) = self.state.terminals.get_mut(&terminal_id) else {
+            return Err(AgentStartError::SpawnFailed("terminal disappeared".into()));
         };
-        pane_state.set_manual_label(name);
+        terminal.set_manual_label(name);
         self.state.mark_session_dirty();
 
         let agent = self
@@ -317,7 +321,7 @@ impl App {
         argv: &[String],
         focus: bool,
     ) -> Result<(usize, usize, crate::layout::PaneId), AgentStartError> {
-        let ws = crate::workspace::Workspace::new_argv_command(
+        let (ws, terminal, runtime) = crate::workspace::Workspace::new_argv_command(
             cwd,
             rows,
             cols,
@@ -329,6 +333,10 @@ impl App {
             self.render_dirty.clone(),
         )
         .map_err(|err| AgentStartError::SpawnFailed(err.to_string()))?;
+        self.state
+            .terminal_runtimes
+            .insert(terminal.id.clone(), runtime);
+        self.state.terminals.insert(terminal.id.clone(), terminal);
         self.state.workspaces.push(ws);
         let ws_idx = self.state.workspaces.len() - 1;
         if focus || self.state.active.is_none() {
@@ -375,13 +383,19 @@ impl App {
                 target: target_pane.raw().to_string(),
             })?
             .map_err(|err| AgentStartError::SpawnFailed(err.to_string()))?;
+        self.state
+            .terminal_runtimes
+            .insert(result.1.terminal.id.clone(), result.1.runtime);
+        self.state
+            .terminals
+            .insert(result.1.terminal.id.clone(), result.1.terminal);
         if focus {
             self.state.switch_workspace(ws_idx);
             self.state.switch_tab(result.0);
             self.state.mode = Mode::Terminal;
         }
         self.schedule_session_save();
-        Ok((ws_idx, result.0, result.1))
+        Ok((ws_idx, result.0, result.1.pane_id))
     }
 
     fn agent_info(
@@ -409,23 +423,11 @@ impl App {
         name: &str,
         except_terminal_id: &str,
     ) -> Vec<crate::api::schema::AgentInfo> {
-        self.state
-            .workspaces
-            .iter()
-            .enumerate()
-            .flat_map(|(ws_idx, ws)| {
-                ws.tabs.iter().flat_map(move |tab| {
-                    tab.layout
-                        .pane_ids()
-                        .into_iter()
-                        .filter_map(move |pane_id| {
-                            let pane_state = ws.pane_state(pane_id)?;
-                            (pane_state.manual_label.as_deref() == Some(name))
-                                .then(|| self.agent_info(ws_idx, pane_id))?
-                        })
-                })
+        self.collect_agent_infos()
+            .into_iter()
+            .filter(|agent| {
+                agent.name.as_deref() == Some(name) && agent.terminal_id != except_terminal_id
             })
-            .filter(|agent| agent.terminal_id != except_terminal_id)
             .collect()
     }
 }
diff --git a/src/app/api.rs b/src/app/api.rs
index c6fa88fa..ab26f82b 100644
--- a/src/app/api.rs
+++ b/src/app/api.rs
@@ -75,7 +75,8 @@ impl App {
         if let Some((pane_id, agent)) = released_agent {
             if pane_updates.iter().any(|update| update.pane_id == pane_id) {
                 if let Some((ws_idx, _)) = self.find_pane(pane_id) {
-                    if let Some(runtime) = self.state.workspaces[ws_idx].runtimes.get(&pane_id) {
+                    if let Some(runtime) = self.state.runtime_for_pane_in_workspace(ws_idx, pane_id)
+                    {
                         runtime.begin_graceful_release(agent);
                     }
                 }
@@ -129,7 +130,12 @@ impl App {
                     else {
                         continue;
                     };
-                    let Some(agent_label) = pane.effective_agent_label() else {
+                    let Some(agent_label) = self
+                        .state
+                        .terminals
+                        .get(&pane.attached_terminal_id)
+                        .and_then(|terminal| terminal.effective_agent_label())
+                    else {
                         continue;
                     };
                     let event_text = match kind {
@@ -199,14 +205,9 @@ impl App {
                 .workspaces
                 .get(update.ws_idx)
                 .and_then(|ws| ws.pane_state(update.pane_id))
-                .map(|pane| pane_agent_status(pane.state, pane.seen))
+                .map(|pane| pane_agent_status(update.state, pane.seen))
                 .unwrap_or_else(|| pane_agent_status(update.state, true));
-            let custom_status = self
-                .state
-                .workspaces
-                .get(update.ws_idx)
-                .and_then(|ws| ws.pane_state(update.pane_id))
-                .and_then(|pane| pane.effective_custom_status().map(str::to_string));
+            let custom_status = update.custom_status.clone();
             self.emit_event(crate::api::schema::EventEnvelope {
                 event: crate::api::schema::EventKind::PaneAgentStatusChanged,
                 data: crate::api::schema::EventData::PaneAgentStatusChanged {
@@ -296,7 +297,7 @@ impl App {
             .state
             .workspaces
             .get(ws_idx)
-            .and_then(|ws| ws.runtime(pane_id))
+            .and_then(|_| self.state.runtime_for_pane_in_workspace(ws_idx, pane_id))
         else {
             return;
         };
@@ -629,11 +630,9 @@ impl App {
                 let cwd = cwd
                     .map(std::path::PathBuf::from)
                     .or_else(|| {
-                        self.state.workspaces.get(ws_idx).and_then(|ws| {
-                            ws.active_tab()
-                                .and_then(|tab| tab.focused_runtime())
-                                .and_then(|rt| rt.cwd())
-                        })
+                        self.state
+                            .focused_runtime_in_workspace(ws_idx)
+                            .and_then(|rt| rt.cwd())
                     })
                     .or_else(|| std::env::current_dir().ok())
                     .unwrap_or_else(|| std::path::PathBuf::from("/"));
@@ -653,7 +652,11 @@ impl App {
                         )
                     });
                 match result {
-                    Ok(tab_idx) => {
+                    Ok((tab_idx, terminal, runtime)) => {
+                        self.state
+                            .terminal_runtimes
+                            .insert(terminal.id.clone(), runtime);
+                        self.state.terminals.insert(terminal.id.clone(), terminal);
                         if let Some(label) = label {
                             let workspace_id = self.state.workspaces[ws_idx].id.clone();
                             let tab_id = self
@@ -785,6 +788,7 @@ impl App {
                     })
                     .unwrap();
                 };
+                let terminal_ids = self.state.terminal_ids_for_tab(ws_idx, tab_idx);
                 let Some(ws) = self.state.workspaces.get_mut(ws_idx) else {
                     return serde_json::to_string(&ErrorResponse {
                         id: request.id,
@@ -815,6 +819,7 @@ impl App {
                     })
                     .unwrap();
                 }
+                self.state.remove_unattached_terminal_ids(terminal_ids);
                 self.schedule_session_save();
                 self.emit_event(crate::api::schema::EventEnvelope {
                     event: crate::api::schema::EventKind::TabClosed,
@@ -1004,6 +1009,16 @@ impl App {
                     .unwrap();
                 };
                 let (rows, cols) = self.state.estimate_pane_size();
+                let split_cwd = params.cwd.map(std::path::PathBuf::from).or_else(|| {
+                    self.state.workspaces.get(ws_idx).and_then(|ws| {
+                        let tab_idx = ws.find_tab_index_for_pane(target_pane_id)?;
+                        ws.tabs.get(tab_idx)?.cwd_for_pane(
+                            target_pane_id,
+                            &self.state.terminals,
+                            &self.state.terminal_runtimes,
+                        )
+                    })
+                });
                 let Some(ws) = self.state.workspaces.get_mut(ws_idx) else {
                     return serde_json::to_string(&ErrorResponse {
                         id: request.id,
@@ -1022,12 +1037,12 @@ impl App {
                         ratatui::layout::Direction::Vertical
                     }
                 };
-                let (target_tab_idx, new_pane_id) = match ws.split_pane(
+                let (target_tab_idx, new_pane) = match ws.split_pane(
                     target_pane_id,
                     direction,
                     rows,
                     cols,
-                    params.cwd.map(std::path::PathBuf::from),
+                    split_cwd,
                     self.state.pane_scrollback_limit_bytes,
                     self.state.host_terminal_theme,
                     params.focus,
@@ -1059,8 +1074,14 @@ impl App {
                     self.state.switch_tab(target_tab_idx);
                     self.state.mode = Mode::Terminal;
                 }
+                self.state
+                    .terminal_runtimes
+                    .insert(new_pane.terminal.id.clone(), new_pane.runtime);
+                self.state
+                    .terminals
+                    .insert(new_pane.terminal.id.clone(), new_pane.terminal);
                 self.schedule_session_save();
-                let pane = self.pane_info(ws_idx, new_pane_id).unwrap();
+                let pane = self.pane_info(ws_idx, new_pane.pane_id).unwrap();
                 self.emit_event(crate::api::schema::EventEnvelope {
                     event: crate::api::schema::EventKind::PaneCreated,
                     data: crate::api::schema::EventData::PaneCreated { pane: pane.clone() },
@@ -1122,7 +1143,13 @@ impl App {
                     })
                     .unwrap();
                 };
-                let Some(ws) = self.state.workspaces.get_mut(ws_idx) else {
+                let Some(terminal_id) = self
+                    .state
+                    .workspaces
+                    .get(ws_idx)
+                    .and_then(|ws| ws.terminal_id(pane_id))
+                    .cloned()
+                else {
                     return serde_json::to_string(&ErrorResponse {
                         id: request.id,
                         error: ErrorBody {
@@ -1132,7 +1159,7 @@ impl App {
                     })
                     .unwrap();
                 };
-                let Some(pane_state) = ws.pane_state_mut(pane_id) else {
+                let Some(terminal) = self.state.terminals.get_mut(&terminal_id) else {
                     return serde_json::to_string(&ErrorResponse {
                         id: request.id,
                         error: ErrorBody {
@@ -1143,8 +1170,8 @@ impl App {
                     .unwrap();
                 };
                 match params.label.map(|label| label.trim().to_string()) {
-                    Some(label) if !label.is_empty() => pane_state.set_manual_label(label),
-                    _ => pane_state.clear_manual_label(),
+                    Some(label) if !label.is_empty() => terminal.set_manual_label(label),
+                    _ => terminal.clear_manual_label(),
                 }
                 self.state.mark_session_dirty();
                 let pane = self.pane_info(ws_idx, pane_id).unwrap();
@@ -1419,6 +1446,7 @@ impl App {
                     .unwrap();
                 };
                 let workspace_id = self.state.workspaces[ws_idx].id.clone();
+                let terminal_id = self.state.terminal_id_for_pane(ws_idx, pane_id);
                 let should_close_workspace = {
                     let Some(ws) = self.state.workspaces.get_mut(ws_idx) else {
                         return serde_json::to_string(&ErrorResponse {
@@ -1447,6 +1475,7 @@ impl App {
                         data: crate::api::schema::EventData::WorkspaceClosed { workspace_id },
                     });
                 } else {
+                    self.state.remove_unattached_terminal_ids(terminal_id);
                     self.schedule_session_save();
                     self.emit_event(crate::api::schema::EventEnvelope {
                         event: crate::api::schema::EventKind::PaneClosed,
diff --git a/src/app/api_helpers.rs b/src/app/api_helpers.rs
index 56907ece..1ebb30ef 100644
--- a/src/app/api_helpers.rs
+++ b/src/app/api_helpers.rs
@@ -30,7 +30,7 @@ fn parse_api_key(key: &str) -> Option<crossterm::event::KeyEvent> {
     }
 }
 
-pub(super) fn encode_api_text(runtime: &crate::pane::PaneRuntime, text: &str) -> Vec<u8> {
+pub(super) fn encode_api_text(runtime: &crate::terminal::TerminalRuntime, text: &str) -> Vec<u8> {
     let bracketed = runtime
         .input_state()
         .map(|state| state.bracketed_paste)
@@ -43,7 +43,7 @@ pub(super) fn encode_api_text(runtime: &crate::pane::PaneRuntime, text: &str) ->
 }
 
 pub(super) fn encode_api_keys(
-    runtime: &crate::pane::PaneRuntime,
+    runtime: &crate::terminal::TerminalRuntime,
     keys: &[String],
 ) -> Result<Vec<Vec<u8>>, String> {
     let mut encoded_keys = Vec::with_capacity(keys.len());
diff --git a/src/app/creation.rs b/src/app/creation.rs
index 6e557066..1832e637 100644
--- a/src/app/creation.rs
+++ b/src/app/creation.rs
@@ -78,13 +78,17 @@ impl App {
         };
         let (rows, cols) = self.state.estimate_pane_size();
         let ws = &mut self.state.workspaces[ws_idx];
-        let idx = ws.create_tab(
+        let (idx, terminal, runtime) = ws.create_tab(
             rows,
             cols,
             initial_cwd,
             self.state.pane_scrollback_limit_bytes,
             self.state.host_terminal_theme,
         )?;
+        self.state
+            .terminal_runtimes
+            .insert(terminal.id.clone(), runtime);
+        self.state.terminals.insert(terminal.id.clone(), terminal);
         if focus {
             ws.switch_tab(idx);
             self.state.mode = Mode::Terminal;
@@ -105,7 +109,7 @@ impl App {
         focus: bool,
     ) -> std::io::Result<usize> {
         let (rows, cols) = self.state.estimate_pane_size();
-        let ws = Workspace::new(
+        let (ws, terminal, runtime) = Workspace::new(
             initial_cwd,
             rows,
             cols,
@@ -115,6 +119,10 @@ impl App {
             self.render_notify.clone(),
             self.render_dirty.clone(),
         )?;
+        self.state
+            .terminal_runtimes
+            .insert(terminal.id.clone(), runtime);
+        self.state.terminals.insert(terminal.id.clone(), terminal);
         self.state.workspaces.push(ws);
         let idx = self.state.workspaces.len() - 1;
         let workspace_id = self.state.workspaces[idx].id.clone();
@@ -177,7 +185,12 @@ impl App {
         let (agg_state, seen) = tab
             .panes
             .values()
-            .map(|pane| (pane.state, pane.seen))
+            .filter_map(|pane| {
+                self.state
+                    .terminals
+                    .get(&pane.attached_terminal_id)
+                    .map(|terminal| (terminal.state, pane.seen))
+            })
             .max_by_key(|(state, seen)| tab_attention_priority(*state, *seen))
             .unwrap_or((crate::detect::AgentState::Unknown, true));
         Some(crate::api::schema::TabInfo {
@@ -230,6 +243,7 @@ impl App {
     ) -> Option<crate::api::schema::PaneInfo> {
         let ws = self.state.workspaces.get(ws_idx)?;
         let pane = ws.pane_state(pane_id)?;
+        let terminal = self.state.terminals.get(&pane.attached_terminal_id)?;
         let tab_idx = ws.find_tab_index_for_pane(pane_id)?;
         let focused = self.state.active == Some(ws_idx)
             && ws.active_tab == tab_idx
@@ -238,18 +252,22 @@ impl App {
                 .is_some_and(|focused| focused == pane_id);
         Some(crate::api::schema::PaneInfo {
             pane_id: self.public_pane_id(ws_idx, pane_id)?,
-            terminal_id: ws.terminal_id(pane_id)?.to_string(),
+            terminal_id: terminal.id.to_string(),
             workspace_id: self.public_workspace_id(ws_idx),
             tab_id: self.public_tab_id(ws_idx, tab_idx)?,
             focused,
             cwd: ws.tabs[tab_idx]
-                .cwd_for_pane(pane_id)
+                .cwd_for_pane(
+                    pane_id,
+                    &self.state.terminals,
+                    &self.state.terminal_runtimes,
+                )
                 .map(|cwd| cwd.display().to_string()),
-            label: pane.manual_label.clone(),
-            agent: pane.effective_agent_label().map(str::to_string),
-            agent_status: pane_agent_status(pane.state, pane.seen),
-            custom_status: pane.effective_custom_status().map(str::to_string),
-            revision: 0,
+            label: terminal.manual_label.clone(),
+            agent: terminal.effective_agent_label().map(str::to_string),
+            agent_status: pane_agent_status(terminal.state, pane.seen),
+            custom_status: terminal.effective_custom_status().map(str::to_string),
+            revision: terminal.revision,
         })
     }
 
@@ -257,9 +275,8 @@ impl App {
         &self,
         ws_idx: usize,
         pane_id: crate::layout::PaneId,
-    ) -> Option<(&crate::pane::PaneRuntime, String)> {
-        let ws = self.state.workspaces.get(ws_idx)?;
-        let runtime = ws.runtime(pane_id)?;
+    ) -> Option<(&crate::terminal::TerminalRuntime, String)> {
+        let runtime = self.state.runtime_for_pane_in_workspace(ws_idx, pane_id)?;
         Some((runtime, self.public_workspace_id(ws_idx)))
     }
 
@@ -267,14 +284,13 @@ impl App {
         &self,
         ws_idx: usize,
         pane_id: crate::layout::PaneId,
-    ) -> Option<&crate::pane::PaneRuntime> {
-        let ws = self.state.workspaces.get(ws_idx)?;
-        ws.runtime(pane_id)
+    ) -> Option<&crate::terminal::TerminalRuntime> {
+        self.state.runtime_for_pane_in_workspace(ws_idx, pane_id)
     }
 
     pub(super) fn workspace_info(&self, index: usize) -> crate::api::schema::WorkspaceInfo {
         let ws = &self.state.workspaces[index];
-        let (agg_state, seen) = ws.aggregate_state();
+        let (agg_state, seen) = ws.aggregate_state(&self.state.terminals);
         crate::api::schema::WorkspaceInfo {
             workspace_id: self.public_workspace_id(index),
             number: index + 1,
diff --git a/src/app/input/mod.rs b/src/app/input/mod.rs
index 575b373d..fea88b55 100644
--- a/src/app/input/mod.rs
+++ b/src/app/input/mod.rs
@@ -82,8 +82,8 @@ impl App {
         if self.state.mode != Mode::Terminal {
             return;
         }
-        if let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) {
-            if let Some(rt) = ws.focused_runtime() {
+        if let Some(ws_idx) = self.state.active {
+            if let Some(rt) = self.state.focused_runtime_in_workspace(ws_idx) {
                 let _ = rt.send_paste(text).await;
             }
         }
@@ -197,11 +197,17 @@ impl AppState {
         let cwd = self
             .active
             .and_then(|i| self.workspaces.get(i))
-            .and_then(|ws| ws.focused_runtime())
-            .and_then(|rt| rt.cwd());
+            .and_then(|ws| {
+                let tab = ws.active_tab()?;
+                tab.cwd_for_pane(
+                    tab.layout.focused(),
+                    &self.terminals,
+                    &self.terminal_runtimes,
+                )
+            });
 
         if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) {
-            if let Ok(new_id) = ws.split_focused(
+            if let Ok(new_pane) = ws.split_focused(
                 direction,
                 new_rows,
                 new_cols,
@@ -209,6 +215,9 @@ impl AppState {
                 self.pane_scrollback_limit_bytes,
                 self.host_terminal_theme,
             ) {
+                let new_id = new_pane.pane_id;
+                self.terminals
+                    .insert(new_pane.terminal.id.clone(), new_pane.terminal);
                 ws.layout.focus_pane(new_id);
                 self.mark_session_dirty();
                 self.mode = Mode::Terminal;
@@ -277,6 +286,8 @@ fn numbered_lines_bytes(count: usize) -> Vec<u8> {
 fn capture_snapshot(state: &AppState) -> crate::persist::SessionSnapshot {
     crate::persist::capture(
         &state.workspaces,
+        &state.terminals,
+        &state.terminal_runtimes,
         state.active,
         state.selected,
         state.agent_panel_scope,
diff --git a/src/app/input/modal.rs b/src/app/input/modal.rs
index 367e7e84..6de349cb 100644
--- a/src/app/input/modal.rs
+++ b/src/app/input/modal.rs
@@ -190,11 +190,14 @@ pub(super) fn open_rename_pane(state: &mut AppState, pane_id: crate::layout::Pan
     let Some(pane) = ws.pane_state(pane_id) else {
         return;
     };
+    let terminal = state.terminals.get(&pane.attached_terminal_id);
     state.creating_new_tab = false;
     state.requested_new_tab_name = None;
     state.rename_pane_target = Some(pane_id);
-    state.name_input = pane.manual_label.clone().unwrap_or_default();
-    state.name_input_replace_on_type = pane.manual_label.is_none();
+    state.name_input = terminal
+        .and_then(|t| t.manual_label.clone())
+        .unwrap_or_default();
+    state.name_input_replace_on_type = terminal.and_then(|t| t.manual_label.as_ref()).is_none();
     state.mode = Mode::RenamePane;
 }
 
@@ -316,10 +319,13 @@ pub(super) fn apply_rename_action(state: &mut AppState, action: ModalAction) {
                 Mode::RenamePane => {
                     if let (Some(ws_idx), Some(pane_id)) = (state.active, state.rename_pane_target)
                     {
-                        if let Some(ws) = state.workspaces.get_mut(ws_idx) {
-                            if let Some(pane) = ws.pane_state_mut(pane_id) {
-                                pane.set_manual_label(new_name);
-                                state.mark_session_dirty();
+                        if let Some(ws) = state.workspaces.get(ws_idx) {
+                            if let Some(pane) = ws.pane_state(pane_id) {
+                                let terminal_id = pane.attached_terminal_id.clone();
+                                if let Some(terminal) = state.terminals.get_mut(&terminal_id) {
+                                    terminal.set_manual_label(new_name);
+                                    state.mark_session_dirty();
+                                }
                             }
                         }
                     }
@@ -468,10 +474,13 @@ pub(super) fn apply_context_menu_action(state: &mut AppState, menu: ContextMenuS
         }
         (ContextMenuKind::Pane { pane_id, .. }, Some("Clear pane name")) => {
             if let Some(ws_idx) = state.active {
-                if let Some(ws) = state.workspaces.get_mut(ws_idx) {
-                    if let Some(pane) = ws.pane_state_mut(pane_id) {
-                        pane.clear_manual_label();
-                        state.mark_session_dirty();
+                if let Some(ws) = state.workspaces.get(ws_idx) {
+                    if let Some(pane) = ws.pane_state(pane_id) {
+                        let terminal_id = pane.attached_terminal_id.clone();
+                        if let Some(terminal) = state.terminals.get_mut(&terminal_id) {
+                            terminal.clear_manual_label();
+                            state.mark_session_dirty();
+                        }
                     }
                 }
             }
diff --git a/src/app/input/mouse.rs b/src/app/input/mouse.rs
index a7a2159a..10ef9c18 100644
--- a/src/app/input/mouse.rs
+++ b/src/app/input/mouse.rs
@@ -712,7 +712,8 @@ impl AppState {
                         .active
                         .and_then(|ws_idx| self.workspaces.get(ws_idx))
                         .and_then(|ws| ws.pane_state(info.id))
-                        .and_then(|pane| pane.manual_label.as_ref())
+                        .and_then(|pane| self.terminals.get(&pane.attached_terminal_id))
+                        .and_then(|terminal| terminal.manual_label.as_ref())
                         .is_some();
                     self.context_menu = Some(ContextMenuState {
                         kind: ContextMenuKind::Pane {
@@ -1061,16 +1062,16 @@ impl AppState {
     }
 
     pub(super) fn scroll_pane_up(&self, pane_id: crate::layout::PaneId, lines: usize) {
-        if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) {
-            if let Some(rt) = ws.runtimes.get(&pane_id) {
+        if let Some(ws_idx) = self.active {
+            if let Some(rt) = self.runtime_for_pane_in_workspace(ws_idx, pane_id) {
                 rt.scroll_up(lines);
             }
         }
     }
 
     pub(super) fn scroll_pane_down(&self, pane_id: crate::layout::PaneId, lines: usize) {
-        if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) {
-            if let Some(rt) = ws.runtimes.get(&pane_id) {
+        if let Some(ws_idx) = self.active {
+            if let Some(rt) = self.runtime_for_pane_in_workspace(ws_idx, pane_id) {
                 rt.scroll_down(lines);
             }
         }
@@ -1081,9 +1082,8 @@ impl AppState {
         pane_id: crate::layout::PaneId,
     ) -> Option<crate::pane::ScrollMetrics> {
         self.active
-            .and_then(|i| self.workspaces.get(i))
-            .and_then(|ws| ws.runtime(pane_id))
-            .and_then(crate::pane::PaneRuntime::scroll_metrics)
+            .and_then(|i| self.runtime_for_pane_in_workspace(i, pane_id))
+            .and_then(crate::terminal::TerminalRuntime::scroll_metrics)
     }
 
     pub(super) fn handle_terminal_wheel(&mut self, mouse: MouseEvent) {
@@ -1112,8 +1112,8 @@ impl AppState {
             return;
         }
 
-        if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) {
-            if let Some(rt) = ws.focused_runtime() {
+        if let Some(ws_idx) = self.active {
+            if let Some(rt) = self.focused_runtime_in_workspace(ws_idx) {
                 match mouse.kind {
                     MouseEventKind::ScrollUp => rt.scroll_up(LINES_PER_NOTCH),
                     MouseEventKind::ScrollDown => rt.scroll_down(LINES_PER_NOTCH),
@@ -1124,10 +1124,10 @@ impl AppState {
     }
 
     pub(super) fn forward_pane_mouse_button(&self, info: &PaneInfo, mouse: MouseEvent) -> bool {
-        let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else {
+        let Some(ws_idx) = self.active else {
             return false;
         };
-        let Some(rt) = ws.runtimes.get(&info.id) else {
+        let Some(rt) = self.runtime_for_pane_in_workspace(ws_idx, info.id) else {
             return false;
         };
         let column = mouse.column.saturating_sub(info.inner_rect.x);
@@ -1169,10 +1169,10 @@ impl AppState {
     }
 
     pub(super) fn forward_pane_wheel(&self, info: &PaneInfo, mouse: MouseEvent) -> bool {
-        let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else {
+        let Some(ws_idx) = self.active else {
             return false;
         };
-        let Some(rt) = ws.runtimes.get(&info.id) else {
+        let Some(rt) = self.runtime_for_pane_in_workspace(ws_idx, info.id) else {
             return false;
         };
         match rt.wheel_routing() {
@@ -1209,8 +1209,8 @@ impl AppState {
         pane_id: crate::layout::PaneId,
         offset_from_bottom: usize,
     ) {
-        if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) {
-            if let Some(rt) = ws.runtimes.get(&pane_id) {
+        if let Some(ws_idx) = self.active {
+            if let Some(rt) = self.runtime_for_pane_in_workspace(ws_idx, pane_id) {
                 rt.set_scroll_offset_from_bottom(offset_from_bottom);
             }
         }
@@ -1221,7 +1221,7 @@ impl AppState {
         col: u16,
         row: u16,
     ) -> Option<(crate::layout::PaneId, ScrollbarClickTarget)> {
-        let ws = self.active.and_then(|i| self.workspaces.get(i))?;
+        let ws_idx = self.active?;
         let info = self.view.pane_infos.iter().find(|info| {
             crate::ui::pane_scrollbar_rect(info).is_some_and(|track| {
                 col >= track.x
@@ -1230,7 +1230,7 @@ impl AppState {
                     && row < track.y + track.height
             })
         })?;
-        let rt = ws.runtimes.get(&info.id)?;
+        let rt = self.runtime_for_pane_in_workspace(ws_idx, info.id)?;
         let metrics = rt.scroll_metrics()?;
         if metrics.max_offset_from_bottom == 0 {
             return None;
@@ -1254,14 +1254,14 @@ impl AppState {
         row: u16,
         grab_row_offset: u16,
     ) -> Option<usize> {
-        let ws = self.active.and_then(|i| self.workspaces.get(i))?;
+        let ws_idx = self.active?;
         let info = self
             .view
             .pane_infos
             .iter()
             .find(|info| info.id == pane_id)?;
         let track = crate::ui::pane_scrollbar_rect(info)?;
-        let rt = ws.runtimes.get(&pane_id)?;
+        let rt = self.runtime_for_pane_in_workspace(ws_idx, pane_id)?;
         let metrics = rt.scroll_metrics()?;
         if metrics.max_offset_from_bottom == 0 {
             return None;
@@ -1345,12 +1345,19 @@ mod tests {
         background.tabs[0].layout.focus_pane(first_pane);
 
         app.state.workspaces = vec![active, background];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.toast_config.delivery = crate::config::ToastDelivery::Herdr;
-        app.state.workspaces[1]
+        let target_terminal_id = app.state.workspaces[1]
             .panes
-            .get_mut(&target_pane)
+            .get(&target_pane)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&target_terminal_id)
             .unwrap()
             .state = AgentState::Working;
 
@@ -1606,17 +1613,17 @@ mod tests {
             .expect("second pane info")
             .clone();
 
-        app.state.workspaces[0].tabs[0].runtimes.insert(
+        app.state.insert_test_runtime(
             first_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 first_info.inner_rect.width.max(1),
                 first_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
             ),
         );
-        app.state.workspaces[0].tabs[0].runtimes.insert(
+        app.state.insert_test_runtime(
             second_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 second_info.inner_rect.width.max(1),
                 second_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
@@ -1675,17 +1682,17 @@ mod tests {
             .expect("second pane info")
             .clone();
 
-        app.state.workspaces[0].tabs[0].runtimes.insert(
+        app.state.insert_test_runtime(
             first_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 first_info.inner_rect.width.max(1),
                 first_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
             ),
         );
-        app.state.workspaces[0].tabs[0].runtimes.insert(
+        app.state.insert_test_runtime(
             second_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 second_info.inner_rect.width.max(1),
                 second_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
diff --git a/src/app/input/navigate.rs b/src/app/input/navigate.rs
index f5a0bcaa..9fc11605 100644
--- a/src/app/input/navigate.rs
+++ b/src/app/input/navigate.rs
@@ -126,10 +126,10 @@ impl App {
     }
 
     fn pass_through_key_to_focused_pane(&mut self, key: TerminalKey) -> bool {
-        let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) else {
+        let Some(ws_idx) = self.state.active else {
             return false;
         };
-        let Some(rt) = ws.focused_runtime() else {
+        let Some(rt) = self.state.focused_runtime_in_workspace(ws_idx) else {
             return false;
         };
 
@@ -191,10 +191,13 @@ impl App {
                     if let Some(public_pane_id) = self.public_pane_id(ws_idx, pane_id) {
                         env.push(("HERDR_ACTIVE_PANE_ID".to_string(), public_pane_id));
                     }
-                    if let Some(pane_cwd) = workspace
-                        .active_tab()
-                        .and_then(|tab| tab.cwd_for_pane(pane_id))
-                    {
+                    if let Some(pane_cwd) = workspace.active_tab().and_then(|tab| {
+                        tab.cwd_for_pane(
+                            pane_id,
+                            &self.state.terminals,
+                            &self.state.terminal_runtimes,
+                        )
+                    }) {
                         env.push((
                             "HERDR_ACTIVE_PANE_CWD".to_string(),
                             pane_cwd.display().to_string(),
@@ -308,10 +311,14 @@ impl App {
             .focused_pane_id()
             .ok_or_else(|| std::io::Error::other("no focused pane"))?;
         let previous_zoomed = ws.active_tab().map(|tab| tab.zoomed).unwrap_or(false);
-        let cwd = ws
-            .active_tab()
-            .and_then(|tab| tab.cwd_for_pane(previous_focus));
-        let new_pane_id = ws.split_focused_command(
+        let cwd = ws.active_tab().and_then(|tab| {
+            tab.cwd_for_pane(
+                previous_focus,
+                &self.state.terminals,
+                &self.state.terminal_runtimes,
+            )
+        });
+        let new_pane = ws.split_focused_command(
             Direction::Horizontal,
             new_rows,
             new_cols,
@@ -321,6 +328,10 @@ impl App {
             self.state.pane_scrollback_limit_bytes,
             self.state.host_terminal_theme,
         )?;
+        let new_pane_id = new_pane.pane_id;
+        self.state
+            .terminals
+            .insert(new_pane.terminal.id.clone(), new_pane.terminal);
         ws.active_tab_mut()
             .expect("workspace must have an active tab")
             .layout
@@ -1072,7 +1083,7 @@ mod tests {
             api_rx,
             crate::api::EventHub::default(),
         );
-        let workspace = Workspace::new(
+        let (workspace, terminal, runtime) = Workspace::new(
             std::env::current_dir().unwrap_or_else(|_| "/".into()),
             24,
             80,
@@ -1084,6 +1095,10 @@ mod tests {
         )
         .expect("workspace should spawn");
         app.state.workspaces = vec![workspace];
+        app.state
+            .terminal_runtimes
+            .insert(terminal.id.clone(), runtime);
+        app.state.terminals.insert(terminal.id.clone(), terminal);
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
diff --git a/src/app/input/sidebar.rs b/src/app/input/sidebar.rs
index 8f6c7792..e8e1e094 100644
--- a/src/app/input/sidebar.rs
+++ b/src/app/input/sidebar.rs
@@ -351,7 +351,7 @@ impl AppState {
         let ws_idx = self.collapsed_detail_workspace_idx()?;
         let ws = self.workspaces.get(ws_idx)?;
         let detail_idx = (row - detail_content_area.y) as usize;
-        let details = ws.pane_details();
+        let details = ws.pane_details(&self.terminals);
         let detail = details.get(detail_idx)?;
         Some((ws_idx, detail.tab_idx, detail.pane_id))
     }
@@ -633,19 +633,26 @@ mod tests {
         let mut ws = Workspace::test_new("test");
         ws.tabs[0].set_custom_name("main".into());
         let first_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .panes
-            .get_mut(&first_pane)
+        let first_tab = ws.test_add_tab(Some("logs"));
+        let second_pane = ws.tabs[first_tab].root_pane;
+        app.state.workspaces = vec![ws];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
             .unwrap()
             .detected_agent = Some(Agent::Pi);
-        let second_tab = ws.test_add_tab(Some("logs"));
-        let second_pane = ws.tabs[second_tab].root_pane;
-        ws.tabs[second_tab]
-            .panes
-            .get_mut(&second_pane)
+        let second_terminal_id = app.state.workspaces[0].tabs[first_tab].panes[&second_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
             .unwrap()
             .detected_agent = Some(Agent::Claude);
-        app.state.workspaces = vec![ws];
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -659,9 +666,9 @@ mod tests {
         );
         assert_eq!(app.state.mode, Mode::Terminal);
         let snapshot = capture_snapshot(&app.state);
-        assert_eq!(snapshot.workspaces[0].active_tab, second_tab);
+        assert_eq!(snapshot.workspaces[0].active_tab, first_tab);
         assert_eq!(
-            snapshot.workspaces[0].tabs[second_tab].focused,
+            snapshot.workspaces[0].tabs[first_tab].focused,
             Some(second_pane.raw())
         );
     }
@@ -701,23 +708,30 @@ mod tests {
     #[test]
     fn clicking_all_workspaces_agent_row_switches_to_correct_workspace() {
         let mut app = app_for_mouse_test();
-        let mut first = Workspace::test_new("one");
+        let first = Workspace::test_new("one");
         let first_pane = first.tabs[0].root_pane;
-        first.tabs[0]
-            .panes
-            .get_mut(&first_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Pi);
 
-        let mut second = Workspace::test_new("two");
+        let second = Workspace::test_new("two");
         let second_pane = second.tabs[0].root_pane;
-        second.tabs[0]
-            .panes
-            .get_mut(&second_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Claude);
 
         app.state.workspaces = vec![first, second];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Pi);
+        let second_terminal_id = app.state.workspaces[1].tabs[0].panes[&second_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Claude);
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -747,12 +761,8 @@ mod tests {
         let mut app = app_for_mouse_test();
         let mut ws = Workspace::test_new("test");
         let first_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .panes
-            .get_mut(&first_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Pi);
 
+        let mut tabs = Vec::new();
         for (tab_name, agent) in [
             ("logs", Agent::Claude),
             ("review", Agent::Codex),
@@ -760,14 +770,29 @@ mod tests {
         ] {
             let tab_idx = ws.test_add_tab(Some(tab_name));
             let pane_id = ws.tabs[tab_idx].root_pane;
-            ws.tabs[tab_idx]
-                .panes
-                .get_mut(&pane_id)
-                .unwrap()
-                .detected_agent = Some(agent);
+            tabs.push((tab_idx, pane_id, agent));
         }
 
         app.state.workspaces = vec![ws];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Pi);
+        for (tab_idx, pane_id, agent) in tabs {
+            let terminal_id = app.state.workspaces[0].tabs[tab_idx].panes[&pane_id]
+                .attached_terminal_id
+                .clone();
+            app.state
+                .terminals
+                .get_mut(&terminal_id)
+                .unwrap()
+                .detected_agent = Some(agent);
+        }
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -792,31 +817,43 @@ mod tests {
         let mut app = app_for_mouse_test();
         let mut ws = Workspace::test_new("test");
         let first_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .panes
-            .get_mut(&first_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Pi);
-
         let second_tab = ws.test_add_tab(Some("logs"));
         let second_pane = ws.tabs[second_tab].root_pane;
-        ws.tabs[second_tab]
-            .panes
-            .get_mut(&second_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Claude);
-
+        let mut extra_tabs = Vec::new();
         for (tab_name, agent) in [("review", Agent::Codex), ("ops", Agent::Gemini)] {
             let tab_idx = ws.test_add_tab(Some(tab_name));
             let pane_id = ws.tabs[tab_idx].root_pane;
-            ws.tabs[tab_idx]
-                .panes
-                .get_mut(&pane_id)
-                .unwrap()
-                .detected_agent = Some(agent);
+            extra_tabs.push((tab_idx, pane_id, agent));
         }
 
         app.state.workspaces = vec![ws];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Pi);
+        let second_terminal_id = app.state.workspaces[0].tabs[second_tab].panes[&second_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Claude);
+        for (tab_idx, pane_id, agent) in extra_tabs {
+            let terminal_id = app.state.workspaces[0].tabs[tab_idx].panes[&pane_id]
+                .attached_terminal_id
+                .clone();
+            app.state
+                .terminals
+                .get_mut(&terminal_id)
+                .unwrap()
+                .detected_agent = Some(agent);
+        }
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -843,19 +880,26 @@ mod tests {
         let mut app = app_for_mouse_test();
         let mut ws = Workspace::test_new("test");
         let first_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .panes
-            .get_mut(&first_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Pi);
         let second_tab = ws.test_add_tab(Some("logs"));
         let second_pane = ws.tabs[second_tab].root_pane;
-        ws.tabs[second_tab]
-            .panes
-            .get_mut(&second_pane)
+        app.state.workspaces = vec![ws];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Pi);
+        let second_terminal_id = app.state.workspaces[0].tabs[second_tab].panes[&second_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
             .unwrap()
             .detected_agent = Some(Agent::Claude);
-        app.state.workspaces = vec![ws];
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -1128,20 +1172,27 @@ mod tests {
         let mut first = Workspace::test_new("a");
         let first_root = first.tabs[0].root_pane;
         first.identity_cwd = first_repo.clone();
-        first.tabs[0]
-            .pane_cwds
-            .insert(first_root, first_repo.clone());
         first.refresh_git_ahead_behind();
 
         let mut second = Workspace::test_new("b");
         let second_root = second.tabs[0].root_pane;
         second.identity_cwd = second_repo.clone();
-        second.tabs[0]
-            .pane_cwds
-            .insert(second_root, second_repo.clone());
         second.refresh_git_ahead_behind();
 
         app.state.workspaces = vec![first, second];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0].tabs[0].panes[&first_root]
+            .attached_terminal_id
+            .clone();
+        app.state.terminals.get_mut(&first_terminal_id).unwrap().cwd = first_repo.clone();
+        let second_terminal_id = app.state.workspaces[1].tabs[0].panes[&second_root]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
+            .unwrap()
+            .cwd = second_repo.clone();
         crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20));
 
         assert_eq!(app.state.workspace_drop_index_at_row(0), Some(0));
diff --git a/src/app/input/terminal.rs b/src/app/input/terminal.rs
index 22cf3169..3f0bff2c 100644
--- a/src/app/input/terminal.rs
+++ b/src/app/input/terminal.rs
@@ -64,7 +64,7 @@ impl App {
         let ws_idx = self.state.active?;
         let ws = self.state.workspaces.get(ws_idx)?;
         let pane_id = ws.focused_pane_id()?;
-        let rt = ws.runtimes.get(&pane_id)?;
+        let rt = self.state.runtime_for_pane_in_workspace(ws_idx, pane_id)?;
 
         // Intercept plain PageUp/PageDown presses for pane scrollback when the
         // focused pane doesn't handle its own scrolling (e.g., a plain shell
@@ -179,9 +179,9 @@ mod tests {
         let pane_id = ws.tabs[0].root_pane;
         let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18));
         let info = pane_infos[0].clone();
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_scrollback_bytes(
+            crate::terminal::TerminalRuntime::test_with_scrollback_bytes(
                 info.inner_rect.width,
                 info.inner_rect.height,
                 16 * 1024,
@@ -195,9 +195,10 @@ mod tests {
         app.state.mode = Mode::Terminal;
         app.state.view.pane_infos = pane_infos;
 
-        let start_metrics = app.state.workspaces[0]
-            .runtime(pane_id)
-            .and_then(crate::pane::PaneRuntime::scroll_metrics)
+        let start_metrics = app
+            .state
+            .runtime_for_pane(pane_id)
+            .and_then(crate::terminal::TerminalRuntime::scroll_metrics)
             .expect("initial scroll metrics");
         let start_row = info.inner_rect.y;
         let start_col = info.inner_rect.x + 2;
@@ -213,9 +214,10 @@ mod tests {
             info.inner_rect.y.saturating_sub(1),
         ));
 
-        let end_metrics = app.state.workspaces[0]
-            .runtime(pane_id)
-            .and_then(crate::pane::PaneRuntime::scroll_metrics)
+        let end_metrics = app
+            .state
+            .runtime_for_pane(pane_id)
+            .and_then(crate::terminal::TerminalRuntime::scroll_metrics)
             .expect("scroll metrics after drag");
         assert_eq!(
             end_metrics.offset_from_bottom,
@@ -243,9 +245,9 @@ mod tests {
         let pane_id = ws.tabs[0].root_pane;
         let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18));
         let info = pane_infos[0].clone();
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_scrollback_bytes(
+            crate::terminal::TerminalRuntime::test_with_scrollback_bytes(
                 info.inner_rect.width,
                 info.inner_rect.height,
                 16 * 1024,
@@ -283,9 +285,9 @@ mod tests {
         let pane_id = ws.tabs[0].root_pane;
         let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18));
         let info = pane_infos[0].clone();
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_scrollback_bytes(
+            crate::terminal::TerminalRuntime::test_with_scrollback_bytes(
                 info.inner_rect.width,
                 info.inner_rect.height,
                 16 * 1024,
@@ -299,9 +301,10 @@ mod tests {
         app.state.mode = Mode::Terminal;
         app.state.view.pane_infos = pane_infos;
 
-        let start_metrics = app.state.workspaces[0]
-            .runtime(pane_id)
-            .and_then(crate::pane::PaneRuntime::scroll_metrics)
+        let start_metrics = app
+            .state
+            .runtime_for_pane(pane_id)
+            .and_then(crate::terminal::TerminalRuntime::scroll_metrics)
             .expect("initial scroll metrics");
         let top_row = info.inner_rect.y;
         let col = info.inner_rect.x + 2;
@@ -309,9 +312,10 @@ mod tests {
         app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), col, top_row));
         app.handle_mouse(mouse(MouseEventKind::ScrollUp, col, top_row));
 
-        let end_metrics = app.state.workspaces[0]
-            .runtime(pane_id)
-            .and_then(crate::pane::PaneRuntime::scroll_metrics)
+        let end_metrics = app
+            .state
+            .runtime_for_pane(pane_id)
+            .and_then(crate::terminal::TerminalRuntime::scroll_metrics)
             .expect("scroll metrics after wheel");
         assert_eq!(
             end_metrics.offset_from_bottom,
@@ -352,17 +356,17 @@ mod tests {
             .unwrap()
             .clone();
 
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             first_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 first_info.inner_rect.width.max(1),
                 first_info.inner_rect.height.max(1),
                 b"",
             ),
         );
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             second_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 second_info.inner_rect.width.max(1),
                 second_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
@@ -410,17 +414,17 @@ mod tests {
             .unwrap()
             .clone();
 
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             first_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 first_info.inner_rect.width.max(1),
                 first_info.inner_rect.height.max(1),
                 b"",
             ),
         );
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             second_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(
                 second_info.inner_rect.width.max(1),
                 second_info.inner_rect.height.max(1),
                 b"\x1b[?1002h",
diff --git a/src/app/mod.rs b/src/app/mod.rs
index d37bcb5d..b1fb9775 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -207,6 +207,8 @@ impl App {
         let render_dirty = Arc::new(AtomicBool::new(false));
 
         // Try to restore previous session
+        let mut restored_terminals = std::collections::HashMap::new();
+        let mut restored_terminal_runtimes = std::collections::HashMap::new();
         let (
             workspaces,
             active,
@@ -226,7 +228,7 @@ impl App {
                 0.5_f32,
             )
         } else if let Some(snap) = crate::persist::load() {
-            let ws = crate::persist::restore(
+            let (ws, terminals, terminal_runtimes) = crate::persist::restore(
                 &snap,
                 24,
                 80,
@@ -235,6 +237,8 @@ impl App {
                 render_notify.clone(),
                 render_dirty.clone(),
             );
+            restored_terminals = terminals;
+            restored_terminal_runtimes = terminal_runtimes;
             if ws.is_empty() {
                 crate::logging::session_restored(0, "empty");
                 (
@@ -306,6 +310,8 @@ impl App {
         };
 
         let mut state = AppState {
+            terminals: std::collections::HashMap::new(),
+            terminal_runtimes: std::collections::HashMap::new(),
             workspaces,
             active,
             selected,
@@ -402,6 +408,9 @@ impl App {
             session_dirty: false,
         };
 
+        state.terminals = restored_terminals;
+        state.terminal_runtimes = restored_terminal_runtimes;
+
         for ws in &mut state.workspaces {
             ws.refresh_git_branch();
         }
@@ -857,7 +866,9 @@ impl App {
                         if let Some(ws_idx) = self.state.active {
                             if let Some(ws) = self.state.workspaces.get(ws_idx) {
                                 if let Some(focused) = ws.focused_pane_id() {
-                                    if let Some(runtime) = ws.runtimes.get(&focused) {
+                                    if let Some(runtime) =
+                                        self.state.runtime_for_pane_in_workspace(ws_idx, focused)
+                                    {
                                         let _ = runtime.try_send_bytes(bytes::Bytes::from(
                                             if runtime
                                                 .input_state()
@@ -945,7 +956,7 @@ mod tests {
     use super::*;
     use crate::config::Config;
     use crate::detect::{Agent, AgentState};
-    use crate::pane::PaneRuntime;
+    use crate::terminal::TerminalRuntime;
     use crate::workspace::Workspace;
     use crossterm::event::{KeyCode, KeyEventKind, KeyModifiers};
     use std::sync::{Mutex, OnceLock};
@@ -1369,22 +1380,44 @@ mod tests {
         let background_tab = workspace.test_add_tab(Some("background"));
         let background_pane = workspace.tabs[background_tab].root_pane;
 
-        workspace.tabs[0].panes.get_mut(&root_pane).unwrap().state = AgentState::Idle;
-        workspace.tabs[0].panes.get_mut(&root_pane).unwrap().seen = false;
-        workspace.tabs[0].panes.get_mut(&split_pane).unwrap().state = AgentState::Idle;
-        workspace.tabs[0].panes.get_mut(&split_pane).unwrap().seen = false;
-        workspace.tabs[background_tab]
+        app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
+        let root_terminal_id = app.state.workspaces[0].tabs[0].panes[&root_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&root_terminal_id)
+            .unwrap()
+            .state = AgentState::Idle;
+        app.state.workspaces[0].tabs[0]
             .panes
-            .get_mut(&background_pane)
+            .get_mut(&root_pane)
+            .unwrap()
+            .seen = false;
+        let split_terminal_id = app.state.workspaces[0].tabs[0].panes[&split_pane]
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&split_terminal_id)
             .unwrap()
             .state = AgentState::Idle;
-        workspace.tabs[background_tab]
+        app.state.workspaces[0].tabs[0]
+            .panes
+            .get_mut(&split_pane)
+            .unwrap()
+            .seen = false;
+        let bg_terminal_id = app.state.workspaces[0].tabs[background_tab].panes[&background_pane]
+            .attached_terminal_id
+            .clone();
+        app.state.terminals.get_mut(&bg_terminal_id).unwrap().state = AgentState::Idle;
+        app.state.workspaces[0].tabs[background_tab]
             .panes
             .get_mut(&background_pane)
             .unwrap()
             .seen = false;
 
-        app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
@@ -1498,6 +1531,7 @@ mod tests {
     fn workspace_create_response_includes_initial_tab_and_root_pane() {
         let mut app = test_app();
         app.state.workspaces = vec![Workspace::test_new("api-root-pane")];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1524,6 +1558,7 @@ mod tests {
         let mut workspace = Workspace::test_new("api-tab-root-pane");
         workspace.test_add_tab(None);
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1542,15 +1577,9 @@ mod tests {
     fn workspace_creation_in_navigate_mode_uses_selected_workspace_seed_cwd() {
         let mut app = test_app();
         let mut first = Workspace::test_new("herdr");
-        let first_root = first.tabs[0].root_pane;
-        first.tabs[0]
-            .pane_cwds
-            .insert(first_root, std::path::PathBuf::from("/tmp/herdr"));
+        first.identity_cwd = std::path::PathBuf::from("/tmp/herdr");
         let mut second = Workspace::test_new("pion");
-        let second_root = second.tabs[0].root_pane;
-        second.tabs[0]
-            .pane_cwds
-            .insert(second_root, std::path::PathBuf::from("/tmp/pion"));
+        second.identity_cwd = std::path::PathBuf::from("/tmp/pion");
 
         app.state.workspaces = vec![first, second];
         app.state.active = Some(0);
@@ -1586,6 +1615,7 @@ mod tests {
         let workspace = Workspace::test_new("api-pane-rename");
         let pane = workspace.tabs[0].root_pane;
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1601,9 +1631,15 @@ mod tests {
 
         assert_eq!(response["result"]["type"], "pane_info");
         assert_eq!(response["result"]["pane"]["label"], "reviewer");
+        let terminal_id = app.state.workspaces[0]
+            .pane_state(pane)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
         assert_eq!(
-            app.state.workspaces[0]
-                .pane_state(pane)
+            app.state
+                .terminals
+                .get(&terminal_id)
                 .unwrap()
                 .manual_label
                 .as_deref(),
@@ -1621,8 +1657,10 @@ mod tests {
 
         assert_eq!(response["result"]["type"], "pane_info");
         assert!(response["result"]["pane"].get("label").is_none());
-        assert!(app.state.workspaces[0]
-            .pane_state(pane)
+        assert!(app
+            .state
+            .terminals
+            .get(&terminal_id)
             .unwrap()
             .manual_label
             .is_none());
@@ -1665,11 +1703,21 @@ mod tests {
     #[test]
     fn terminal_target_resolves_unique_manual_name() {
         let mut app = test_app();
-        let mut workspace = Workspace::test_new("terminal-target-name");
+        let workspace = Workspace::test_new("terminal-target-name");
         let pane = workspace.tabs[0].root_pane;
-        workspace.pane_state_mut(pane).unwrap().manual_label = Some("reviewer".into());
         let terminal_id = workspace.terminal_id(pane).unwrap().to_string();
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
+        let attached_terminal_id = app.state.workspaces[0]
+            .pane_state(pane)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&attached_terminal_id)
+            .unwrap()
+            .manual_label = Some("reviewer".into());
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1702,9 +1750,28 @@ mod tests {
         let mut workspace = Workspace::test_new("terminal-target-ambiguous");
         let first = workspace.tabs[0].root_pane;
         let second = workspace.test_split(ratatui::layout::Direction::Horizontal);
-        workspace.pane_state_mut(first).unwrap().manual_label = Some("worker".into());
-        workspace.pane_state_mut(second).unwrap().manual_label = Some("worker".into());
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
+        let first_terminal_id = app.state.workspaces[0]
+            .pane_state(first)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .manual_label = Some("worker".into());
+        let second_terminal_id = app.state.workspaces[0]
+            .pane_state(second)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&second_terminal_id)
+            .unwrap()
+            .manual_label = Some("worker".into());
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1741,6 +1808,18 @@ mod tests {
             workspace.test_split(ratatui::layout::Direction::Horizontal);
         workspace.switch_tab(0);
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
+        let split_cwd = std::env::temp_dir();
+        let target_terminal_id = app.state.workspaces[0]
+            .pane_state(target_pane)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        app.state
+            .terminals
+            .get_mut(&target_terminal_id)
+            .unwrap()
+            .cwd = split_cwd.clone();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1761,6 +1840,10 @@ mod tests {
 
         assert_eq!(response["result"]["type"], "pane_info");
         assert_eq!(response["result"]["pane"]["tab_id"], target_tab_id);
+        assert_eq!(
+            response["result"]["pane"]["cwd"],
+            split_cwd.display().to_string()
+        );
         assert_eq!(response["result"]["pane"]["focused"], false);
         assert_eq!(app.state.active, Some(0));
         assert_eq!(app.state.workspaces[0].active_tab, 0);
@@ -1782,13 +1865,9 @@ mod tests {
             3
         );
 
-        let runtimes: Vec<_> = app.state.workspaces[0]
-            .tabs
-            .iter_mut()
-            .flat_map(|tab| tab.runtimes.drain())
-            .collect();
-        for (pane_id, runtime) in runtimes {
-            runtime.shutdown(pane_id);
+        let runtimes: Vec<_> = app.state.terminal_runtimes.drain().collect();
+        for (_terminal_id, runtime) in runtimes {
+            runtime.shutdown();
         }
         match original_shell {
             Some(value) => std::env::set_var("SHELL", value),
@@ -1807,6 +1886,7 @@ mod tests {
         let background_tab = workspace.test_add_tab(Some("worker"));
         workspace.switch_tab(0);
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1832,13 +1912,9 @@ mod tests {
         assert_eq!(app.state.active, Some(0));
         assert_eq!(app.state.workspaces[0].active_tab, background_tab);
 
-        let runtimes: Vec<_> = app.state.workspaces[0]
-            .tabs
-            .iter_mut()
-            .flat_map(|tab| tab.runtimes.drain())
-            .collect();
-        for (pane_id, runtime) in runtimes {
-            runtime.shutdown(pane_id);
+        let runtimes: Vec<_> = app.state.terminal_runtimes.drain().collect();
+        for (_terminal_id, runtime) in runtimes {
+            runtime.shutdown();
         }
         match original_shell {
             Some(value) => std::env::set_var("SHELL", value),
@@ -1853,6 +1929,7 @@ mod tests {
         let second_tab = workspace.test_add_tab(Some("logs"));
         workspace.switch_tab(second_tab);
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1878,6 +1955,7 @@ mod tests {
         let mut app = test_app();
         let workspace = Workspace::test_new("api-pane-close-last");
         app.state.workspaces = vec![workspace];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
 
@@ -1968,17 +2046,23 @@ mod tests {
         let pane_id = ws.tabs[0].root_pane;
 
         app.state.workspaces = vec![ws];
+        app.state.ensure_test_terminals();
         app.state.active = Some(0);
         app.state.selected = 0;
         app.state.mode = Mode::Terminal;
 
+        let terminal_id = app.state.workspaces[0]
+            .pane_state(pane_id)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
         app.handle_internal_event(AppEvent::StateChanged {
             pane_id,
             agent: Some(Agent::Pi),
             state: AgentState::Working,
         });
         assert_eq!(
-            app.state.workspaces[0].pane_state(pane_id).unwrap().state,
+            app.state.terminals.get(&terminal_id).unwrap().state,
             AgentState::Working
         );
 
@@ -2016,7 +2100,7 @@ mod tests {
         app.drain_internal_events();
 
         assert_eq!(
-            app.state.workspaces[0].pane_state(pane_id).unwrap().state,
+            app.state.terminals.get(&terminal_id).unwrap().state,
             AgentState::Idle,
             "Working→Idle should still apply after temporary queue pressure"
         );
@@ -2116,7 +2200,7 @@ mod tests {
         let mut app = test_app();
         let mut workspace = Workspace::test_new("test");
         let focused = workspace.focused_pane_id().unwrap();
-        let (runtime, mut rx) = PaneRuntime::test_with_channel(80, 24);
+        let (runtime, mut rx) = TerminalRuntime::test_with_channel(80, 24);
         workspace.tabs[0].runtimes.insert(focused, runtime);
         app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
@@ -2138,7 +2222,7 @@ mod tests {
         let mut app = test_app();
         let mut workspace = Workspace::test_new("test");
         let focused = workspace.focused_pane_id().unwrap();
-        let (runtime, mut rx) = PaneRuntime::test_with_channel(80, 24);
+        let (runtime, mut rx) = TerminalRuntime::test_with_channel(80, 24);
         workspace.tabs[0].runtimes.insert(focused, runtime);
         app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
@@ -2157,7 +2241,7 @@ mod tests {
         let mut app = test_app();
         let mut workspace = Workspace::test_new("test");
         let focused = workspace.focused_pane_id().unwrap();
-        let (runtime, mut rx) = PaneRuntime::test_with_channel(80, 24);
+        let (runtime, mut rx) = TerminalRuntime::test_with_channel(80, 24);
         workspace.tabs[0].runtimes.insert(focused, runtime);
         app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
@@ -2178,7 +2262,7 @@ mod tests {
         let focused = workspace.focused_pane_id().unwrap();
         let text = "中日한🙂";
         let (runtime, mut rx) =
-            PaneRuntime::test_with_channel_capacity(80, 24, text.chars().count());
+            TerminalRuntime::test_with_channel_capacity(80, 24, text.chars().count());
         workspace.tabs[0].runtimes.insert(focused, runtime);
         app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
@@ -2203,7 +2287,7 @@ mod tests {
         let focused = workspace.focused_pane_id().unwrap();
         let text = "你好，今天我们测试一段比较长的语音输入。こんにちは。안녕하세요.🙂".repeat(64);
         let char_count = text.chars().count();
-        let (runtime, mut rx) = PaneRuntime::test_with_channel_capacity(80, 24, char_count);
+        let (runtime, mut rx) = TerminalRuntime::test_with_channel_capacity(80, 24, char_count);
         workspace.tabs[0].runtimes.insert(focused, runtime);
         app.state.workspaces = vec![workspace];
         app.state.active = Some(0);
diff --git a/src/app/runtime.rs b/src/app/runtime.rs
index 4d2f6c47..98ae4e0e 100644
--- a/src/app/runtime.rs
+++ b/src/app/runtime.rs
@@ -198,12 +198,12 @@ impl App {
                 .state
                 .active
                 .and_then(|idx| self.state.workspaces.get(idx))
-                .is_some_and(Workspace::has_working_pane),
+                .is_some_and(|ws| ws.has_working_pane(&self.state.terminals)),
             crate::app::state::AgentPanelScope::AllWorkspaces => self
                 .state
                 .workspaces
                 .iter()
-                .any(Workspace::has_working_pane),
+                .any(|ws| ws.has_working_pane(&self.state.terminals)),
         }
     }
 
diff --git a/src/app/session.rs b/src/app/session.rs
index c075fd4c..85bdd1bb 100644
--- a/src/app/session.rs
+++ b/src/app/session.rs
@@ -27,6 +27,8 @@ impl App {
         } else {
             let snap = crate::persist::capture(
                 &self.state.workspaces,
+                &self.state.terminals,
+                &self.state.terminal_runtimes,
                 self.state.active,
                 self.state.selected,
                 self.state.agent_panel_scope,
diff --git a/src/app/state.rs b/src/app/state.rs
index 45473435..daed47f0 100644
--- a/src/app/state.rs
+++ b/src/app/state.rs
@@ -818,6 +818,10 @@ pub enum SidebarWidthSource {
 /// All application state — pure data, no channels or async runtime.
 /// Testable without PTYs or a tokio runtime.
 pub struct AppState {
+    pub terminals:
+        std::collections::HashMap<crate::terminal::TerminalId, crate::terminal::TerminalState>,
+    pub terminal_runtimes:
+        std::collections::HashMap<crate::terminal::TerminalId, crate::terminal::TerminalRuntime>,
     pub workspaces: Vec<Workspace>,
     pub active: Option<usize>,
     pub selected: usize,
@@ -953,6 +957,57 @@ impl AppState {
 
     /// Returns true when the given (workspace, tab, pane) refers to the
     /// currently focused pane in the active workspace's active tab.
+    pub(crate) fn runtime_for_pane_in_workspace(
+        &self,
+        ws_idx: usize,
+        pane_id: crate::layout::PaneId,
+    ) -> Option<&crate::terminal::TerminalRuntime> {
+        #[cfg(test)]
+        if let Some(runtime) = self.workspaces.get(ws_idx)?.test_runtimes.get(&pane_id) {
+            return Some(runtime);
+        }
+        #[cfg(test)]
+        if let Some(runtime) = self
+            .workspaces
+            .get(ws_idx)?
+            .tabs
+            .iter()
+            .find_map(|tab| tab.runtimes.get(&pane_id))
+        {
+            return Some(runtime);
+        }
+        let terminal_id = self.workspaces.get(ws_idx)?.terminal_id(pane_id)?;
+        self.terminal_runtimes.get(terminal_id)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn runtime_for_pane(
+        &self,
+        pane_id: crate::layout::PaneId,
+    ) -> Option<&crate::terminal::TerminalRuntime> {
+        self.workspaces.iter().find_map(|ws| {
+            #[cfg(test)]
+            if let Some(runtime) = ws.test_runtimes.get(&pane_id) {
+                return Some(runtime);
+            }
+            #[cfg(test)]
+            if let Some(runtime) = ws.tabs.iter().find_map(|tab| tab.runtimes.get(&pane_id)) {
+                return Some(runtime);
+            }
+            let terminal_id = ws.terminal_id(pane_id)?;
+            self.terminal_runtimes.get(terminal_id)
+        })
+    }
+
+    pub(crate) fn focused_runtime_in_workspace(
+        &self,
+        ws_idx: usize,
+    ) -> Option<&crate::terminal::TerminalRuntime> {
+        let ws = self.workspaces.get(ws_idx)?;
+        let pane_id = ws.focused_pane_id()?;
+        self.runtime_for_pane_in_workspace(ws_idx, pane_id)
+    }
+
     pub fn is_active_pane(
         &self,
         ws_idx: usize,
@@ -1003,6 +1058,8 @@ impl AppState {
     /// Create an AppState for testing — no channels, no PTYs.
     pub fn test_new() -> Self {
         Self {
+            terminals: std::collections::HashMap::new(),
+            terminal_runtimes: std::collections::HashMap::new(),
             workspaces: Vec::new(),
             active: None,
             selected: 0,
@@ -1155,6 +1212,40 @@ impl AppState {
             session_dirty: false,
         }
     }
+
+    /// Populate missing `TerminalState` entries for every pane so tests that
+    /// read or write terminal metadata don't need to manually create them.
+    pub fn ensure_test_terminals(&mut self) {
+        use crate::terminal::TerminalState;
+        for ws in &self.workspaces {
+            for tab in &ws.tabs {
+                for pane in tab.panes.values() {
+                    if !self.terminals.contains_key(&pane.attached_terminal_id) {
+                        let cwd = ws.identity_cwd.clone();
+                        self.terminals.insert(
+                            pane.attached_terminal_id.clone(),
+                            TerminalState::new(pane.attached_terminal_id.clone(), cwd),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn insert_test_runtime(
+        &mut self,
+        pane_id: crate::layout::PaneId,
+        runtime: crate::terminal::TerminalRuntime,
+    ) {
+        let Some(terminal_id) = self
+            .workspaces
+            .iter()
+            .find_map(|ws| ws.terminal_id(pane_id).cloned())
+        else {
+            return;
+        };
+        self.terminal_runtimes.insert(terminal_id, runtime);
+    }
 }
 
 #[cfg(test)]
diff --git a/src/app/terminal_targets.rs b/src/app/terminal_targets.rs
index cf90717d..94cf89d0 100644
--- a/src/app/terminal_targets.rs
+++ b/src/app/terminal_targets.rs
@@ -61,9 +61,11 @@ impl App {
             .terminal_targets()
             .into_iter()
             .filter(|candidate| {
-                self.state.workspaces[candidate.ws_idx]
-                    .pane_state(candidate.pane_id)
-                    .and_then(|pane| pane.manual_label.as_deref())
+                self.state
+                    .terminals
+                    .values()
+                    .find(|terminal| terminal.id.to_string() == candidate.terminal_id)
+                    .and_then(|terminal| terminal.manual_label.as_deref())
                     .is_some_and(|label| label == target)
             })
             .collect();
@@ -151,15 +153,20 @@ impl App {
         let ws = self.state.workspaces.get(ws_idx)?;
         let tab_idx = ws.find_tab_index_for_pane(pane_id)?;
         let pane = ws.pane_state(pane_id)?;
+        let terminal = self.state.terminals.get(&pane.attached_terminal_id)?;
         Some(TerminalTargetCandidate {
-            terminal_id: ws.terminal_id(pane_id)?.to_string(),
+            terminal_id: terminal.id.to_string(),
             pane_id: self.public_pane_id(ws_idx, pane_id)?,
             workspace_id: self.public_workspace_id(ws_idx),
             tab_id: self.public_tab_id(ws_idx, tab_idx)?,
             cwd: ws.tabs[tab_idx]
-                .cwd_for_pane(pane_id)
+                .cwd_for_pane(
+                    pane_id,
+                    &self.state.terminals,
+                    &self.state.terminal_runtimes,
+                )
                 .map(|cwd| cwd.display().to_string()),
-            agent_status: pane_agent_status(pane.state, pane.seen),
+            agent_status: pane_agent_status(terminal.state, pane.seen),
         })
     }
 }
diff --git a/src/app/theme_sync.rs b/src/app/theme_sync.rs
index df47f6a3..802725f0 100644
--- a/src/app/theme_sync.rs
+++ b/src/app/theme_sync.rs
@@ -37,12 +37,8 @@ impl App {
             return;
         }
 
-        for workspace in &self.state.workspaces {
-            for tab in &workspace.tabs {
-                for runtime in tab.runtimes.values() {
-                    runtime.apply_host_terminal_theme(self.state.host_terminal_theme);
-                }
-            }
+        for runtime in self.state.terminal_runtimes.values() {
+            runtime.apply_host_terminal_theme(self.state.host_terminal_theme);
         }
 
         self.render_dirty.store(true, Ordering::Release);
diff --git a/src/pane.rs b/src/pane.rs
index b5886933..592255a5 100644
--- a/src/pane.rs
+++ b/src/pane.rs
@@ -20,14 +20,12 @@ mod osc;
 mod state;
 mod terminal;
 
-use self::{
-    state::stabilize_agent_state,
-    terminal::{GhosttyPaneTerminal, PaneTerminal},
-};
+use self::terminal::{GhosttyPaneTerminal, PaneTerminal};
 pub use self::{
-    state::{EffectiveStateChange, PaneState},
+    state::PaneState,
     terminal::{InputState, ScrollMetrics, TerminalCursorState},
 };
+use crate::terminal::stabilize_agent_state;
 
 const RELEASE_REACQUIRE_SUPPRESSION: std::time::Duration = std::time::Duration::from_secs(1);
 const PANE_TERM: &str = "xterm-256color";
@@ -160,6 +158,7 @@ impl AgentDetectionPresence {
 /// PTY runtime for a pane. Owns the terminal, I/O channels, and background tasks.
 /// Dropping this shuts down all background tasks and closes the PTY.
 pub struct PaneRuntime {
+    pane_id: PaneId,
     terminal: Arc<PaneTerminal>,
     sender: mpsc::Sender<Bytes>,
     resize_tx: watch::Sender<(u16, u16, u32, u32)>,
@@ -181,10 +180,11 @@ pub enum WheelRouting {
 
 impl Drop for PaneRuntime {
     fn drop(&mut self) {
-        // Abort detection task immediately.
+        // Abort detection task immediately and terminate the owned session.
         // Reader/writer/resize tasks shut down naturally via channel close
         // and PTY EOF when the rest of PaneRuntime is dropped.
         self.detect_handle.abort();
+        shutdown_pane_processes(self.pane_id, self.child_pid.load(Ordering::Acquire));
     }
 }
 
@@ -251,9 +251,9 @@ fn shutdown_pane_processes(pane_id: PaneId, child_pid: u32) {
 }
 
 impl PaneRuntime {
-    pub fn shutdown(self, pane_id: PaneId) {
+    pub fn shutdown(self) {
         self.detect_handle.abort();
-        shutdown_pane_processes(pane_id, self.child_pid.load(Ordering::Acquire));
+        shutdown_pane_processes(self.pane_id, self.child_pid.load(Ordering::Acquire));
     }
 
     pub fn apply_host_terminal_theme(&self, theme: crate::terminal_theme::TerminalTheme) {
@@ -748,6 +748,7 @@ impl PaneRuntime {
         }
 
         Ok(Self {
+            pane_id,
             terminal,
             sender: input_tx,
             resize_tx,
@@ -1039,6 +1040,7 @@ impl PaneRuntime {
 
         (
             Self {
+                pane_id: PaneId::from_raw(0),
                 terminal: Arc::new(PaneTerminal::new(
                     GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(),
                 )),
@@ -1121,6 +1123,7 @@ mod tests {
             .mode_set(crate::ghostty::MODE_FOCUS_EVENT, true)
             .unwrap();
         let runtime = PaneRuntime {
+            pane_id: PaneId::from_raw(0),
             terminal: Arc::new(PaneTerminal::new(
                 GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(),
             )),
@@ -1144,6 +1147,7 @@ mod tests {
         let (resize_tx, _resize_rx) = watch::channel((80, 24, 0, 0));
         let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap();
         let runtime = PaneRuntime {
+            pane_id: PaneId::from_raw(0),
             terminal: Arc::new(PaneTerminal::new(
                 GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(),
             )),
diff --git a/src/pane/state.rs b/src/pane/state.rs
index 2a2f789e..be7ebfae 100644
--- a/src/pane/state.rs
+++ b/src/pane/state.rs
@@ -1,606 +1,20 @@
-use std::collections::HashMap;
+use crate::terminal::TerminalId;
 
-use crate::detect::{Agent, AgentState};
-
-const CLAUDE_WORKING_HOLD: std::time::Duration = std::time::Duration::from_millis(1200);
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct HookAuthority {
-    pub source: String,
-    pub agent_label: String,
-    pub state: AgentState,
-    pub message: Option<String>,
-    pub custom_status: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct EffectiveStateChange {
-    pub previous_agent_label: Option<String>,
-    pub previous_known_agent: Option<Agent>,
-    pub previous_state: AgentState,
-    pub agent_label: Option<String>,
-    pub known_agent: Option<Agent>,
-    pub state: AgentState,
-}
-
-/// Observable state for a single pane.
-/// This is the only part of a pane that workspace logic and tests need.
+/// Viewport state for a pane.
+///
+/// Terminal identity, cwd, labels, and agent metadata live in TerminalState.
 pub struct PaneState {
-    pub detected_agent: Option<Agent>,
-    pub fallback_state: AgentState,
-    pub hook_authority: Option<HookAuthority>,
-    pub manual_label: Option<String>,
-    hook_report_sequences: HashMap<String, u64>,
-    pub state: AgentState,
+    pub attached_terminal_id: TerminalId,
     /// Whether the user has seen this pane since its last state change to Idle.
     /// False = "Done" (agent finished while user was in another workspace).
     pub seen: bool,
 }
 
 impl PaneState {
-    pub fn new() -> Self {
+    pub fn new(attached_terminal_id: TerminalId) -> Self {
         Self {
-            detected_agent: None,
-            fallback_state: AgentState::Unknown,
-            hook_authority: None,
-            manual_label: None,
-            hook_report_sequences: HashMap::new(),
-            state: AgentState::Unknown,
+            attached_terminal_id,
             seen: true,
         }
     }
-
-    pub fn set_detected_state(
-        &mut self,
-        agent: Option<Agent>,
-        fallback_state: AgentState,
-    ) -> Option<EffectiveStateChange> {
-        let previous_agent_label = self.effective_agent_label().map(str::to_string);
-        let previous_known_agent = self.effective_known_agent();
-        let previous_state = self.state;
-        let previous_detected_agent = self.detected_agent;
-        self.detected_agent = agent;
-        self.fallback_state = fallback_state;
-        if previous_detected_agent.is_some()
-            && agent != previous_detected_agent
-            && self.hook_authority.as_ref().is_some_and(|authority| {
-                crate::detect::parse_agent_label(&authority.agent_label) == previous_detected_agent
-            })
-        {
-            self.hook_authority = None;
-        }
-        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
-    }
-
-    #[cfg(test)]
-    pub fn set_hook_authority(
-        &mut self,
-        source: String,
-        agent_label: String,
-        state: AgentState,
-        message: Option<String>,
-        seq: Option<u64>,
-    ) -> Option<EffectiveStateChange> {
-        self.set_hook_authority_with_custom_status(source, agent_label, state, message, None, seq)
-    }
-
-    pub fn set_hook_authority_with_custom_status(
-        &mut self,
-        source: String,
-        agent_label: String,
-        state: AgentState,
-        message: Option<String>,
-        custom_status: Option<String>,
-        seq: Option<u64>,
-    ) -> Option<EffectiveStateChange> {
-        if !self.accept_hook_report(&source, seq) {
-            return None;
-        }
-
-        let previous_agent_label = self.effective_agent_label().map(str::to_string);
-        let previous_known_agent = self.effective_known_agent();
-        let previous_state = self.state;
-        self.hook_authority = Some(HookAuthority {
-            source,
-            agent_label,
-            state,
-            message,
-            custom_status,
-        });
-        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
-    }
-
-    fn accept_hook_report(&mut self, source: &str, seq: Option<u64>) -> bool {
-        let Some(seq) = seq else {
-            return !self.hook_report_sequences.contains_key(source);
-        };
-
-        if self
-            .hook_report_sequences
-            .get(source)
-            .is_some_and(|last_seq| seq <= *last_seq)
-        {
-            return false;
-        }
-
-        self.hook_report_sequences.insert(source.to_string(), seq);
-        true
-    }
-
-    pub fn clear_hook_authority(
-        &mut self,
-        source: Option<&str>,
-        seq: Option<u64>,
-    ) -> Option<EffectiveStateChange> {
-        let sequence_source = source.map(str::to_string).or_else(|| {
-            self.hook_authority
-                .as_ref()
-                .map(|authority| authority.source.clone())
-        });
-        if let Some(source) = sequence_source.as_deref() {
-            if !self.accept_hook_report(source, seq) {
-                return None;
-            }
-        }
-
-        let previous_agent_label = self.effective_agent_label().map(str::to_string);
-        let previous_known_agent = self.effective_known_agent();
-        let previous_state = self.state;
-        let should_clear = self
-            .hook_authority
-            .as_ref()
-            .is_some_and(|authority| source.is_none_or(|source| authority.source == source));
-        if !should_clear {
-            return None;
-        }
-        self.hook_authority = None;
-        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
-    }
-
-    pub fn release_agent(
-        &mut self,
-        source: &str,
-        agent_label: &str,
-        seq: Option<u64>,
-    ) -> Option<EffectiveStateChange> {
-        if !self.accept_hook_report(source, seq) {
-            return None;
-        }
-
-        let current_agent_label = self.effective_agent_label()?;
-        if current_agent_label != agent_label {
-            return None;
-        }
-
-        if self.hook_authority.as_ref().is_some_and(|authority| {
-            authority.agent_label != agent_label || authority.source != source
-        }) {
-            return None;
-        }
-
-        let previous_agent_label = self.effective_agent_label().map(str::to_string);
-        let previous_known_agent = self.effective_known_agent();
-        let previous_state = self.state;
-        self.detected_agent = None;
-        self.fallback_state = AgentState::Unknown;
-        self.hook_authority = None;
-        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
-    }
-
-    pub fn effective_agent_label(&self) -> Option<&str> {
-        self.hook_authority
-            .as_ref()
-            .map(|authority| authority.agent_label.as_str())
-            .or_else(|| self.detected_agent.map(crate::detect::agent_label))
-    }
-
-    pub fn effective_known_agent(&self) -> Option<Agent> {
-        if let Some(authority) = &self.hook_authority {
-            return crate::detect::parse_agent_label(&authority.agent_label);
-        }
-        self.detected_agent
-    }
-
-    pub fn effective_custom_status(&self) -> Option<&str> {
-        self.hook_authority
-            .as_ref()
-            .and_then(|authority| authority.custom_status.as_deref())
-    }
-
-    pub fn set_manual_label(&mut self, label: String) {
-        let label = label.trim().to_string();
-        self.manual_label = (!label.is_empty()).then_some(label);
-    }
-
-    pub fn clear_manual_label(&mut self) {
-        self.manual_label = None;
-    }
-
-    pub fn border_label(&self, show_agent_labels: bool) -> Option<&str> {
-        self.manual_label.as_deref().or_else(|| {
-            show_agent_labels
-                .then(|| self.effective_agent_label())
-                .flatten()
-        })
-    }
-
-    fn recompute_effective_state(
-        &mut self,
-        previous_agent_label: Option<String>,
-        previous_known_agent: Option<Agent>,
-        previous_state: AgentState,
-    ) -> Option<EffectiveStateChange> {
-        let state = self
-            .hook_authority
-            .as_ref()
-            .map(|authority| authority.state)
-            .unwrap_or(self.fallback_state);
-        let agent_label = self.effective_agent_label().map(str::to_string);
-        let known_agent = self.effective_known_agent();
-
-        if previous_agent_label == agent_label && previous_state == state {
-            return None;
-        }
-
-        self.state = state;
-        Some(EffectiveStateChange {
-            previous_agent_label,
-            previous_known_agent,
-            previous_state,
-            agent_label,
-            known_agent,
-            state,
-        })
-    }
-}
-
-pub(crate) fn stabilize_agent_state(
-    agent: Option<Agent>,
-    previous: AgentState,
-    raw: AgentState,
-    now: std::time::Instant,
-    last_claude_working_at: &mut Option<std::time::Instant>,
-) -> AgentState {
-    if agent != Some(Agent::Claude) {
-        return raw;
-    }
-
-    match raw {
-        AgentState::Working => {
-            *last_claude_working_at = Some(now);
-            AgentState::Working
-        }
-        AgentState::Blocked => AgentState::Blocked,
-        AgentState::Idle if previous == AgentState::Working => {
-            if last_claude_working_at
-                .is_some_and(|last_working| now.duration_since(last_working) < CLAUDE_WORKING_HOLD)
-            {
-                AgentState::Working
-            } else {
-                AgentState::Idle
-            }
-        }
-        _ => raw,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn claude_working_is_sticky_for_short_gap() {
-        let now = std::time::Instant::now();
-        let mut last_working = None;
-
-        let working = stabilize_agent_state(
-            Some(Agent::Claude),
-            AgentState::Idle,
-            AgentState::Working,
-            now,
-            &mut last_working,
-        );
-        assert_eq!(working, AgentState::Working);
-
-        let still_working = stabilize_agent_state(
-            Some(Agent::Claude),
-            AgentState::Working,
-            AgentState::Idle,
-            now + std::time::Duration::from_millis(400),
-            &mut last_working,
-        );
-        assert_eq!(still_working, AgentState::Working);
-    }
-
-    #[test]
-    fn claude_transitions_to_idle_after_hold_expires() {
-        let now = std::time::Instant::now();
-        let mut last_working = Some(now);
-
-        let state = stabilize_agent_state(
-            Some(Agent::Claude),
-            AgentState::Working,
-            AgentState::Idle,
-            now + CLAUDE_WORKING_HOLD + std::time::Duration::from_millis(1),
-            &mut last_working,
-        );
-        assert_eq!(state, AgentState::Idle);
-    }
-
-    #[test]
-    fn non_claude_states_are_unchanged() {
-        let now = std::time::Instant::now();
-        let mut last_working = None;
-
-        let state = stabilize_agent_state(
-            Some(Agent::Codex),
-            AgentState::Working,
-            AgentState::Idle,
-            now,
-            &mut last_working,
-        );
-        assert_eq!(state, AgentState::Idle);
-    }
-
-    #[test]
-    fn hook_authority_overrides_fallback_for_same_agent() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Pi), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            None,
-        );
-
-        assert_eq!(pane.detected_agent, Some(Agent::Pi));
-        assert_eq!(pane.fallback_state, AgentState::Idle);
-        assert_eq!(pane.effective_agent_label(), Some("pi"));
-        assert_eq!(pane.state, AgentState::Working);
-    }
-
-    #[test]
-    fn hook_authority_can_override_with_unknown_agent_label() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Pi), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:custom".into(),
-            "hermes".into(),
-            AgentState::Working,
-            None,
-            None,
-        );
-
-        assert_eq!(pane.detected_agent, Some(Agent::Pi));
-        assert_eq!(pane.effective_agent_label(), Some("hermes"));
-        assert_eq!(pane.effective_known_agent(), None);
-        assert_eq!(pane.state, AgentState::Working);
-    }
-
-    #[test]
-    fn border_label_prefers_manual_label_over_agent_label() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Claude), AgentState::Idle);
-
-        assert_eq!(pane.border_label(false), None);
-        assert_eq!(pane.border_label(true), Some("claude"));
-
-        pane.set_manual_label(" reviewer ".into());
-        assert_eq!(pane.border_label(false), Some("reviewer"));
-        assert_eq!(pane.border_label(true), Some("reviewer"));
-
-        pane.set_manual_label("   ".into());
-        assert_eq!(pane.border_label(true), Some("claude"));
-
-        pane.set_manual_label("reviewer".into());
-        pane.clear_manual_label();
-        assert_eq!(pane.border_label(true), Some("claude"));
-    }
-
-    #[test]
-    fn hook_authority_survives_unrelated_detected_agent_clear() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Pi), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:custom".into(),
-            "hermes".into(),
-            AgentState::Working,
-            None,
-            None,
-        );
-
-        pane.set_detected_state(None, AgentState::Unknown);
-
-        assert!(pane.hook_authority.is_some());
-        assert_eq!(pane.detected_agent, None);
-        assert_eq!(pane.effective_agent_label(), Some("hermes"));
-        assert_eq!(pane.state, AgentState::Working);
-    }
-
-    #[test]
-    fn detected_agent_clear_clears_matching_hook_authority() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::OpenCode), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:opencode".into(),
-            "opencode".into(),
-            AgentState::Idle,
-            None,
-            None,
-        );
-
-        pane.set_detected_state(None, AgentState::Unknown);
-
-        assert!(pane.hook_authority.is_none());
-        assert_eq!(pane.detected_agent, None);
-        assert_eq!(pane.fallback_state, AgentState::Unknown);
-        assert_eq!(pane.effective_agent_label(), None);
-        assert_eq!(pane.state, AgentState::Unknown);
-    }
-
-    #[test]
-    fn detected_agent_change_clears_previous_matching_hook_authority() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Codex), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:codex".into(),
-            "codex".into(),
-            AgentState::Idle,
-            None,
-            None,
-        );
-
-        pane.set_detected_state(Some(Agent::OpenCode), AgentState::Working);
-
-        assert!(pane.hook_authority.is_none());
-        assert_eq!(pane.detected_agent, Some(Agent::OpenCode));
-        assert_eq!(pane.effective_agent_label(), Some("opencode"));
-        assert_eq!(pane.state, AgentState::Working);
-    }
-
-    #[test]
-    fn release_agent_clears_identity_immediately() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Pi), AgentState::Idle);
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            None,
-        );
-
-        pane.release_agent("herdr:pi", "pi", None);
-
-        assert!(pane.hook_authority.is_none());
-        assert_eq!(pane.detected_agent, None);
-        assert_eq!(pane.fallback_state, AgentState::Unknown);
-        assert_eq!(pane.state, AgentState::Unknown);
-    }
-
-    #[test]
-    fn custom_status_is_hook_authority_metadata() {
-        let mut pane = PaneState::new();
-        pane.set_detected_state(Some(Agent::Claude), AgentState::Idle);
-        pane.set_hook_authority_with_custom_status(
-            "herdr:claude".into(),
-            "claude".into(),
-            AgentState::Idle,
-            None,
-            Some("scheduled".into()),
-            None,
-        );
-
-        assert_eq!(pane.state, AgentState::Idle);
-        assert_eq!(pane.effective_custom_status(), Some("scheduled"));
-
-        pane.clear_hook_authority(Some("herdr:claude"), None);
-
-        assert_eq!(pane.effective_custom_status(), None);
-    }
-
-    #[test]
-    fn stale_hook_report_sequence_is_ignored_for_same_source() {
-        let mut pane = PaneState::new();
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            Some(20),
-        );
-
-        let change = pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Idle,
-            None,
-            Some(19),
-        );
-
-        assert!(change.is_none());
-        assert_eq!(pane.state, AgentState::Working);
-        assert_eq!(
-            pane.hook_authority.as_ref().unwrap().state,
-            AgentState::Working
-        );
-    }
-
-    #[test]
-    fn unsequenced_hook_report_is_ignored_after_source_uses_sequence() {
-        let mut pane = PaneState::new();
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            Some(20),
-        );
-
-        let change =
-            pane.set_hook_authority("herdr:pi".into(), "pi".into(), AgentState::Idle, None, None);
-
-        assert!(change.is_none());
-        assert_eq!(pane.state, AgentState::Working);
-    }
-
-    #[test]
-    fn stale_release_sequence_is_ignored_for_same_source() {
-        let mut pane = PaneState::new();
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            Some(20),
-        );
-
-        let change = pane.release_agent("herdr:pi", "pi", Some(19));
-
-        assert!(change.is_none());
-        assert_eq!(pane.state, AgentState::Working);
-        assert!(pane.hook_authority.is_some());
-    }
-
-    #[test]
-    fn stale_clear_all_sequence_is_checked_against_current_authority_source() {
-        let mut pane = PaneState::new();
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            Some(20),
-        );
-
-        let change = pane.clear_hook_authority(None, Some(19));
-
-        assert!(change.is_none());
-        assert_eq!(pane.state, AgentState::Working);
-        assert!(pane.hook_authority.is_some());
-    }
-
-    #[test]
-    fn same_sequence_from_different_sources_is_independent() {
-        let mut pane = PaneState::new();
-        pane.set_hook_authority(
-            "herdr:pi".into(),
-            "pi".into(),
-            AgentState::Working,
-            None,
-            Some(20),
-        );
-
-        pane.set_hook_authority(
-            "custom:pi".into(),
-            "pi".into(),
-            AgentState::Idle,
-            None,
-            Some(19),
-        );
-
-        assert_eq!(pane.state, AgentState::Idle);
-        assert_eq!(pane.hook_authority.as_ref().unwrap().source, "custom:pi");
-    }
 }
diff --git a/src/persist/restore.rs b/src/persist/restore.rs
index 1e10df6d..e53a61d9 100644
--- a/src/persist/restore.rs
+++ b/src/persist/restore.rs
@@ -9,7 +9,8 @@ use tracing::{error, warn};
 
 use crate::events::AppEvent;
 use crate::layout::{Node, PaneId, TileLayout};
-use crate::pane::{PaneRuntime, PaneState};
+use crate::pane::PaneState;
+use crate::terminal::{TerminalId, TerminalRuntime, TerminalState};
 use crate::workspace::Workspace;
 
 use super::{DirectionSnapshot, LayoutSnapshot, SessionSnapshot, TabSnapshot, WorkspaceSnapshot};
@@ -23,22 +24,32 @@ pub fn restore(
     events: mpsc::Sender<AppEvent>,
     render_notify: Arc<Notify>,
     render_dirty: Arc<AtomicBool>,
-) -> Vec<Workspace> {
-    snapshot
-        .workspaces
-        .iter()
-        .filter_map(|ws_snap| {
-            restore_workspace(
-                ws_snap,
-                rows,
-                cols,
-                scrollback_limit_bytes,
-                events.clone(),
-                render_notify.clone(),
-                render_dirty.clone(),
-            )
-        })
-        .collect()
+) -> (
+    Vec<Workspace>,
+    HashMap<TerminalId, TerminalState>,
+    HashMap<TerminalId, TerminalRuntime>,
+) {
+    let mut workspaces = Vec::new();
+    let mut terminals = HashMap::new();
+    let mut terminal_runtimes = HashMap::new();
+    for ws_snap in &snapshot.workspaces {
+        if let Some((workspace, restored_terminals, restored_runtimes)) = restore_workspace(
+            ws_snap,
+            rows,
+            cols,
+            scrollback_limit_bytes,
+            events.clone(),
+            render_notify.clone(),
+            render_dirty.clone(),
+        ) {
+            for terminal in restored_terminals {
+                terminals.insert(terminal.id.clone(), terminal);
+            }
+            terminal_runtimes.extend(restored_runtimes);
+            workspaces.push(workspace);
+        }
+    }
+    (workspaces, terminals, terminal_runtimes)
 }
 
 fn restore_workspace(
@@ -49,13 +60,19 @@ fn restore_workspace(
     events: mpsc::Sender<AppEvent>,
     render_notify: Arc<Notify>,
     render_dirty: Arc<AtomicBool>,
-) -> Option<Workspace> {
+) -> Option<(
+    Workspace,
+    Vec<TerminalState>,
+    HashMap<TerminalId, TerminalRuntime>,
+)> {
     let mut tabs = Vec::new();
+    let mut terminals = Vec::new();
+    let mut terminal_runtimes = HashMap::new();
     let mut public_pane_numbers = HashMap::new();
     let mut next_public_pane_number = 1;
 
     for (idx, tab_snap) in snap.tabs.iter().enumerate() {
-        let tab = restore_tab(
+        let (tab, restored_terminals, restored_runtimes) = restore_tab(
             tab_snap,
             idx + 1,
             rows,
@@ -69,6 +86,8 @@ fn restore_workspace(
             public_pane_numbers.insert(pane_id, next_public_pane_number);
             next_public_pane_number += 1;
         }
+        terminals.extend(restored_terminals);
+        terminal_runtimes.extend(restored_runtimes);
         tabs.push(tab);
     }
 
@@ -76,20 +95,26 @@ fn restore_workspace(
         return None;
     }
 
-    Some(Workspace {
-        id: snap
-            .id
-            .clone()
-            .unwrap_or_else(crate::workspace::generate_workspace_id),
-        custom_name: snap.custom_name.clone(),
-        identity_cwd: snap.identity_cwd.clone(),
-        cached_git_branch: None,
-        cached_git_ahead_behind: None,
-        public_pane_numbers,
-        next_public_pane_number,
-        active_tab: snap.active_tab.min(tabs.len().saturating_sub(1)),
-        tabs,
-    })
+    Some((
+        Workspace {
+            id: snap
+                .id
+                .clone()
+                .unwrap_or_else(crate::workspace::generate_workspace_id),
+            custom_name: snap.custom_name.clone(),
+            identity_cwd: snap.identity_cwd.clone(),
+            cached_git_branch: None,
+            cached_git_ahead_behind: None,
+            public_pane_numbers,
+            next_public_pane_number,
+            active_tab: snap.active_tab.min(tabs.len().saturating_sub(1)),
+            tabs,
+            #[cfg(test)]
+            test_runtimes: HashMap::new(),
+        },
+        terminals,
+        terminal_runtimes,
+    ))
 }
 
 fn restore_tab(
@@ -101,7 +126,11 @@ fn restore_tab(
     events: mpsc::Sender<AppEvent>,
     render_notify: Arc<Notify>,
     render_dirty: Arc<AtomicBool>,
-) -> Option<crate::workspace::Tab> {
+) -> Option<(
+    crate::workspace::Tab,
+    Vec<TerminalState>,
+    HashMap<TerminalId, TerminalRuntime>,
+)> {
     let (node, id_map) = restore_node_remapped(&snap.layout);
     let reverse_id_map: HashMap<PaneId, u32> = id_map
         .iter()
@@ -110,9 +139,8 @@ fn restore_tab(
     let pane_ids = collect_pane_ids(&node);
 
     let mut panes = HashMap::new();
-    let mut pane_cwds = HashMap::new();
-    let mut terminal_ids = HashMap::new();
-    let mut runtimes = HashMap::new();
+    let mut terminals = Vec::new();
+    let mut terminal_runtimes = HashMap::new();
     for id in &pane_ids {
         let saved_cwd = reverse_id_map
             .get(id)
@@ -142,7 +170,7 @@ fn restore_tab(
             .and_then(|old_id| snap.panes.get(old_id))
             .and_then(|p| p.label.clone());
 
-        match PaneRuntime::spawn(
+        match TerminalRuntime::spawn(
             *id,
             rows,
             cols,
@@ -154,12 +182,14 @@ fn restore_tab(
             render_dirty.clone(),
         ) {
             Ok(runtime) => {
-                let mut pane_state = PaneState::new();
-                pane_state.manual_label = saved_label;
-                panes.insert(*id, pane_state);
-                pane_cwds.insert(*id, cwd.clone());
-                terminal_ids.insert(*id, crate::terminal::TerminalId::alloc());
-                runtimes.insert(*id, runtime);
+                let terminal_id = TerminalId::alloc();
+                let mut terminal = TerminalState::new(terminal_id.clone(), cwd.clone());
+                if let Some(label) = saved_label {
+                    terminal.set_manual_label(label);
+                }
+                panes.insert(*id, PaneState::new(terminal_id.clone()));
+                terminal_runtimes.insert(terminal_id, runtime);
+                terminals.push(terminal);
             }
             Err(e) => {
                 error!(
@@ -193,20 +223,23 @@ fn restore_tab(
     let root_pane = resolve_restored_pane(snap.root_pane, &id_map, &surviving, &pane_ids)?;
     let layout = TileLayout::from_saved(node, focus);
 
-    Some(crate::workspace::Tab {
-        custom_name: snap.custom_name.clone(),
-        number,
-        root_pane,
-        layout,
-        panes,
-        pane_cwds,
-        terminal_ids,
-        runtimes,
-        zoomed: snap.zoomed,
-        events,
-        render_notify,
-        render_dirty,
-    })
+    Some((
+        crate::workspace::Tab {
+            custom_name: snap.custom_name.clone(),
+            number,
+            root_pane,
+            layout,
+            panes,
+            #[cfg(test)]
+            runtimes: HashMap::new(),
+            zoomed: snap.zoomed,
+            events,
+            render_notify,
+            render_dirty,
+        },
+        terminals,
+        terminal_runtimes,
+    ))
 }
 
 pub(super) fn prune_restored_node(node: Node, surviving: &HashSet<PaneId>) -> Option<Node> {
diff --git a/src/persist/snapshot.rs b/src/persist/snapshot.rs
index 76ed96f5..245fbb76 100644
--- a/src/persist/snapshot.rs
+++ b/src/persist/snapshot.rs
@@ -195,6 +195,14 @@ fn first_pane_id_in_layout(layout: &LayoutSnapshot) -> Option<u32> {
 /// Capture the current app state into a serializable snapshot.
 pub fn capture(
     workspaces: &[Workspace],
+    terminals: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalState,
+    >,
+    terminal_runtimes: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalRuntime,
+    >,
     active: Option<usize>,
     selected: usize,
     agent_panel_scope: crate::app::state::AgentPanelScope,
@@ -203,7 +211,10 @@ pub fn capture(
 ) -> SessionSnapshot {
     SessionSnapshot {
         version: SNAPSHOT_VERSION,
-        workspaces: workspaces.iter().map(capture_workspace).collect(),
+        workspaces: workspaces
+            .iter()
+            .map(|workspace| capture_workspace(workspace, terminals, terminal_runtimes))
+            .collect(),
         active,
         selected,
         agent_panel_scope,
@@ -212,25 +223,53 @@ pub fn capture(
     }
 }
 
-fn capture_workspace(ws: &Workspace) -> WorkspaceSnapshot {
+fn capture_workspace(
+    ws: &Workspace,
+    terminals: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalState,
+    >,
+    terminal_runtimes: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalRuntime,
+    >,
+) -> WorkspaceSnapshot {
     WorkspaceSnapshot {
         id: Some(ws.id.clone()),
         custom_name: ws.custom_name.clone(),
         identity_cwd: ws
             .resolved_identity_cwd()
             .unwrap_or_else(|| ws.identity_cwd.clone()),
-        tabs: ws.tabs.iter().map(capture_tab).collect(),
+        tabs: ws
+            .tabs
+            .iter()
+            .map(|tab| capture_tab(tab, terminals, terminal_runtimes))
+            .collect(),
         active_tab: ws.active_tab,
     }
 }
 
-fn capture_tab(tab: &crate::workspace::Tab) -> TabSnapshot {
+fn capture_tab(
+    tab: &crate::workspace::Tab,
+    terminals: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalState,
+    >,
+    terminal_runtimes: &std::collections::HashMap<
+        crate::terminal::TerminalId,
+        crate::terminal::TerminalRuntime,
+    >,
+) -> TabSnapshot {
     let mut panes = HashMap::new();
     for id in tab.panes.keys() {
         let cwd = tab
-            .cwd_for_pane(*id)
+            .cwd_for_pane(*id, terminals, terminal_runtimes)
             .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into()));
-        let label = tab.panes.get(id).and_then(|pane| pane.manual_label.clone());
+        let label = tab
+            .panes
+            .get(id)
+            .and_then(|pane| terminals.get(&pane.attached_terminal_id))
+            .and_then(|terminal| terminal.manual_label.clone());
         panes.insert(id.raw(), PaneSnapshot { cwd, label });
     }
     TabSnapshot {
@@ -310,6 +349,7 @@ mod tests {
     fn state_with_workspaces(names: &[&str]) -> AppState {
         let mut state = AppState::test_new();
         state.workspaces = names.iter().map(|name| Workspace::test_new(name)).collect();
+        state.ensure_test_terminals();
         if !state.workspaces.is_empty() {
             state.active = Some(0);
             state.selected = 0;
@@ -321,6 +361,8 @@ mod tests {
     fn capture_from_state(state: &AppState) -> SessionSnapshot {
         capture(
             &state.workspaces,
+            &state.terminals,
+            &state.terminal_runtimes,
             state.active,
             state.selected,
             state.agent_panel_scope,
@@ -657,13 +699,17 @@ mod tests {
     fn capture_contract_tracks_workspace_identity_and_pane_cwds() {
         let mut state = state_with_workspaces(&["one"]);
         let root = state.workspaces[0].tabs[0].root_pane;
-        state.workspaces[0].tabs[0]
-            .pane_cwds
-            .insert(root, PathBuf::from("/tmp/pion"));
+        state.workspaces[0].identity_cwd = PathBuf::from("/tmp/pion");
         let second = state.workspaces[0].test_split(Direction::Horizontal);
-        state.workspaces[0].tabs[0]
-            .pane_cwds
-            .insert(second, PathBuf::from("/tmp/herdr"));
+        state.ensure_test_terminals();
+        let root_terminal_id = state.workspaces[0].tabs[0].panes[&root]
+            .attached_terminal_id
+            .clone();
+        state.terminals.get_mut(&root_terminal_id).unwrap().cwd = PathBuf::from("/tmp/pion");
+        let second_terminal_id = state.workspaces[0].tabs[0].panes[&second]
+            .attached_terminal_id
+            .clone();
+        state.terminals.get_mut(&second_terminal_id).unwrap().cwd = PathBuf::from("/tmp/herdr");
 
         let snapshot = capture_from_state(&state);
         let workspace = &snapshot.workspaces[0];
diff --git a/src/server/headless.rs b/src/server/headless.rs
index a1e7669b..fbfef251 100644
--- a/src/server/headless.rs
+++ b/src/server/headless.rs
@@ -126,7 +126,10 @@ fn toast_message_from_state_change(
         .find_map(|(ws_idx, ws)| {
             ws.tabs.iter().find_map(|tab| {
                 let pane = tab.panes.get(&pane_id)?;
-                let agent_label = pane.effective_agent_label()?;
+                let agent_label = state
+                    .terminals
+                    .get(&pane.attached_terminal_id)
+                    .and_then(|terminal| terminal.effective_agent_label())?;
                 Some(format!(
                     "{} {}: {}",
                     agent_label,
@@ -762,9 +765,14 @@ impl HeadlessServer {
             .workspaces
             .iter()
             .find_map(|ws| {
-                ws.tabs
-                    .iter()
-                    .find_map(|tab| tab.panes.get(&pane_id).map(|pane| pane.state))
+                ws.tabs.iter().find_map(|tab| {
+                    let pane = tab.panes.get(&pane_id)?;
+                    self.app
+                        .state
+                        .terminals
+                        .get(&pane.attached_terminal_id)
+                        .map(|terminal| terminal.state)
+                })
             })
             .unwrap_or(crate::detect::AgentState::Unknown)
     }
@@ -1332,7 +1340,8 @@ impl HeadlessServer {
         // bypasses drain_internal_events_with_forwarding. Headless mode disables
         // local sound playback, so sound notifications need to be forwarded here.
         let toast_before = self.app.state.toast.clone();
-        let pane_states_before: Vec<(usize, crate::layout::PaneId, crate::detect::AgentState)> =
+        let pane_states_before: Vec<(usize, crate::layout::PaneId, crate::detect::AgentState)> = {
+            let terminals = &self.app.state.terminals;
             self.app
                 .state
                 .workspaces
@@ -1340,12 +1349,15 @@ impl HeadlessServer {
                 .enumerate()
                 .flat_map(|(ws_idx, ws)| {
                     ws.tabs.iter().flat_map(move |tab| {
-                        tab.panes
-                            .iter()
-                            .map(move |(&pane_id, pane)| (ws_idx, pane_id, pane.state))
+                        tab.panes.iter().filter_map(move |(&pane_id, pane)| {
+                            terminals
+                                .get(&pane.attached_terminal_id)
+                                .map(|terminal| (ws_idx, pane_id, terminal.state))
+                        })
                     })
                 })
-                .collect();
+                .collect()
+        };
 
         self.sync_foreground_client_state();
         let response = self.app.handle_api_request(msg.request);
@@ -1391,7 +1403,16 @@ impl HeadlessServer {
                 continue;
             };
 
-            let new_state = pane_after.state;
+            let Some(terminal_after) = self
+                .app
+                .state
+                .terminals
+                .get(&pane_after.attached_terminal_id)
+            else {
+                continue;
+            };
+
+            let new_state = terminal_after.state;
             if new_state == *prev_state {
                 continue;
             }
@@ -1400,7 +1421,7 @@ impl HeadlessServer {
             let suppress_active_tab_notifications =
                 self.active_tab_suppresses_notifications(is_active_tab);
 
-            let agent = pane_after.effective_known_agent();
+            let agent = terminal_after.effective_known_agent();
 
             debug!(
                 ws_idx,
@@ -1419,7 +1440,13 @@ impl HeadlessServer {
                     *prev_state,
                     new_state,
                 ) {
-                    if let Some(agent_label) = pane_after.effective_agent_label() {
+                    if let Some(agent_label) = self
+                        .app
+                        .state
+                        .terminals
+                        .get(&pane_after.attached_terminal_id)
+                        .and_then(|terminal| terminal.effective_agent_label())
+                    {
                         let event_text = match kind {
                             crate::app::state::ToastKind::NeedsAttention => "needs attention",
                             crate::app::state::ToastKind::Finished => "finished",
@@ -2129,9 +2156,9 @@ mod tests {
         let mut state = AppState::test_new();
         let mut ws = crate::workspace::Workspace::test_new("test");
         let pane_id = ws.tabs[0].root_pane;
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"left"),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(20, 5, b"left"),
         );
 
         state.workspaces = vec![ws];
@@ -2165,9 +2192,9 @@ mod tests {
         let mut state = AppState::test_new();
         let mut ws = crate::workspace::Workspace::test_new("test");
         let pane_id = ws.tabs[0].root_pane;
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"left\x1b[?25l"),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(20, 5, b"left\x1b[?25l"),
         );
 
         state.workspaces = vec![ws];
@@ -2201,9 +2228,9 @@ mod tests {
         let mut state = AppState::test_new();
         let mut ws = crate::workspace::Workspace::test_new("test");
         let pane_id = ws.tabs[0].root_pane;
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"left"),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(20, 5, b"left"),
         );
 
         state.workspaces = vec![ws];
@@ -2227,8 +2254,9 @@ mod tests {
         for line in 0..80 {
             bytes.extend_from_slice(format!("line {line:02}\r\n").as_bytes());
         }
-        let runtime = crate::pane::PaneRuntime::test_with_scrollback_bytes(20, 5, 4096, &bytes);
-        ws.tabs[0].runtimes.insert(pane_id, runtime);
+        let runtime =
+            crate::terminal::TerminalRuntime::test_with_scrollback_bytes(20, 5, 4096, &bytes);
+        ws.insert_test_runtime(pane_id, runtime);
 
         state.workspaces = vec![ws];
         state.active = Some(0);
@@ -2237,8 +2265,8 @@ mod tests {
 
         let area = Rect::new(0, 0, 80, 24);
         let _ = crate::server::render_stream::render_virtual(&mut state, area, true);
-        let runtime = state.workspaces[0]
-            .runtime(pane_id)
+        let runtime = state
+            .runtime_for_pane(pane_id)
             .expect("pane runtime after initial render");
         runtime.scroll_up(6);
         assert!(crate::ui::pane_is_scrolled_back(runtime));
@@ -2498,11 +2526,11 @@ mod tests {
         let background_pane = workspace.tabs[background_tab].root_pane;
         workspace.tabs[0].runtimes.insert(
             active_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(80, 24, b""),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
         );
         workspace.tabs[background_tab].runtimes.insert(
             background_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(80, 24, b""),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
         );
         server.app.state.workspaces = vec![workspace];
         server.app.state.active = Some(0);
@@ -2528,11 +2556,20 @@ mod tests {
         let terminal_area = server.app.state.view.terminal_area;
         let expected = (terminal_area.height, terminal_area.width.saturating_sub(1));
         assert_eq!(
-            server.app.state.workspaces[0].tabs[0].runtimes[&active_pane].current_size(),
+            server
+                .app
+                .state
+                .runtime_for_pane(active_pane)
+                .unwrap()
+                .current_size(),
             expected
         );
         assert_eq!(
-            server.app.state.workspaces[0].tabs[background_tab].runtimes[&background_pane]
+            server
+                .app
+                .state
+                .runtime_for_pane(background_pane)
+                .unwrap()
                 .current_size(),
             expected
         );
@@ -3029,12 +3066,22 @@ mod tests {
     #[test]
     fn stale_api_agent_report_does_not_forward_done_sound() {
         let mut server = test_headless_server();
-        let mut background = crate::workspace::Workspace::test_new("background");
+        let background = crate::workspace::Workspace::test_new("background");
         let pane_id = background.tabs[0].root_pane;
         let public_pane_id = format!("{}-1", background.id);
-        background.tabs[0]
-            .panes
-            .get_mut(&pane_id)
+        let foreground = crate::workspace::Workspace::test_new("foreground");
+        server.app.state.workspaces = vec![background, foreground];
+        server.app.state.ensure_test_terminals();
+        let terminal_id = server.app.state.workspaces[0]
+            .pane_state(pane_id)
+            .unwrap()
+            .attached_terminal_id
+            .clone();
+        server
+            .app
+            .state
+            .terminals
+            .get_mut(&terminal_id)
             .unwrap()
             .set_hook_authority(
                 "herdr:pi".into(),
@@ -3043,8 +3090,6 @@ mod tests {
                 None,
                 Some(20),
             );
-        let foreground = crate::workspace::Workspace::test_new("foreground");
-        server.app.state.workspaces = vec![background, foreground];
         server.app.state.active = Some(1);
         server.app.state.selected = 1;
         server.app.state.mode = crate::app::Mode::Terminal;
@@ -3085,10 +3130,7 @@ mod tests {
         assert!(changed);
         assert!(response_rx.recv_timeout(Duration::from_millis(100)).is_ok());
         assert_eq!(
-            server.app.state.workspaces[0]
-                .pane_state(pane_id)
-                .unwrap()
-                .state,
+            server.app.state.terminals.get(&terminal_id).unwrap().state,
             crate::detect::AgentState::Working
         );
         assert!(
diff --git a/src/server/render_stream.rs b/src/server/render_stream.rs
index a921960c..94a43980 100644
--- a/src/server/render_stream.rs
+++ b/src/server/render_stream.rs
@@ -272,7 +272,10 @@ pub(crate) fn visible_hyperlinks(app_state: &AppState) -> Vec<((u16, u16), Strin
 
     let mut links = Vec::new();
     for info in &app_state.view.pane_infos {
-        if let Some(runtime) = tab.runtimes.get(&info.id) {
+        if let Some(runtime) = tab
+            .terminal_id(info.id)
+            .and_then(|terminal_id| app_state.terminal_runtimes.get(terminal_id))
+        {
             links.extend(runtime.visible_hyperlinks(info.inner_rect));
         }
     }
@@ -285,13 +288,12 @@ fn focused_terminal_cursor(app_state: &AppState) -> Option<CursorState> {
     }
 
     let ws_idx = app_state.active?;
-    let ws = app_state.workspaces.get(ws_idx)?;
     let info = app_state
         .view
         .pane_infos
         .iter()
         .find(|info| info.is_focused)?;
-    let rt = ws.runtime(info.id)?;
+    let rt = app_state.runtime_for_pane_in_workspace(ws_idx, info.id)?;
     let cursor = rt.cursor_state(info.inner_rect, true)?;
     Some(CursorState {
         x: cursor.x,
diff --git a/src/terminal/mod.rs b/src/terminal/mod.rs
index 489f7876..5f9bb41b 100644
--- a/src/terminal/mod.rs
+++ b/src/terminal/mod.rs
@@ -1,3 +1,13 @@
 mod id;
+pub mod state;
 
 pub use id::TerminalId;
+pub(crate) use state::stabilize_agent_state;
+pub use state::{EffectiveStateChange, TerminalState};
+
+/// Live runtime for a server-owned terminal.
+///
+/// The implementation still lives in the pane module during this migration, but
+/// all new ownership should address it by `TerminalId` through this terminal
+/// noun.
+pub type TerminalRuntime = crate::pane::PaneRuntime;
diff --git a/src/terminal/state.rs b/src/terminal/state.rs
new file mode 100644
index 00000000..df89b688
--- /dev/null
+++ b/src/terminal/state.rs
@@ -0,0 +1,615 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use crate::detect::{Agent, AgentState};
+use crate::terminal::TerminalId;
+
+const CLAUDE_WORKING_HOLD: std::time::Duration = std::time::Duration::from_millis(1200);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HookAuthority {
+    pub source: String,
+    pub agent_label: String,
+    pub state: AgentState,
+    pub message: Option<String>,
+    pub custom_status: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EffectiveStateChange {
+    pub previous_agent_label: Option<String>,
+    pub previous_known_agent: Option<Agent>,
+    pub previous_state: AgentState,
+    pub agent_label: Option<String>,
+    pub known_agent: Option<Agent>,
+    pub state: AgentState,
+    pub custom_status: Option<String>,
+}
+
+/// Pure state for a server-owned terminal.
+///
+/// During the migration this is still one-to-one with a pane-backed PTY, but
+/// pane/view state no longer owns terminal identity, cwd, labels, or agent
+/// metadata.
+pub struct TerminalState {
+    pub id: TerminalId,
+    pub cwd: PathBuf,
+    pub detected_agent: Option<Agent>,
+    pub fallback_state: AgentState,
+    pub hook_authority: Option<HookAuthority>,
+    pub manual_label: Option<String>,
+    hook_report_sequences: HashMap<String, u64>,
+    pub state: AgentState,
+    pub revision: u64,
+    pub launch_argv: Option<Vec<String>>,
+}
+
+impl TerminalState {
+    pub fn new(id: TerminalId, cwd: PathBuf) -> Self {
+        Self {
+            id,
+            cwd,
+            detected_agent: None,
+            fallback_state: AgentState::Unknown,
+            hook_authority: None,
+            manual_label: None,
+            hook_report_sequences: HashMap::new(),
+            state: AgentState::Unknown,
+            revision: 0,
+            launch_argv: None,
+        }
+    }
+
+    pub fn with_launch_argv(mut self, argv: Vec<String>) -> Self {
+        self.launch_argv = Some(argv);
+        self
+    }
+
+    pub fn set_detected_state(
+        &mut self,
+        agent: Option<Agent>,
+        fallback_state: AgentState,
+    ) -> Option<EffectiveStateChange> {
+        let previous_agent_label = self.effective_agent_label().map(str::to_string);
+        let previous_known_agent = self.effective_known_agent();
+        let previous_state = self.state;
+        let previous_detected_agent = self.detected_agent;
+        self.detected_agent = agent;
+        self.fallback_state = fallback_state;
+        if previous_detected_agent.is_some()
+            && agent != previous_detected_agent
+            && self.hook_authority.as_ref().is_some_and(|authority| {
+                crate::detect::parse_agent_label(&authority.agent_label) == previous_detected_agent
+            })
+        {
+            self.hook_authority = None;
+        }
+        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
+    }
+
+    #[cfg(test)]
+    pub fn set_hook_authority(
+        &mut self,
+        source: String,
+        agent_label: String,
+        state: AgentState,
+        message: Option<String>,
+        seq: Option<u64>,
+    ) -> Option<EffectiveStateChange> {
+        self.set_hook_authority_with_custom_status(source, agent_label, state, message, None, seq)
+    }
+
+    pub fn set_hook_authority_with_custom_status(
+        &mut self,
+        source: String,
+        agent_label: String,
+        state: AgentState,
+        message: Option<String>,
+        custom_status: Option<String>,
+        seq: Option<u64>,
+    ) -> Option<EffectiveStateChange> {
+        if !self.accept_hook_report(&source, seq) {
+            return None;
+        }
+
+        let previous_agent_label = self.effective_agent_label().map(str::to_string);
+        let previous_known_agent = self.effective_known_agent();
+        let previous_state = self.state;
+        self.hook_authority = Some(HookAuthority {
+            source,
+            agent_label,
+            state,
+            message,
+            custom_status,
+        });
+        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
+    }
+
+    fn accept_hook_report(&mut self, source: &str, seq: Option<u64>) -> bool {
+        let Some(seq) = seq else {
+            return !self.hook_report_sequences.contains_key(source);
+        };
+
+        if self
+            .hook_report_sequences
+            .get(source)
+            .is_some_and(|last_seq| seq <= *last_seq)
+        {
+            return false;
+        }
+
+        self.hook_report_sequences.insert(source.to_string(), seq);
+        true
+    }
+
+    pub fn clear_hook_authority(
+        &mut self,
+        source: Option<&str>,
+        seq: Option<u64>,
+    ) -> Option<EffectiveStateChange> {
+        let sequence_source = source.map(str::to_string).or_else(|| {
+            self.hook_authority
+                .as_ref()
+                .map(|authority| authority.source.clone())
+        });
+        if let Some(source) = sequence_source.as_deref() {
+            if !self.accept_hook_report(source, seq) {
+                return None;
+            }
+        }
+
+        let previous_agent_label = self.effective_agent_label().map(str::to_string);
+        let previous_known_agent = self.effective_known_agent();
+        let previous_state = self.state;
+        let should_clear = self
+            .hook_authority
+            .as_ref()
+            .is_some_and(|authority| source.is_none_or(|source| authority.source == source));
+        if !should_clear {
+            return None;
+        }
+        self.hook_authority = None;
+        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
+    }
+
+    pub fn release_agent(
+        &mut self,
+        source: &str,
+        agent_label: &str,
+        seq: Option<u64>,
+    ) -> Option<EffectiveStateChange> {
+        if !self.accept_hook_report(source, seq) {
+            return None;
+        }
+
+        let current_agent_label = self.effective_agent_label()?;
+        if current_agent_label != agent_label {
+            return None;
+        }
+
+        if self.hook_authority.as_ref().is_some_and(|authority| {
+            authority.agent_label != agent_label || authority.source != source
+        }) {
+            return None;
+        }
+
+        let previous_agent_label = self.effective_agent_label().map(str::to_string);
+        let previous_known_agent = self.effective_known_agent();
+        let previous_state = self.state;
+        self.detected_agent = None;
+        self.fallback_state = AgentState::Unknown;
+        self.hook_authority = None;
+        self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state)
+    }
+
+    pub fn effective_agent_label(&self) -> Option<&str> {
+        self.hook_authority
+            .as_ref()
+            .map(|authority| authority.agent_label.as_str())
+            .or_else(|| self.detected_agent.map(crate::detect::agent_label))
+    }
+
+    pub fn effective_known_agent(&self) -> Option<Agent> {
+        if let Some(authority) = &self.hook_authority {
+            return crate::detect::parse_agent_label(&authority.agent_label);
+        }
+        self.detected_agent
+    }
+
+    pub fn effective_custom_status(&self) -> Option<&str> {
+        self.hook_authority
+            .as_ref()
+            .and_then(|authority| authority.custom_status.as_deref())
+    }
+
+    pub fn set_manual_label(&mut self, label: String) {
+        let label = label.trim().to_string();
+        self.manual_label = (!label.is_empty()).then_some(label);
+    }
+
+    pub fn clear_manual_label(&mut self) {
+        self.manual_label = None;
+    }
+
+    pub fn border_label(&self, show_agent_labels: bool) -> Option<&str> {
+        self.manual_label.as_deref().or_else(|| {
+            show_agent_labels
+                .then(|| self.effective_agent_label())
+                .flatten()
+        })
+    }
+
+    fn recompute_effective_state(
+        &mut self,
+        previous_agent_label: Option<String>,
+        previous_known_agent: Option<Agent>,
+        previous_state: AgentState,
+    ) -> Option<EffectiveStateChange> {
+        let state = self
+            .hook_authority
+            .as_ref()
+            .map(|authority| authority.state)
+            .unwrap_or(self.fallback_state);
+        let agent_label = self.effective_agent_label().map(str::to_string);
+        let known_agent = self.effective_known_agent();
+
+        let custom_status = self.effective_custom_status().map(str::to_string);
+
+        if previous_agent_label == agent_label && previous_state == state {
+            return None;
+        }
+
+        self.state = state;
+        Some(EffectiveStateChange {
+            previous_agent_label,
+            previous_known_agent,
+            previous_state,
+            agent_label,
+            known_agent,
+            state,
+            custom_status,
+        })
+    }
+}
+
+pub(crate) fn stabilize_agent_state(
+    agent: Option<Agent>,
+    previous: AgentState,
+    raw: AgentState,
+    now: std::time::Instant,
+    last_claude_working_at: &mut Option<std::time::Instant>,
+) -> AgentState {
+    if agent != Some(Agent::Claude) {
+        return raw;
+    }
+
+    match raw {
+        AgentState::Working => {
+            *last_claude_working_at = Some(now);
+            AgentState::Working
+        }
+        AgentState::Blocked => AgentState::Blocked,
+        AgentState::Idle if previous == AgentState::Working => {
+            if last_claude_working_at
+                .is_some_and(|last_working| now.duration_since(last_working) < CLAUDE_WORKING_HOLD)
+            {
+                AgentState::Working
+            } else {
+                AgentState::Idle
+            }
+        }
+        _ => raw,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_terminal() -> TerminalState {
+        TerminalState::new(TerminalId::alloc(), "/tmp".into())
+    }
+
+    #[test]
+    fn claude_working_is_sticky_for_short_gap() {
+        let now = std::time::Instant::now();
+        let mut last_working = None;
+
+        let working = stabilize_agent_state(
+            Some(Agent::Claude),
+            AgentState::Idle,
+            AgentState::Working,
+            now,
+            &mut last_working,
+        );
+        assert_eq!(working, AgentState::Working);
+
+        let still_working = stabilize_agent_state(
+            Some(Agent::Claude),
+            AgentState::Working,
+            AgentState::Idle,
+            now + std::time::Duration::from_millis(400),
+            &mut last_working,
+        );
+        assert_eq!(still_working, AgentState::Working);
+    }
+
+    #[test]
+    fn claude_transitions_to_idle_after_hold_expires() {
+        let now = std::time::Instant::now();
+        let mut last_working = Some(now);
+
+        let state = stabilize_agent_state(
+            Some(Agent::Claude),
+            AgentState::Working,
+            AgentState::Idle,
+            now + CLAUDE_WORKING_HOLD + std::time::Duration::from_millis(1),
+            &mut last_working,
+        );
+        assert_eq!(state, AgentState::Idle);
+    }
+
+    #[test]
+    fn non_claude_states_are_unchanged() {
+        let now = std::time::Instant::now();
+        let mut last_working = None;
+
+        let state = stabilize_agent_state(
+            Some(Agent::Codex),
+            AgentState::Working,
+            AgentState::Idle,
+            now,
+            &mut last_working,
+        );
+        assert_eq!(state, AgentState::Idle);
+    }
+
+    #[test]
+    fn hook_authority_overrides_fallback_for_same_agent() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            None,
+        );
+
+        assert_eq!(terminal.detected_agent, Some(Agent::Pi));
+        assert_eq!(terminal.fallback_state, AgentState::Idle);
+        assert_eq!(terminal.effective_agent_label(), Some("pi"));
+        assert_eq!(terminal.state, AgentState::Working);
+    }
+
+    #[test]
+    fn hook_authority_can_override_with_unknown_agent_label() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:custom".into(),
+            "hermes".into(),
+            AgentState::Working,
+            None,
+            None,
+        );
+
+        assert_eq!(terminal.detected_agent, Some(Agent::Pi));
+        assert_eq!(terminal.effective_agent_label(), Some("hermes"));
+        assert_eq!(terminal.effective_known_agent(), None);
+        assert_eq!(terminal.state, AgentState::Working);
+    }
+
+    #[test]
+    fn border_label_prefers_manual_label_over_agent_label() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Claude), AgentState::Idle);
+
+        assert_eq!(terminal.border_label(false), None);
+        assert_eq!(terminal.border_label(true), Some("claude"));
+
+        terminal.set_manual_label(" reviewer ".into());
+        assert_eq!(terminal.border_label(false), Some("reviewer"));
+        assert_eq!(terminal.border_label(true), Some("reviewer"));
+
+        terminal.set_manual_label("   ".into());
+        assert_eq!(terminal.border_label(true), Some("claude"));
+
+        terminal.set_manual_label("reviewer".into());
+        terminal.clear_manual_label();
+        assert_eq!(terminal.border_label(true), Some("claude"));
+    }
+
+    #[test]
+    fn hook_authority_survives_unrelated_detected_agent_clear() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:custom".into(),
+            "hermes".into(),
+            AgentState::Working,
+            None,
+            None,
+        );
+
+        terminal.set_detected_state(None, AgentState::Unknown);
+
+        assert!(terminal.hook_authority.is_some());
+        assert_eq!(terminal.detected_agent, None);
+        assert_eq!(terminal.effective_agent_label(), Some("hermes"));
+        assert_eq!(terminal.state, AgentState::Working);
+    }
+
+    #[test]
+    fn detected_agent_clear_clears_matching_hook_authority() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::OpenCode), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:opencode".into(),
+            "opencode".into(),
+            AgentState::Idle,
+            None,
+            None,
+        );
+
+        terminal.set_detected_state(None, AgentState::Unknown);
+
+        assert!(terminal.hook_authority.is_none());
+        assert_eq!(terminal.detected_agent, None);
+        assert_eq!(terminal.fallback_state, AgentState::Unknown);
+        assert_eq!(terminal.effective_agent_label(), None);
+        assert_eq!(terminal.state, AgentState::Unknown);
+    }
+
+    #[test]
+    fn detected_agent_change_clears_previous_matching_hook_authority() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Codex), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:codex".into(),
+            "codex".into(),
+            AgentState::Idle,
+            None,
+            None,
+        );
+
+        terminal.set_detected_state(Some(Agent::OpenCode), AgentState::Working);
+
+        assert!(terminal.hook_authority.is_none());
+        assert_eq!(terminal.detected_agent, Some(Agent::OpenCode));
+        assert_eq!(terminal.effective_agent_label(), Some("opencode"));
+        assert_eq!(terminal.state, AgentState::Working);
+    }
+
+    #[test]
+    fn release_agent_clears_identity_immediately() {
+        let mut terminal = test_terminal();
+        terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle);
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            None,
+        );
+
+        terminal.release_agent("herdr:pi", "pi", None);
+
+        assert!(terminal.hook_authority.is_none());
+        assert_eq!(terminal.detected_agent, None);
+        assert_eq!(terminal.fallback_state, AgentState::Unknown);
+        assert_eq!(terminal.state, AgentState::Unknown);
+    }
+
+    #[test]
+    fn stale_hook_report_sequence_is_ignored_for_same_source() {
+        let mut terminal = test_terminal();
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            Some(20),
+        );
+
+        let change = terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Idle,
+            None,
+            Some(19),
+        );
+
+        assert!(change.is_none());
+        assert_eq!(terminal.state, AgentState::Working);
+        assert_eq!(
+            terminal.hook_authority.as_ref().unwrap().state,
+            AgentState::Working
+        );
+    }
+
+    #[test]
+    fn unsequenced_hook_report_is_ignored_after_source_uses_sequence() {
+        let mut terminal = test_terminal();
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            Some(20),
+        );
+
+        let change = terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Idle,
+            None,
+            None,
+        );
+
+        assert!(change.is_none());
+        assert_eq!(terminal.state, AgentState::Working);
+    }
+
+    #[test]
+    fn stale_release_sequence_is_ignored_for_same_source() {
+        let mut terminal = test_terminal();
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            Some(20),
+        );
+
+        let change = terminal.release_agent("herdr:pi", "pi", Some(19));
+
+        assert!(change.is_none());
+        assert_eq!(terminal.state, AgentState::Working);
+        assert!(terminal.hook_authority.is_some());
+    }
+
+    #[test]
+    fn stale_clear_all_sequence_is_checked_against_current_authority_source() {
+        let mut terminal = test_terminal();
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            Some(20),
+        );
+
+        let change = terminal.clear_hook_authority(None, Some(19));
+
+        assert!(change.is_none());
+        assert_eq!(terminal.state, AgentState::Working);
+        assert!(terminal.hook_authority.is_some());
+    }
+
+    #[test]
+    fn same_sequence_from_different_sources_is_independent() {
+        let mut terminal = test_terminal();
+        terminal.set_hook_authority(
+            "herdr:pi".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            Some(20),
+        );
+
+        terminal.set_hook_authority(
+            "custom:pi".into(),
+            "pi".into(),
+            AgentState::Idle,
+            None,
+            Some(19),
+        );
+
+        assert_eq!(terminal.state, AgentState::Idle);
+        assert_eq!(
+            terminal.hook_authority.as_ref().unwrap().source,
+            "custom:pi"
+        );
+    }
+}
diff --git a/src/ui.rs b/src/ui.rs
index 819cc0eb..a92eb1fe 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -127,7 +127,7 @@ fn resize_background_tab_panes_to_terminal_area(
             if app.active == Some(ws_idx) && tab_idx == ws.active_tab_index() {
                 continue;
             }
-            resize_tab_panes(tab, terminal_area, cell_size);
+            resize_tab_panes(app, tab, terminal_area, cell_size);
         }
     }
 }
@@ -396,13 +396,13 @@ mod tests {
         let first_pane = ws.tabs[0].root_pane;
         let second_pane = ws.test_split(ratatui::layout::Direction::Horizontal);
 
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             first_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"left"),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(20, 5, b"left"),
         );
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             second_pane,
-            crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"r\r\nb"),
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(20, 5, b"r\r\nb"),
         );
         ws.tabs[0].layout.focus_pane(first_pane);
 
@@ -480,10 +480,14 @@ mod tests {
         let repo = temp_git_repo("main");
         ws.identity_cwd = repo.clone();
         let root_pane = ws.tabs[0].root_pane;
-        ws.tabs[0].pane_cwds.insert(root_pane, repo.clone());
         ws.refresh_git_ahead_behind();
 
         app.workspaces = vec![ws];
+        app.ensure_test_terminals();
+        let root_terminal_id = app.workspaces[0].tabs[0].panes[&root_pane]
+            .attached_terminal_id
+            .clone();
+        app.terminals.get_mut(&root_terminal_id).unwrap().cwd = repo.clone();
         app.selected = 0;
         app.mode = Mode::Navigate;
 
@@ -681,9 +685,9 @@ mod tests {
         let mut app = crate::app::state::AppState::test_new();
         let mut ws = Workspace::test_new("test");
         let pane_id = ws.tabs[0].root_pane;
-        ws.tabs[0].runtimes.insert(
+        ws.insert_test_runtime(
             pane_id,
-            crate::pane::PaneRuntime::test_with_scrollback_bytes(
+            crate::terminal::TerminalRuntime::test_with_scrollback_bytes(
                 12,
                 4,
                 4096,
diff --git a/src/ui/mobile.rs b/src/ui/mobile.rs
index 9e8c57e9..8bcdf184 100644
--- a/src/ui/mobile.rs
+++ b/src/ui/mobile.rs
@@ -266,7 +266,7 @@ fn render_header_status(app: &AppState, frame: &mut Frame, area: Rect) {
         return;
     };
 
-    let (state, seen) = ws.aggregate_state();
+    let (state, seen) = ws.aggregate_state(&app.terminals);
     let (dot, dot_style) = if matches!(state, AgentState::Working) {
         (
             super::spinner_frame(app.spinner_tick),
@@ -430,7 +430,7 @@ fn render_mobile_switcher_content(app: &AppState, frame: &mut Frame, viewport: R
         let active = Some(idx) == app.active;
         let selected = idx == app.selected;
         let bg = mobile_item_bg(selected, active, p);
-        let (state, seen) = ws.aggregate_state();
+        let (state, seen) = ws.aggregate_state(&app.terminals);
         let (dot, dot_style) = state_dot(state, seen, p);
         let title = Line::from(vec![
             Span::styled("  ", Style::default().bg(bg)),
@@ -824,7 +824,7 @@ fn agent_priority_label(app: &AppState) -> String {
     let mut blocked = 0usize;
     let mut working = 0usize;
     let mut done = 0usize;
-    for detail in ws.pane_details() {
+    for detail in ws.pane_details(&app.terminals) {
         match (detail.state, detail.seen) {
             (AgentState::Blocked, _) => blocked += 1,
             (AgentState::Working, _) => working += 1,
diff --git a/src/ui/panes.rs b/src/ui/panes.rs
index 289d5fab..c90183ea 100644
--- a/src/ui/panes.rs
+++ b/src/ui/panes.rs
@@ -11,9 +11,9 @@ use super::widgets::panel_contrast_fg;
 use crate::app::state::Palette;
 use crate::app::{AppState, Mode};
 use crate::layout::PaneInfo;
-use crate::pane::PaneRuntime;
+use crate::terminal::TerminalRuntime;
 
-pub(crate) fn pane_is_scrolled_back(rt: &PaneRuntime) -> bool {
+pub(crate) fn pane_is_scrolled_back(rt: &TerminalRuntime) -> bool {
     rt.scroll_metrics()
         .is_some_and(|metrics| metrics.offset_from_bottom > 0)
 }
@@ -55,7 +55,20 @@ fn stable_terminal_inner_rect(pane_inner: Rect) -> Rect {
     )
 }
 
-fn stable_scrollbar_gutter(rt: &PaneRuntime, pane_inner: Rect) -> (Rect, Option<Rect>) {
+fn runtime_for_tab_pane<'a>(
+    app: &'a AppState,
+    tab: &'a crate::workspace::Tab,
+    pane_id: crate::layout::PaneId,
+) -> Option<&'a TerminalRuntime> {
+    #[cfg(test)]
+    if let Some(runtime) = tab.runtimes.get(&pane_id) {
+        return Some(runtime);
+    }
+    let terminal_id = tab.terminal_id(pane_id)?;
+    app.terminal_runtimes.get(terminal_id)
+}
+
+fn stable_scrollbar_gutter(rt: &TerminalRuntime, pane_inner: Rect) -> (Rect, Option<Rect>) {
     let inner_rect = stable_terminal_inner_rect(pane_inner);
     if inner_rect == pane_inner {
         return (inner_rect, None);
@@ -76,6 +89,7 @@ fn stable_scrollbar_gutter(rt: &PaneRuntime, pane_inner: Rect) -> (Rect, Option<
 
 /// Resize every visible runtime in a tab to the geometry it would receive if the tab were selected.
 pub(super) fn resize_tab_panes(
+    app: &AppState,
     tab: &crate::workspace::Tab,
     area: Rect,
     cell_size: crate::kitty_graphics::HostCellSize,
@@ -84,7 +98,7 @@ pub(super) fn resize_tab_panes(
 
     if tab.zoomed {
         let focused_id = tab.layout.focused();
-        if let Some(rt) = tab.runtimes.get(&focused_id) {
+        if let Some(rt) = runtime_for_tab_pane(app, tab, focused_id) {
             let inner_rect = stable_terminal_inner_rect(area);
             rt.resize(
                 inner_rect.height,
@@ -103,7 +117,7 @@ pub(super) fn resize_tab_panes(
             area
         };
 
-        if let Some(rt) = tab.runtimes.get(&info.id) {
+        if let Some(rt) = runtime_for_tab_pane(app, tab, info.id) {
             let inner_rect = stable_terminal_inner_rect(pane_inner);
             rt.resize(
                 inner_rect.height,
@@ -136,7 +150,7 @@ pub(super) fn compute_pane_infos(
         let focused_id = ws.layout.focused();
         let mut inner_rect = area;
         let mut scrollbar_rect = None;
-        if let Some(rt) = ws.runtimes.get(&focused_id) {
+        if let Some(rt) = app.runtime_for_pane_in_workspace(ws_idx, focused_id) {
             (inner_rect, scrollbar_rect) = stable_scrollbar_gutter(rt, area);
             if resize_panes {
                 rt.resize(
@@ -175,7 +189,7 @@ pub(super) fn compute_pane_infos(
 
         let mut inner_rect = pane_inner;
         let mut scrollbar_rect = None;
-        if let Some(rt) = ws.runtimes.get(&info.id) {
+        if let Some(rt) = app.runtime_for_pane_in_workspace(ws_idx, info.id) {
             (inner_rect, scrollbar_rect) = stable_scrollbar_gutter(rt, pane_inner);
             if resize_panes {
                 rt.resize(
@@ -208,7 +222,7 @@ pub(super) fn render_panes(app: &AppState, frame: &mut Frame, area: Rect) {
     let terminal_active = app.mode == Mode::Terminal;
 
     for info in &app.view.pane_infos {
-        if let Some(rt) = ws.runtimes.get(&info.id) {
+        if let Some(rt) = app.runtime_for_pane_in_workspace(ws_idx, info.id) {
             if multi_pane {
                 let (border_style, border_set) = if info.is_focused && terminal_active {
                     (
@@ -233,7 +247,10 @@ pub(super) fn render_panes(app: &AppState, frame: &mut Frame, area: Rect) {
                     .border_set(border_set);
                 if let Some(title) = ws
                     .pane_state(info.id)
-                    .and_then(|pane| pane.border_label(app.show_agent_labels_on_pane_borders))
+                    .and_then(|pane| app.terminals.get(&pane.attached_terminal_id))
+                    .and_then(|terminal| {
+                        terminal.border_label(app.show_agent_labels_on_pane_borders)
+                    })
                     .and_then(|label| pane_border_title(label, info.rect.width))
                 {
                     block = block.title(Line::from(Span::styled(title, border_style)));
@@ -360,7 +377,7 @@ fn render_empty(app: &AppState, frame: &mut Frame, area: Rect) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pane::PaneRuntime;
+    use crate::terminal::TerminalRuntime;
     use crate::workspace::Workspace;
 
     #[test]
@@ -381,7 +398,7 @@ mod tests {
         let root_pane = workspace.tabs[0].root_pane;
         workspace.tabs[0].runtimes.insert(
             root_pane,
-            PaneRuntime::test_with_scrollback_bytes(40, 8, 1024, b"ready\n"),
+            TerminalRuntime::test_with_scrollback_bytes(40, 8, 1024, b"ready\n"),
         );
         app.workspaces = vec![workspace];
         app.active = Some(0);
@@ -408,7 +425,7 @@ mod tests {
         let root_pane = workspace.tabs[0].root_pane;
         workspace.tabs[0].runtimes.insert(
             root_pane,
-            PaneRuntime::test_with_scrollback_bytes(40, 8, 1024, b"ready\n"),
+            TerminalRuntime::test_with_scrollback_bytes(40, 8, 1024, b"ready\n"),
         );
         app.workspaces = vec![workspace];
         app.active = Some(0);
@@ -434,7 +451,7 @@ mod tests {
         let root_pane = workspace.tabs[0].root_pane;
         workspace.tabs[0].runtimes.insert(
             root_pane,
-            PaneRuntime::test_with_scrollback_bytes(4, 8, 1024, b"ready\n"),
+            TerminalRuntime::test_with_scrollback_bytes(4, 8, 1024, b"ready\n"),
         );
         app.workspaces = vec![workspace];
         app.active = Some(0);
@@ -460,7 +477,7 @@ mod tests {
         let root_pane = workspace.tabs[0].root_pane;
         workspace.tabs[0].runtimes.insert(
             root_pane,
-            PaneRuntime::test_with_scrollback_bytes(
+            TerminalRuntime::test_with_scrollback_bytes(
                 40,
                 8,
                 1024,
diff --git a/src/ui/scrollbar.rs b/src/ui/scrollbar.rs
index 34e739d0..b73b2c50 100644
--- a/src/ui/scrollbar.rs
+++ b/src/ui/scrollbar.rs
@@ -165,7 +165,7 @@ pub(super) fn render_pane_scrollbar(
     app: &AppState,
     frame: &mut Frame,
     info: &PaneInfo,
-    rt: &crate::pane::PaneRuntime,
+    rt: &crate::terminal::TerminalRuntime,
 ) {
     let Some(metrics) = rt.scroll_metrics() else {
         return;
diff --git a/src/ui/sidebar.rs b/src/ui/sidebar.rs
index 29f3525d..eb6d6fab 100644
--- a/src/ui/sidebar.rs
+++ b/src/ui/sidebar.rs
@@ -116,7 +116,7 @@ pub(crate) fn agent_panel_entries(app: &AppState) -> Vec<AgentPanelEntry> {
             let Some(ws) = app.workspaces.get(ws_idx) else {
                 return Vec::new();
             };
-            ws.pane_details()
+            ws.pane_details(&app.terminals)
                 .into_iter()
                 .map(|detail| AgentPanelEntry {
                     ws_idx,
@@ -138,7 +138,7 @@ pub(crate) fn agent_panel_entries(app: &AppState) -> Vec<AgentPanelEntry> {
             .flat_map(|(ws_idx, ws)| {
                 let multi_tab = ws.tabs.len() > 1;
                 let workspace_label = ws.display_name();
-                ws.pane_details()
+                ws.pane_details(&app.terminals)
                     .into_iter()
                     .map(move |detail| AgentPanelEntry {
                         ws_idx,
@@ -429,7 +429,7 @@ pub(super) fn render_sidebar_collapsed(app: &AppState, frame: &mut Frame, area:
         if y >= ws_area.y + ws_area.height {
             break;
         }
-        let (agg_state, agg_seen) = ws.aggregate_state();
+        let (agg_state, agg_seen) = ws.aggregate_state(&app.terminals);
         let (icon, icon_style) = state_dot(agg_state, agg_seen, p);
         let is_selected = visible_idx == app.selected && is_navigating;
         let is_active = Some(visible_idx) == app.active;
@@ -487,7 +487,7 @@ pub(super) fn render_sidebar_collapsed(app: &AppState, frame: &mut Frame, area:
     if detail_content_area != Rect::default() {
         if let Some(ws_idx) = detail_ws_idx {
             if let Some(ws) = app.workspaces.get(ws_idx) {
-                for (detail_idx, detail) in ws.pane_details().iter().enumerate() {
+                for (detail_idx, detail) in ws.pane_details(&app.terminals).iter().enumerate() {
                     let y = detail_content_area.y + detail_idx as u16;
                     if y >= detail_content_area.y + detail_content_area.height {
                         break;
@@ -603,7 +603,7 @@ fn render_workspace_list(app: &AppState, frame: &mut Frame, area: Rect, is_navig
         let is_active = Some(i) == app.active;
         let is_dragged = dragged_ws_idx == Some(i);
         let highlighted = selected || is_active || is_dragged;
-        let (agg_state, agg_seen) = ws.aggregate_state();
+        let (agg_state, agg_seen) = ws.aggregate_state(&app.terminals);
 
         if highlighted {
             let bg = if selected {
@@ -899,24 +899,28 @@ mod tests {
     #[test]
     fn all_workspaces_agent_panel_entries_use_workspace_and_optional_tab_labels() {
         let mut app = crate::app::state::AppState::test_new();
-        let mut first = Workspace::test_new("one");
+        let first = Workspace::test_new("one");
         let first_pane = first.tabs[0].root_pane;
-        first.tabs[0]
-            .panes
-            .get_mut(&first_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Pi);
-
         let mut second = Workspace::test_new("two");
         let second_tab = second.test_add_tab(Some("logs"));
         let second_pane = second.tabs[second_tab].root_pane;
-        second.tabs[second_tab]
-            .panes
-            .get_mut(&second_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Claude);
 
         app.workspaces = vec![first, second];
+        app.ensure_test_terminals();
+        let first_terminal_id = app.workspaces[0].tabs[0].panes[&first_pane]
+            .attached_terminal_id
+            .clone();
+        app.terminals
+            .get_mut(&first_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Pi);
+        let second_terminal_id = app.workspaces[1].tabs[second_tab].panes[&second_pane]
+            .attached_terminal_id
+            .clone();
+        app.terminals
+            .get_mut(&second_terminal_id)
+            .unwrap()
+            .detected_agent = Some(Agent::Claude);
         app.active = Some(0);
         app.selected = 0;
         app.agent_panel_scope = AgentPanelScope::AllWorkspaces;
diff --git a/src/workspace.rs b/src/workspace.rs
index 59b3e35d..553206c4 100644
--- a/src/workspace.rs
+++ b/src/workspace.rs
@@ -12,8 +12,8 @@ use crate::events::AppEvent;
 use crate::layout::PaneId;
 #[cfg(test)]
 use crate::layout::TileLayout;
-use crate::pane::{PaneRuntime, PaneState};
-use crate::terminal::TerminalId;
+use crate::pane::PaneState;
+use crate::terminal::{TerminalId, TerminalRuntime, TerminalState};
 
 mod aggregate;
 mod git;
@@ -62,6 +62,8 @@ pub struct Workspace {
     pub(crate) next_public_pane_number: usize,
     pub tabs: Vec<Tab>,
     pub active_tab: usize,
+    #[cfg(test)]
+    pub(crate) test_runtimes: HashMap<PaneId, TerminalRuntime>,
 }
 
 impl Deref for Workspace {
@@ -90,7 +92,7 @@ impl Workspace {
         events: mpsc::Sender<AppEvent>,
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
-    ) -> std::io::Result<Self> {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
         Self::new_with_tab(
             initial_cwd,
             rows,
@@ -114,7 +116,7 @@ impl Workspace {
         events: mpsc::Sender<AppEvent>,
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
-    ) -> std::io::Result<Self> {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
         Self::new_with_tab(
             initial_cwd,
             rows,
@@ -139,8 +141,8 @@ impl Workspace {
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
         argv: Option<&[String]>,
-    ) -> std::io::Result<Self> {
-        let tab = if let Some(argv) = argv {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
+        let (tab, terminal, runtime) = if let Some(argv) = argv {
             Tab::new_argv_command(
                 1,
                 initial_cwd.clone(),
@@ -168,17 +170,23 @@ impl Workspace {
         };
         let mut public_pane_numbers = HashMap::new();
         public_pane_numbers.insert(tab.root_pane, 1);
-        Ok(Self {
-            id: generate_workspace_id(),
-            custom_name: None,
-            identity_cwd: initial_cwd.clone(),
-            cached_git_branch: git_branch(&initial_cwd),
-            cached_git_ahead_behind: None,
-            public_pane_numbers,
-            next_public_pane_number: 2,
-            tabs: vec![tab],
-            active_tab: 0,
-        })
+        Ok((
+            Self {
+                id: generate_workspace_id(),
+                custom_name: None,
+                identity_cwd: initial_cwd.clone(),
+                cached_git_branch: git_branch(&initial_cwd),
+                cached_git_ahead_behind: None,
+                public_pane_numbers,
+                next_public_pane_number: 2,
+                tabs: vec![tab],
+                active_tab: 0,
+                #[cfg(test)]
+                test_runtimes: HashMap::new(),
+            },
+            terminal,
+            runtime,
+        ))
     }
 
     pub fn active_tab(&self) -> Option<&Tab> {
@@ -215,7 +223,7 @@ impl Workspace {
         cwd: PathBuf,
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
-    ) -> std::io::Result<usize> {
+    ) -> std::io::Result<(usize, TerminalState, TerminalRuntime)> {
         self.create_tab_with_runtime(
             rows,
             cols,
@@ -234,7 +242,7 @@ impl Workspace {
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
         argv: Option<&[String]>,
-    ) -> std::io::Result<usize> {
+    ) -> std::io::Result<(usize, TerminalState, TerminalRuntime)> {
         let number = self.tabs.len() + 1;
         let events = self
             .active_tab()
@@ -249,7 +257,7 @@ impl Workspace {
             .map(|tab| tab.render_dirty.clone())
             .expect("workspace must always have at least one tab");
 
-        let tab = if let Some(argv) = argv {
+        let (tab, terminal, runtime) = if let Some(argv) = argv {
             Tab::new_argv_command(
                 number,
                 cwd,
@@ -277,7 +285,7 @@ impl Workspace {
         };
         self.register_new_pane(tab.root_pane);
         self.tabs.push(tab);
-        Ok(self.tabs.len() - 1)
+        Ok((self.tabs.len() - 1, terminal, runtime))
     }
 
     pub fn close_tab(&mut self, idx: usize) -> bool {
@@ -335,8 +343,8 @@ impl Workspace {
         cwd: Option<PathBuf>,
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
-    ) -> std::io::Result<PaneId> {
-        let new_id = self
+    ) -> std::io::Result<crate::workspace::tab::NewPane> {
+        let new_pane = self
             .active_tab_mut()
             .expect("workspace must always have at least one tab")
             .split_focused(
@@ -347,8 +355,8 @@ impl Workspace {
                 scrollback_limit_bytes,
                 host_terminal_theme,
             )?;
-        self.register_new_pane(new_id);
-        Ok(new_id)
+        self.register_new_pane(new_pane.pane_id);
+        Ok(new_pane)
     }
 
     pub fn split_pane(
@@ -361,7 +369,7 @@ impl Workspace {
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
         focus_new_pane: bool,
-    ) -> Option<std::io::Result<(usize, PaneId)>> {
+    ) -> Option<std::io::Result<(usize, crate::workspace::tab::NewPane)>> {
         self.split_pane_with_runtime(
             pane_id,
             direction,
@@ -387,7 +395,7 @@ impl Workspace {
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
         focus_new_pane: bool,
-    ) -> Option<std::io::Result<(usize, PaneId)>> {
+    ) -> Option<std::io::Result<(usize, crate::workspace::tab::NewPane)>> {
         self.split_pane_with_runtime(
             pane_id,
             direction,
@@ -413,12 +421,12 @@ impl Workspace {
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
         focus_new_pane: bool,
         argv: Option<&[String]>,
-    ) -> Option<std::io::Result<(usize, PaneId)>> {
+    ) -> Option<std::io::Result<(usize, crate::workspace::tab::NewPane)>> {
         let tab_idx = self.find_tab_index_for_pane(pane_id)?;
         let tab = &mut self.tabs[tab_idx];
         let previous_focus = tab.layout.focused();
         tab.layout.focus_pane(pane_id);
-        let new_id = match if let Some(argv) = argv {
+        let new_pane = match if let Some(argv) = argv {
             tab.split_focused_argv_command(
                 direction,
                 rows,
@@ -438,7 +446,7 @@ impl Workspace {
                 host_terminal_theme,
             )
         } {
-            Ok(new_id) => new_id,
+            Ok(new_pane) => new_pane,
             Err(err) => {
                 tab.layout.focus_pane(previous_focus);
                 return Some(Err(err));
@@ -447,8 +455,8 @@ impl Workspace {
         if !focus_new_pane {
             tab.layout.focus_pane(previous_focus);
         }
-        self.register_new_pane(new_id);
-        Some(Ok((tab_idx, new_id)))
+        self.register_new_pane(new_pane.pane_id);
+        Some(Ok((tab_idx, new_pane)))
     }
 
     /// Close the focused pane. Returns true if the workspace should close.
@@ -462,11 +470,8 @@ impl Workspace {
             return tab_count <= 1 || self.close_active_tab_and_report();
         }
 
-        if let Some((removed, runtime)) = self.active_tab_mut().and_then(Tab::close_focused) {
+        if let Some((removed, _terminal_id)) = self.active_tab_mut().and_then(Tab::close_focused) {
             self.unregister_pane(removed);
-            if let Some(runtime) = runtime {
-                runtime.shutdown(removed);
-            }
         }
         false
     }
@@ -494,7 +499,7 @@ impl Workspace {
             return false;
         }
 
-        if let Some((removed, _)) = self.tabs[tab_idx].remove_pane(pane_id) {
+        if let Some((removed, _terminal_id)) = self.tabs[tab_idx].remove_pane(pane_id) {
             self.unregister_pane(removed);
         }
         false
@@ -509,10 +514,7 @@ impl Workspace {
     }
 
     pub fn resolved_identity_cwd(&self) -> Option<PathBuf> {
-        self.tabs
-            .first()
-            .and_then(Tab::root_cwd)
-            .or_else(|| Some(self.identity_cwd.clone()))
+        Some(self.identity_cwd.clone())
     }
 
     pub fn display_name(&self) -> String {
@@ -557,10 +559,6 @@ impl Workspace {
         }
     }
 
-    pub fn focused_runtime(&self) -> Option<&PaneRuntime> {
-        self.active_tab().and_then(Tab::focused_runtime)
-    }
-
     pub fn find_tab_index_for_pane(&self, pane_id: PaneId) -> Option<usize> {
         self.tabs
             .iter()
@@ -571,16 +569,6 @@ impl Workspace {
         self.tabs.iter().find_map(|tab| tab.panes.get(&pane_id))
     }
 
-    pub fn pane_state_mut(&mut self, pane_id: PaneId) -> Option<&mut PaneState> {
-        self.tabs
-            .iter_mut()
-            .find_map(|tab| tab.panes.get_mut(&pane_id))
-    }
-
-    pub fn runtime(&self, pane_id: PaneId) -> Option<&PaneRuntime> {
-        self.tabs.iter().find_map(|tab| tab.runtimes.get(&pane_id))
-    }
-
     pub fn terminal_id(&self, pane_id: PaneId) -> Option<&TerminalId> {
         self.tabs.iter().find_map(|tab| tab.terminal_id(pane_id))
     }
@@ -611,11 +599,8 @@ impl Workspace {
             return false;
         }
 
-        if let Some((removed, runtime)) = self.tabs[tab_idx].close_pane(pane_id) {
+        if let Some((removed, _terminal_id)) = self.tabs[tab_idx].close_pane(pane_id) {
             self.unregister_pane(removed);
-            if let Some(runtime) = runtime {
-                runtime.shutdown(removed);
-            }
         }
         false
     }
@@ -660,20 +645,15 @@ impl Workspace {
         let render_dirty = Arc::new(AtomicBool::new(false));
         let identity_cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
         let (layout, root_id) = TileLayout::new();
+        let terminal_id = TerminalId::alloc();
         let mut panes = HashMap::new();
-        panes.insert(root_id, PaneState::new());
-        let mut pane_cwds = HashMap::new();
-        pane_cwds.insert(root_id, identity_cwd.clone());
-        let mut terminal_ids = HashMap::new();
-        terminal_ids.insert(root_id, TerminalId::alloc());
+        panes.insert(root_id, PaneState::new(terminal_id));
         let tab = Tab {
             custom_name: None,
             number: 1,
             root_pane: root_id,
             layout,
             panes,
-            pane_cwds,
-            terminal_ids,
             runtimes: HashMap::new(),
             zoomed: false,
             events,
@@ -692,16 +672,19 @@ impl Workspace {
             next_public_pane_number: 2,
             tabs: vec![tab],
             active_tab: 0,
+            test_runtimes: HashMap::new(),
         }
     }
 
+    pub(crate) fn insert_test_runtime(&mut self, pane_id: PaneId, runtime: TerminalRuntime) {
+        self.test_runtimes.insert(pane_id, runtime);
+    }
+
     pub(crate) fn test_split(&mut self, direction: Direction) -> PaneId {
         let tab = self.active_tab_mut().expect("workspace must have tab");
         let new_id = tab.layout.split_focused(direction);
-        tab.panes.insert(new_id, PaneState::new());
-        let cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
-        tab.pane_cwds.insert(new_id, cwd);
-        tab.terminal_ids.insert(new_id, TerminalId::alloc());
+        tab.panes
+            .insert(new_id, PaneState::new(TerminalId::alloc()));
         self.register_new_pane(new_id);
         new_id
     }
@@ -712,20 +695,13 @@ impl Workspace {
         let render_dirty = Arc::new(AtomicBool::new(false));
         let (layout, root_id) = TileLayout::new();
         let mut panes = HashMap::new();
-        panes.insert(root_id, PaneState::new());
-        let cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
-        let mut pane_cwds = HashMap::new();
-        pane_cwds.insert(root_id, cwd);
-        let mut terminal_ids = HashMap::new();
-        terminal_ids.insert(root_id, TerminalId::alloc());
+        panes.insert(root_id, PaneState::new(TerminalId::alloc()));
         let tab = Tab {
             custom_name: name.map(str::to_string),
             number: self.tabs.len() + 1,
             root_pane: root_id,
             layout,
             panes,
-            pane_cwds,
-            terminal_ids,
             runtimes: HashMap::new(),
             zoomed: false,
             events,
@@ -743,13 +719,10 @@ mod tests {
     use super::*;
 
     #[test]
-    fn workspace_identity_follows_first_tab_root_pane_cwd() {
+    fn workspace_identity_uses_identity_cwd() {
         let mut ws = Workspace::test_new("ignored");
         ws.custom_name = None;
-        let root_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .pane_cwds
-            .insert(root_pane, PathBuf::from("/herdr-test/pion"));
+        ws.identity_cwd = PathBuf::from("/herdr-test/pion");
 
         assert_eq!(ws.display_name(), "pion");
         assert_eq!(
diff --git a/src/workspace/aggregate.rs b/src/workspace/aggregate.rs
index 0507781e..3ac7ea9b 100644
--- a/src/workspace/aggregate.rs
+++ b/src/workspace/aggregate.rs
@@ -1,5 +1,8 @@
+use std::collections::HashMap;
+
 use crate::detect::{Agent, AgentState};
 use crate::layout::PaneId;
+use crate::terminal::{TerminalId, TerminalState};
 
 use super::{Tab, Workspace};
 
@@ -18,29 +21,32 @@ pub struct PaneDetail {
 }
 
 impl Tab {
-    pub fn has_working_pane(&self) -> bool {
-        self.panes
-            .values()
-            .any(|pane| pane.state == AgentState::Working)
+    pub fn has_working_pane(&self, terminals: &HashMap<TerminalId, TerminalState>) -> bool {
+        self.panes.values().any(|pane| {
+            terminals
+                .get(&pane.attached_terminal_id)
+                .is_some_and(|terminal| terminal.state == AgentState::Working)
+        })
     }
 
-    pub fn pane_details(&self) -> Vec<PaneDetail> {
+    pub fn pane_details(&self, terminals: &HashMap<TerminalId, TerminalState>) -> Vec<PaneDetail> {
         self.layout
             .pane_ids()
             .iter()
             .filter_map(|id| {
                 let pane = self.panes.get(id)?;
-                let agent_label = pane.effective_agent_label()?.to_string();
+                let terminal = terminals.get(&pane.attached_terminal_id)?;
+                let agent_label = terminal.effective_agent_label()?.to_string();
                 Some(PaneDetail {
                     pane_id: *id,
                     tab_idx: self.number.saturating_sub(1),
                     tab_label: self.display_name(),
                     label: agent_label.clone(),
                     agent_label,
-                    agent: pane.effective_known_agent(),
-                    state: pane.state,
+                    agent: terminal.effective_known_agent(),
+                    state: terminal.state,
                     seen: pane.seen,
-                    custom_status: pane.effective_custom_status().map(str::to_string),
+                    custom_status: terminal.effective_custom_status().map(str::to_string),
                 })
             })
             .collect()
@@ -58,24 +64,31 @@ fn pane_attention_priority(state: AgentState, seen: bool) -> u8 {
 }
 
 impl Workspace {
-    pub fn aggregate_state(&self) -> (AgentState, bool) {
+    pub fn aggregate_state(
+        &self,
+        terminals: &HashMap<TerminalId, TerminalState>,
+    ) -> (AgentState, bool) {
         self.tabs
             .iter()
             .flat_map(|tab| tab.panes.values())
-            .map(|pane| (pane.state, pane.seen))
+            .filter_map(|pane| {
+                terminals
+                    .get(&pane.attached_terminal_id)
+                    .map(|terminal| (terminal.state, pane.seen))
+            })
             .max_by_key(|(state, seen)| pane_attention_priority(*state, *seen))
             .unwrap_or((AgentState::Unknown, true))
     }
 
-    pub fn has_working_pane(&self) -> bool {
-        self.tabs.iter().any(Tab::has_working_pane)
+    pub fn has_working_pane(&self, terminals: &HashMap<TerminalId, TerminalState>) -> bool {
+        self.tabs.iter().any(|tab| tab.has_working_pane(terminals))
     }
 
-    pub fn pane_details(&self) -> Vec<PaneDetail> {
+    pub fn pane_details(&self, terminals: &HashMap<TerminalId, TerminalState>) -> Vec<PaneDetail> {
         let multi_tab = self.tabs.len() > 1;
         self.tabs
             .iter()
-            .flat_map(Tab::pane_details)
+            .flat_map(|tab| tab.pane_details(terminals))
             .map(|mut detail| {
                 if multi_tab {
                     detail.label = format!("{}·{}", detail.tab_label, detail.agent_label);
@@ -93,10 +106,18 @@ mod tests {
     use super::*;
     use crate::detect::Agent;
 
+    fn terminal_for_pane(ws: &Workspace, pane_id: PaneId) -> TerminalState {
+        TerminalState::new(ws.terminal_id(pane_id).unwrap().clone(), "/tmp".into())
+    }
+
     #[test]
     fn aggregate_state_all_unknown() {
         let ws = Workspace::test_new("test");
-        let (state, seen) = ws.aggregate_state();
+        let mut terminals = HashMap::new();
+        let root = ws.tabs[0].root_pane;
+        let terminal = terminal_for_pane(&ws, root);
+        terminals.insert(terminal.id.clone(), terminal);
+        let (state, seen) = ws.aggregate_state(&terminals);
         assert_eq!(state, AgentState::Unknown);
         assert!(seen);
     }
@@ -111,10 +132,16 @@ mod tests {
             .find(|id| **id != id2)
             .copied()
             .unwrap();
-        ws.tabs[0].panes.get_mut(&root_id).unwrap().state = AgentState::Idle;
-        ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working;
+        let mut terminals = HashMap::new();
+        let mut root_terminal = terminal_for_pane(&ws, root_id);
+        root_terminal.state = AgentState::Idle;
+        terminals.insert(root_terminal.id.clone(), root_terminal);
+        let mut second_terminal = terminal_for_pane(&ws, id2);
+        second_terminal.state = AgentState::Working;
+        terminals.insert(second_terminal.id.clone(), second_terminal);
+
+        let (state, seen) = ws.aggregate_state(&terminals);
 
-        let (state, seen) = ws.aggregate_state();
         assert_eq!(state, AgentState::Working);
         assert!(seen);
     }
@@ -129,68 +156,61 @@ mod tests {
             .find(|id| **id != id2)
             .copied()
             .unwrap();
+        let mut terminals = HashMap::new();
+        let mut root_terminal = terminal_for_pane(&ws, root_id);
+        root_terminal.state = AgentState::Idle;
+        terminals.insert(root_terminal.id.clone(), root_terminal);
+        let mut second_terminal = terminal_for_pane(&ws, id2);
+        second_terminal.state = AgentState::Working;
+        terminals.insert(second_terminal.id.clone(), second_terminal);
         let root = ws.tabs[0].panes.get_mut(&root_id).unwrap();
-        root.state = AgentState::Idle;
         root.seen = false;
-        ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working;
 
-        let (state, seen) = ws.aggregate_state();
+        let (state, seen) = ws.aggregate_state(&terminals);
+
         assert_eq!(state, AgentState::Idle);
         assert!(!seen);
     }
 
     #[test]
-    fn pane_details_hide_plain_shells() {
-        let mut ws = Workspace::test_new("test");
-        let root_pane = ws.tabs[0].root_pane;
-        ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi);
-        ws.test_split(Direction::Horizontal);
-
-        let details = ws.pane_details();
-        assert_eq!(details.len(), 1);
-        assert_eq!(details[0].label, "pi");
-    }
-
-    #[test]
-    fn pane_details_include_tab_context_when_workspace_has_multiple_tabs() {
-        let mut ws = Workspace::test_new("test");
-        ws.tabs[0].set_custom_name("main".into());
-        let root_pane = ws.tabs[0].root_pane;
-        ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi);
-
-        let tab_idx = ws.test_add_tab(Some("logs"));
-        let second_root_pane = ws.tabs[tab_idx].root_pane;
-        ws.tabs[tab_idx]
-            .panes
-            .get_mut(&second_root_pane)
-            .unwrap()
-            .detected_agent = Some(Agent::Claude);
-
-        let details = ws.pane_details();
-        assert_eq!(details.len(), 2);
-        assert!(details.iter().any(|detail| detail.label == "main·pi"));
-        assert!(details.iter().any(|detail| detail.label == "logs·claude"));
-    }
-
-    #[test]
-    fn pane_details_include_hook_reported_unknown_agents() {
+    fn pane_details_includes_tab_context_for_multi_tab_workspace() {
         let mut ws = Workspace::test_new("test");
+        ws.tabs[0].custom_name = Some("main".into());
         let root_pane = ws.tabs[0].root_pane;
-        ws.tabs[0]
-            .panes
-            .get_mut(&root_pane)
-            .unwrap()
-            .set_hook_authority(
-                "custom:hermes".into(),
-                "hermes".into(),
-                AgentState::Working,
-                None,
-                None,
-            );
-
-        let details = ws.pane_details();
-        assert_eq!(details.len(), 1);
-        assert_eq!(details[0].agent_label, "hermes");
-        assert_eq!(details[0].agent, None);
+        let second_tab = ws.test_add_tab(Some("review"));
+        let review_pane = ws.tabs[second_tab].root_pane;
+        let mut terminals = HashMap::new();
+        let mut root_terminal = terminal_for_pane(&ws, root_pane);
+        root_terminal.set_hook_authority(
+            "test".into(),
+            "pi".into(),
+            AgentState::Working,
+            None,
+            None,
+        );
+        terminals.insert(root_terminal.id.clone(), root_terminal);
+        let mut review_terminal = terminal_for_pane(&ws, review_pane);
+        review_terminal.set_hook_authority(
+            "test".into(),
+            "claude".into(),
+            AgentState::Idle,
+            None,
+            None,
+        );
+        terminals.insert(review_terminal.id.clone(), review_terminal);
+
+        let labels: Vec<_> = ws
+            .pane_details(&terminals)
+            .into_iter()
+            .map(|detail| (detail.label, detail.agent_label, detail.agent))
+            .collect();
+
+        assert_eq!(
+            labels,
+            vec![
+                ("main·pi".into(), "pi".into(), Some(Agent::Pi)),
+                ("review·claude".into(), "claude".into(), Some(Agent::Claude)),
+            ]
+        );
     }
 }
diff --git a/src/workspace/tab.rs b/src/workspace/tab.rs
index d809f944..943a45a0 100644
--- a/src/workspace/tab.rs
+++ b/src/workspace/tab.rs
@@ -8,8 +8,16 @@ use tokio::sync::{mpsc, Notify};
 
 use crate::events::AppEvent;
 use crate::layout::{PaneId, TileLayout};
-use crate::pane::{PaneRuntime, PaneState};
-use crate::terminal::TerminalId;
+use crate::pane::PaneState;
+use crate::terminal::{TerminalId, TerminalRuntime, TerminalState};
+
+pub(crate) type DetachedPane = (PaneId, TerminalId);
+
+pub struct NewPane {
+    pub pane_id: PaneId,
+    pub terminal: TerminalState,
+    pub runtime: TerminalRuntime,
+}
 
 enum SplitCommand<'a> {
     Shell {
@@ -27,29 +35,16 @@ pub struct Tab {
     /// Identity source for this tab's pane tree.
     pub root_pane: PaneId,
     pub layout: TileLayout,
-    /// Pane state — always present, testable without PTYs.
+    /// Pane viewport state — always present, testable without PTYs.
     pub panes: HashMap<PaneId, PaneState>,
-    /// Best-effort cwd cache per pane. Live runtime cwd wins when available.
-    pub pane_cwds: HashMap<PaneId, PathBuf>,
-    /// One-to-one terminal identity for each pane-backed PTY during the transition.
-    pub terminal_ids: HashMap<PaneId, TerminalId>,
-    /// Pane runtimes — only present in production (empty in tests).
-    pub runtimes: HashMap<PaneId, PaneRuntime>,
+    #[cfg(test)]
+    pub runtimes: HashMap<PaneId, TerminalRuntime>,
     pub zoomed: bool,
     pub events: mpsc::Sender<AppEvent>,
     pub(crate) render_notify: Arc<Notify>,
     pub(crate) render_dirty: Arc<AtomicBool>,
 }
 
-impl Drop for Tab {
-    fn drop(&mut self) {
-        let runtimes = std::mem::take(&mut self.runtimes);
-        for (pane_id, runtime) in runtimes {
-            runtime.shutdown(pane_id);
-        }
-    }
-}
-
 impl Tab {
     pub fn new(
         number: usize,
@@ -61,7 +56,7 @@ impl Tab {
         events: mpsc::Sender<AppEvent>,
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
-    ) -> std::io::Result<Self> {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
         Self::new_with_runtime(
             number,
             initial_cwd,
@@ -87,7 +82,7 @@ impl Tab {
         events: mpsc::Sender<AppEvent>,
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
-    ) -> std::io::Result<Self> {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
         Self::new_with_runtime(
             number,
             initial_cwd,
@@ -114,10 +109,10 @@ impl Tab {
         render_notify: Arc<Notify>,
         render_dirty: Arc<AtomicBool>,
         argv: Option<&[String]>,
-    ) -> std::io::Result<Self> {
+    ) -> std::io::Result<(Self, TerminalState, TerminalRuntime)> {
         let (layout, root_id) = TileLayout::new();
         let runtime = if let Some(argv) = argv {
-            PaneRuntime::spawn_argv_command(
+            TerminalRuntime::spawn_argv_command(
                 root_id,
                 rows,
                 cols,
@@ -130,7 +125,7 @@ impl Tab {
                 render_dirty.clone(),
             )?
         } else {
-            PaneRuntime::spawn(
+            TerminalRuntime::spawn(
                 root_id,
                 rows,
                 cols,
@@ -143,29 +138,33 @@ impl Tab {
             )?
         };
 
+        let terminal_id = TerminalId::alloc();
+        let terminal = match argv {
+            Some(argv) => {
+                TerminalState::new(terminal_id.clone(), initial_cwd).with_launch_argv(argv.to_vec())
+            }
+            None => TerminalState::new(terminal_id.clone(), initial_cwd),
+        };
         let mut panes = HashMap::new();
-        panes.insert(root_id, PaneState::new());
-        let mut pane_cwds = HashMap::new();
-        pane_cwds.insert(root_id, initial_cwd);
-        let mut terminal_ids = HashMap::new();
-        terminal_ids.insert(root_id, TerminalId::alloc());
-        let mut runtimes = HashMap::new();
-        runtimes.insert(root_id, runtime);
+        panes.insert(root_id, PaneState::new(terminal_id));
 
-        Ok(Self {
-            custom_name: None,
-            number,
-            root_pane: root_id,
-            layout,
-            panes,
-            pane_cwds,
-            terminal_ids,
-            runtimes,
-            zoomed: false,
-            events,
-            render_notify,
-            render_dirty,
-        })
+        Ok((
+            Self {
+                custom_name: None,
+                number,
+                root_pane: root_id,
+                layout,
+                panes,
+                #[cfg(test)]
+                runtimes: HashMap::new(),
+                zoomed: false,
+                events,
+                render_notify,
+                render_dirty,
+            },
+            terminal,
+            runtime,
+        ))
     }
 
     pub fn display_name(&self) -> String {
@@ -190,7 +189,7 @@ impl Tab {
         cwd: Option<PathBuf>,
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
-    ) -> std::io::Result<PaneId> {
+    ) -> std::io::Result<NewPane> {
         self.split_focused_with_runtime(
             direction,
             rows,
@@ -212,7 +211,7 @@ impl Tab {
         extra_env: &[(String, String)],
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
-    ) -> std::io::Result<PaneId> {
+    ) -> std::io::Result<NewPane> {
         self.split_focused_with_runtime(
             direction,
             rows,
@@ -233,7 +232,7 @@ impl Tab {
         argv: &[String],
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
-    ) -> std::io::Result<PaneId> {
+    ) -> std::io::Result<NewPane> {
         self.split_focused_with_runtime(
             direction,
             rows,
@@ -254,25 +253,33 @@ impl Tab {
         scrollback_limit_bytes: usize,
         host_terminal_theme: crate::terminal_theme::TerminalTheme,
         command: Option<SplitCommand<'_>>,
-    ) -> std::io::Result<PaneId> {
+    ) -> std::io::Result<NewPane> {
+        let previous_focus = self.layout.focused();
         let new_id = self.layout.split_focused(direction);
         let actual_cwd =
             cwd.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into()));
+        let launch_argv = if let Some(SplitCommand::Argv { argv }) = &command {
+            Some((*argv).to_vec())
+        } else {
+            None
+        };
         let runtime = match command {
-            Some(SplitCommand::Shell { command, extra_env }) => PaneRuntime::spawn_shell_command(
-                new_id,
-                rows,
-                cols,
-                actual_cwd.clone(),
-                command,
-                extra_env,
-                scrollback_limit_bytes,
-                host_terminal_theme,
-                self.events.clone(),
-                self.render_notify.clone(),
-                self.render_dirty.clone(),
-            )?,
-            Some(SplitCommand::Argv { argv }) => PaneRuntime::spawn_argv_command(
+            Some(SplitCommand::Shell { command, extra_env }) => {
+                TerminalRuntime::spawn_shell_command(
+                    new_id,
+                    rows,
+                    cols,
+                    actual_cwd.clone(),
+                    command,
+                    extra_env,
+                    scrollback_limit_bytes,
+                    host_terminal_theme,
+                    self.events.clone(),
+                    self.render_notify.clone(),
+                    self.render_dirty.clone(),
+                )
+            }
+            Some(SplitCommand::Argv { argv }) => TerminalRuntime::spawn_argv_command(
                 new_id,
                 rows,
                 cols,
@@ -283,8 +290,8 @@ impl Tab {
                 self.events.clone(),
                 self.render_notify.clone(),
                 self.render_dirty.clone(),
-            )?,
-            None => PaneRuntime::spawn(
+            ),
+            None => TerminalRuntime::spawn(
                 new_id,
                 rows,
                 cols,
@@ -294,30 +301,46 @@ impl Tab {
                 self.events.clone(),
                 self.render_notify.clone(),
                 self.render_dirty.clone(),
-            )?,
+            ),
+        };
+        let runtime = match runtime {
+            Ok(runtime) => runtime,
+            Err(err) => {
+                self.layout.close_focused();
+                self.layout.focus_pane(previous_focus);
+                return Err(err);
+            }
         };
-        self.panes.insert(new_id, PaneState::new());
-        self.pane_cwds.insert(new_id, actual_cwd);
-        self.terminal_ids.insert(new_id, TerminalId::alloc());
-        self.runtimes.insert(new_id, runtime);
+        let terminal_id = TerminalId::alloc();
+        let terminal = match launch_argv {
+            Some(argv) => {
+                TerminalState::new(terminal_id.clone(), actual_cwd).with_launch_argv(argv)
+            }
+            None => TerminalState::new(terminal_id.clone(), actual_cwd),
+        };
+        self.panes.insert(new_id, PaneState::new(terminal_id));
         self.zoomed = false;
-        Ok(new_id)
+        Ok(NewPane {
+            pane_id: new_id,
+            terminal,
+            runtime,
+        })
     }
 
-    pub fn close_focused(&mut self) -> Option<(PaneId, Option<PaneRuntime>)> {
+    pub fn close_focused(&mut self) -> Option<DetachedPane> {
         let pane_id = self.layout.focused();
         self.detach_pane(pane_id)
     }
 
-    pub fn close_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> {
+    pub fn close_pane(&mut self, pane_id: PaneId) -> Option<DetachedPane> {
         self.detach_pane(pane_id)
     }
 
-    pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> {
+    pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<DetachedPane> {
         self.detach_pane(pane_id)
     }
 
-    fn detach_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> {
+    fn detach_pane(&mut self, pane_id: PaneId) -> Option<DetachedPane> {
         if self.layout.pane_count() <= 1 {
             return None;
         }
@@ -333,15 +356,13 @@ impl Tab {
             self.layout.focus_pane(prev_focus);
         }
 
-        self.panes.remove(&pane_id);
-        self.pane_cwds.remove(&pane_id);
-        self.terminal_ids.remove(&pane_id);
-        let runtime = self.runtimes.remove(&pane_id);
+        let pane = self.panes.remove(&pane_id)?;
+        let terminal_id = pane.attached_terminal_id;
         self.zoomed = false;
         if let Some(next_root) = next_root {
             self.root_pane = next_root;
         }
-        Some((pane_id, runtime))
+        Some((pane_id, terminal_id))
     }
 
     fn promoted_root_if_needed(&self, closing: PaneId) -> Option<PaneId> {
@@ -351,37 +372,26 @@ impl Tab {
         self.layout.pane_ids().into_iter().find(|id| *id != closing)
     }
 
-    pub fn focused_runtime(&self) -> Option<&PaneRuntime> {
-        self.runtimes.get(&self.layout.focused())
-    }
-
     pub fn terminal_id(&self, pane_id: PaneId) -> Option<&TerminalId> {
-        self.terminal_ids.get(&pane_id)
-    }
-
-    pub fn cwd_for_pane(&self, pane_id: PaneId) -> Option<PathBuf> {
-        self.runtimes
+        self.panes
             .get(&pane_id)
-            .and_then(|rt| rt.cwd())
-            .or_else(|| self.pane_cwds.get(&pane_id).cloned())
+            .map(|pane| &pane.attached_terminal_id)
     }
 
-    pub fn root_cwd(&self) -> Option<PathBuf> {
-        self.cwd_for_pane(self.root_pane)
-    }
-
-    #[cfg(test)]
-    #[allow(dead_code)] // retained for focused layout-order assertions in tests
-    pub fn pane_states(&self) -> Vec<(crate::detect::AgentState, bool)> {
-        self.layout
-            .pane_ids()
-            .iter()
-            .map(|id| {
-                self.panes
-                    .get(id)
-                    .map(|p| (p.state, p.seen))
-                    .unwrap_or((crate::detect::AgentState::Unknown, true))
+    pub fn cwd_for_pane(
+        &self,
+        pane_id: PaneId,
+        terminals: &HashMap<TerminalId, TerminalState>,
+        terminal_runtimes: &HashMap<TerminalId, TerminalRuntime>,
+    ) -> Option<PathBuf> {
+        let terminal_id = self.terminal_id(pane_id)?;
+        terminal_runtimes
+            .get(terminal_id)
+            .and_then(|rt| rt.cwd())
+            .or_else(|| {
+                terminals
+                    .get(terminal_id)
+                    .map(|terminal| terminal.cwd.clone())
             })
-            .collect()
     }
 }