fix(terminals): decouple PTY lifecycle from view lifecycle (no kill on navigation)

Navigating (layout/tab switch) tore the xterm view down and called
handle.close(), killing the backend PTY and cutting off running AIs. Now
the view's cleanup only detaches; only an explicit user action kills a PTY.

Backend:
- PortablePtyAdapter: per-session scrollback ring buffer (~100KB, most
  recent) + re-subscribable fan-out broadcast replacing the single-take
  output_rx. Reader thread feeds both the ring buffer and current
  subscribers; on EOF it closes subscribers (streams end) while keeping
  scrollback for late re-attach.
- PtyPort: new scrollback() method; subscribe_output is now re-subscribable
  (all impls + test fakes updated).
- reattach_terminal IPC command: returns scrollback and re-wires a fresh
  output channel on the live session without re-spawning.
- CloseRequested hook kills all live PTYs cleanly on app shutdown.
- TerminalSessions::handles() to enumerate live sessions at shutdown.

Frontend:
- TerminalHandle.detach(); TerminalGateway/AgentGateway.reattach() + mocks.
- TerminalView cleanup detaches (never close); on mount it re-attaches to a
  persisted session (repainting scrollback) instead of opening a new PTY.
- LayoutGrid persists the cell's session id via setSession; AgentsPanel
  tracks per-agent session ids — both drive reattach-vs-open.

Tests: ring buffer bounds to 100KB keeping newest bytes; scrollback retained;
re-subscription delivers post-reattach output; TerminalView detaches (not
closes) on unmount and reattaches with a known session; mock detach/reattach.

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

crates/infrastructure/tests/pty_adapter.rs

@@ -113,25 +113,113 @@ async fn write_is_echoed_back_through_output_stream() {
 }
 
 #[tokio::test]
-async fn subscribe_output_twice_is_an_error() {
+async fn subscribe_output_is_re_subscribable_for_reattach() {
+    // A live PTY can be subscribed to more than once over its lifetime: the
+    // first view detaches (drops its stream), a second view re-attaches and
+    // still receives subsequent output — the core of the no-kill navigation fix.
     let pty = PortablePtyAdapter::new();
     let handle = pty
-        .spawn(sh_spec("sleep 0.2"), size())
+        .spawn(sh_spec("cat"), size())
+        .await
+        .expect("spawn cat");
+
+    // First attachment: subscribe, observe an echo, then drop the stream
+    // (simulating a view tearing down on navigation — NOT a kill).
+    {
+        let first = pty.subscribe_output(&handle).expect("first subscribe");
+        let (tx, rx) = mpsc::channel();
+        let worker = thread::spawn(move || {
+            let mut all = Vec::new();
+            for chunk in first {
+                all.extend_from_slice(&chunk);
+                if String::from_utf8_lossy(&all).contains("first-marker") {
+                    let _ = tx.send(());
+                    return; // drop the stream → detach
+                }
+            }
+        });
+        pty.write(&handle, b"first-marker\n").expect("write 1");
+        rx.recv_timeout(TIMEOUT).expect("first view saw its marker");
+        worker.join().expect("first worker joined");
+    }
+
+    // Second attachment to the SAME live PTY (no re-spawn): must still receive
+    // new output produced after re-subscription.
+    let second = pty.subscribe_output(&handle).expect("re-subscribe");
+    let (tx, rx) = mpsc::channel();
+    let worker = thread::spawn(move || {
+        let mut all = Vec::new();
+        for chunk in second {
+            all.extend_from_slice(&chunk);
+            if String::from_utf8_lossy(&all).contains("second-marker") {
+                let _ = tx.send(());
+            }
+        }
+    });
+    pty.write(&handle, b"second-marker\n").expect("write 2");
+    rx.recv_timeout(TIMEOUT)
+        .expect("re-attached view saw new output");
+
+    pty.kill(&handle).await.expect("kill cat");
+    worker.join().expect("second worker joined after kill");
+}
+
+#[tokio::test]
+async fn scrollback_retains_recent_output_for_repaint() {
+    // After output is produced and the process exits, the scrollback still holds
+    // the recent bytes so a re-attaching view can repaint them.
+    let pty = PortablePtyAdapter::new();
+    let handle = pty
+        .spawn(sh_spec("printf scrollback-content"), size())
         .await
         .expect("spawn");
 
-    let first = pty.subscribe_output(&handle);
-    assert!(first.is_ok(), "first subscribe succeeds");
+    // Drain to EOF so all output has been pushed into the ring buffer.
+    let stream = pty.subscribe_output(&handle).expect("subscribe");
+    drain_with_timeout(stream, TIMEOUT);
 
-    let second = pty.subscribe_output(&handle);
+    let sb = pty.scrollback(&handle).expect("scrollback readable");
+    let text = String::from_utf8_lossy(&sb);
     assert!(
-        second.is_err(),
-        "second subscribe on the same session must error"
+        text.contains("scrollback-content"),
+        "scrollback should retain recent output, got {text:?}"
     );
 
-    // Drain the first stream so the reader thread can finish, then tidy up.
-    let stream = first.unwrap();
+    let _ = pty.kill(&handle).await;
+}
+
+#[tokio::test]
+async fn scrollback_is_bounded_to_cap_and_keeps_most_recent_bytes() {
+    // Emit clearly more than 100 KB of deterministic output, then assert the
+    // retained scrollback is bounded and ends with the most recent bytes.
+    let pty = PortablePtyAdapter::new();
+    // 5000 lines of "....END<n>" → well over 100 KB; the tail is the freshest.
+    let script = "i=0; while [ $i -lt 5000 ]; do \
+        printf 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-%d\\n' $i; \
+        i=$((i+1)); done; printf 'FINAL-LINE-MARKER'";
+    let handle = pty.spawn(sh_spec(script), size()).await.expect("spawn");
+
+    let stream = pty.subscribe_output(&handle).expect("subscribe");
     drain_with_timeout(stream, TIMEOUT);
+
+    let sb = pty.scrollback(&handle).expect("scrollback readable");
+    assert!(
+        sb.len() <= 100 * 1024,
+        "scrollback must be bounded to ~100 KB, was {} bytes",
+        sb.len()
+    );
+    // The newest output is retained even though the oldest was dropped.
+    let text = String::from_utf8_lossy(&sb);
+    assert!(
+        text.contains("FINAL-LINE-MARKER"),
+        "the most recent bytes must be kept in the ring buffer"
+    );
+    // And the very first lines must have been evicted.
+    assert!(
+        !text.contains("-0\n") || sb.len() < 100 * 1024,
+        "oldest bytes should be dropped once the cap is exceeded"
+    );
+
     let _ = pty.kill(&handle).await;
 }