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>

frontend/src/features/terminals/TerminalView.test.tsx

@@ -5,20 +5,44 @@
  * Under jsdom xterm's `term.open` may bail gracefully (no real layout engine),
  * so these tests assert the *wiring contract* (mounts without throwing, talks to
  * the gateway port, tears down on unmount) rather than xterm's visual rendering.
+ *
+ * The core lifecycle invariant tested here: unmounting the view (navigation /
+ * layout change) must **detach**, NEVER **close** — the backend PTY must survive
+ * so a running AI isn't cut off. Re-mounting with a known session re-attaches.
  */
 import { describe, it, expect, vi } from "vitest";
 import { render, screen, waitFor } from "@testing-library/react";
 
-import type { Gateways, TerminalGateway, TerminalHandle } from "@/ports";
+import type {
+  Gateways,
+  ReattachResult,
+  TerminalGateway,
+  TerminalHandle,
+} from "@/ports";
 import { MockTerminalGateway } from "@/adapters/mock";
 import { DIProvider } from "@/app/di";
 import { TerminalView } from "./TerminalView";
 
-function renderView(terminal: TerminalGateway, cwd = "/home/me/proj") {
+function makeHandle(overrides: Partial<TerminalHandle> = {}): TerminalHandle {
+  return {
+    sessionId: "s1",
+    write: vi.fn().mockResolvedValue(undefined),
+    resize: vi.fn().mockResolvedValue(undefined),
+    detach: vi.fn(),
+    close: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+function renderView(
+  terminal: TerminalGateway,
+  cwd = "/home/me/proj",
+  extra?: Partial<React.ComponentProps<typeof TerminalView>>,
+) {
   const gateways = { terminal } as unknown as Gateways;
   return render(
     <DIProvider gateways={gateways}>
-      <TerminalView cwd={cwd} />
+      <TerminalView cwd={cwd} {...extra} />
     </DIProvider>,
   );
 }
@@ -49,20 +73,13 @@ describe("TerminalView (with MockTerminalGateway)", () => {
   });
 
   it("consuming gateway output (onData) does not throw", async () => {
-    // A gateway that immediately pushes bytes to the consumer, exercising the
-    // gateway→term.write path. The component must swallow this safely even when
-    // xterm bailed under jsdom.
-    const handle: TerminalHandle = {
-      sessionId: "s1",
-      write: vi.fn().mockResolvedValue(undefined),
-      resize: vi.fn().mockResolvedValue(undefined),
-      close: vi.fn().mockResolvedValue(undefined),
-    };
+    const handle = makeHandle();
     const terminal: TerminalGateway = {
       openTerminal: vi.fn(async (_opts, onData) => {
         onData(new TextEncoder().encode("hello\r\n"));
         return handle;
       }),
+      reattach: vi.fn(),
     };
 
     expect(() => renderView(terminal)).not.toThrow();
@@ -71,21 +88,15 @@ describe("TerminalView (with MockTerminalGateway)", () => {
     });
   });
 
-  it("closes the opened handle on unmount (cleanup)", async () => {
+  it("DETACHES (does not close) the handle on unmount — the PTY must survive", async () => {
+    const detach = vi.fn();
     const close = vi.fn().mockResolvedValue(undefined);
-    const handle: TerminalHandle = {
-      sessionId: "s1",
-      write: vi.fn().mockResolvedValue(undefined),
-      resize: vi.fn().mockResolvedValue(undefined),
-      close,
-    };
+    const handle = makeHandle({ detach, close });
     const openTerminal = vi.fn(async () => handle);
-    const terminal: TerminalGateway = { openTerminal };
+    const terminal: TerminalGateway = { openTerminal, reattach: vi.fn() };
 
     const { unmount } = renderView(terminal);
 
-    // Only assert close-on-unmount if the gateway was actually opened (i.e.
-    // xterm.open did not bail in this jsdom run).
     await waitFor(() => {
       expect(openTerminal.mock.calls.length >= 0).toBe(true);
     });
@@ -95,11 +106,57 @@ describe("TerminalView (with MockTerminalGateway)", () => {
 
     if (wasOpened) {
       await waitFor(() => {
-        expect(close).toHaveBeenCalled();
+        expect(detach).toHaveBeenCalled();
       });
+      // The cardinal invariant: navigating away must NOT kill the PTY.
+      expect(close).not.toHaveBeenCalled();
     } else {
-      // Bailed render: unmount must still be clean (no throw, no close needed).
+      // Bailed render: unmount must still be clean (no close, no detach needed).
       expect(close).not.toHaveBeenCalled();
     }
   });
+
+  it("REATTACHES to an existing session instead of opening a new PTY", async () => {
+    const handle = makeHandle({ sessionId: "live-1" });
+    const reattach = vi.fn(
+      async (_sessionId: string, onData: (b: Uint8Array) => void) => {
+        onData(new TextEncoder().encode("scroll"));
+        const result: ReattachResult = {
+          handle,
+          scrollback: new TextEncoder().encode("history"),
+        };
+        return result;
+      },
+    );
+    const openTerminal = vi.fn(async () => handle);
+    const terminal: TerminalGateway = { openTerminal, reattach };
+
+    renderView(terminal, "/cwd", { sessionId: "live-1" });
+
+    await waitFor(() => {
+      // When xterm wired up, reattach must be used (with the known id) and a
+      // fresh open must NOT happen.
+      if (reattach.mock.calls.length > 0) {
+        expect(reattach.mock.calls[0][0]).toBe("live-1");
+        expect(openTerminal).not.toHaveBeenCalled();
+      }
+    });
+    expect(true).toBe(true);
+  });
+
+  it("persists a newly opened session id via onSessionId", async () => {
+    const handle = makeHandle({ sessionId: "new-99" });
+    const openTerminal = vi.fn(async () => handle);
+    const terminal: TerminalGateway = { openTerminal, reattach: vi.fn() };
+    const onSessionId = vi.fn();
+
+    renderView(terminal, "/cwd", { onSessionId });
+
+    await waitFor(() => {
+      if (openTerminal.mock.calls.length > 0) {
+        expect(onSessionId).toHaveBeenCalledWith("new-99");
+      }
+    });
+    expect(true).toBe(true);
+  });
 });