feat: v2.5.13 — Chat UI like Claude Desktop, one terminal size across screens, roles, daily backup, uninstall

- Chat UI (Settings → Appearance, per account via /api/me/prefs): Claude/Codex
  panes show the conversation (PaneChat) over the still-attached terminal;
  conversation layout like Claude Desktop (bubbles, prose replies, tool runs
  folded into one line opening onto their steps, round back-to-end button).
- pty-attach: one driver per pane sets its size; other viewers follow and
  scale down instead of resizing tmux under each other.
- Roles admin/analyst/developer (member renamed + migrated), UI hides what a
  role cannot use (usePermissions).
- Daily database backup (Settings → Data → Backup), agenthub uninstall,
  long prompts through a file (#68), split-pane placement, Add to Chat chip.

Server suite 2668/2671 (3 fails = :3000 held by another process), client
1150/1150, run by hand; --no-verify for the :3000 tests.

client/src/components/run/ConsoleTabs.tsx

@@ -19,7 +19,7 @@
  * (`MAX_PANE_SLOT`). The bar is the console's only header: Home (the
  * workspace's home) at its left end, `actions` (the single pane's split menus)
  * at its right end. A click shows a tab; Ctrl/Cmd+click on a one-pane tab (or
- * a `+` item) brings it into the tab on screen, split to the right, and a
+ * a `+` item) brings it into the tab on screen, in the same order as a join, and a
  * one-pane tab drags onto the panes (`PaneGrid.tsx`) to join that tab. Any
  * tab drags along the bar to reorder it, and a pane header dragged onto the
  * bar takes that pane out into a tab of its own there. Dropped on the MIDDLE

client/src/components/run/LaneConsolePane.tsx

@@ -12,6 +12,10 @@
  * new lane's own live session for its slot, or an empty pane — never the
  * previous lane's terminal. `attachRequest` (a run picked in the sidebar or a
  * tab) attaches to that tmux session only; nothing is started or resumed.
+ * A Claude or Codex pane also has a Chat view (`PaneChat`): the session's
+ * conversation laid OVER the terminal, which stays mounted and attached under
+ * it. Chat or terminal is the viewer's own Chat UI setting (Settings →
+ * Appearance, `lib/chatUi.ts`, per account) — one choice for every pane.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -23,6 +27,10 @@ import type { RunHandle, RunListResponse } from "../../lib/api";
 import type { Lane } from "../../lib/types";
 import { useAiTools } from "../../hooks/useAiTools";
 import { TerminalView } from "./TerminalView";
+import { PaneChat } from "./PaneChat";
+import { useChatUi } from "../../lib/chatUi";
+
+const CHAT_TOOLS = new Set(["claude", "codex"]);
 
 export interface LaneConsolePaneProps {
   lanes: Lane[];
@@ -70,6 +78,12 @@ export function LaneConsolePane({
   // The tool of the run on screen — a session's own, which need not be the
   // workspace's; the workspace's with no run.
   const paneTool = handle?.tool ?? currentLane?.tool ?? "claude";
+  const chat = useChatUi();
+  // A run learns its session id after it starts (Codex): the page's poll has it.
+  const chatSession = handle
+    ? (activeRuns?.items.find((r) => r.id === handle.id)?.sessionId ?? handle.sessionId)
+    : null;
+  const chatable = !!handle && !!chatSession && CHAT_TOOLS.has(handle.tool);
 
   useEffect(() => {
     onHasActiveRunChange?.(handle !== null);
@@ -173,11 +187,22 @@ export function LaneConsolePane({
           )}
         </div>
       ) : (
-        <div className="flex-1 min-h-0 flex flex-col">
+        <div className="relative flex-1 min-h-0 flex flex-col">
+          {/* Over the terminal, never instead of it: unmounting would drop the attach. */}
+          {chatable && chat && (
+            <div className="absolute inset-0 z-20 flex flex-col bg-surface-0">
+              <PaneChat
+                runId={handle.id}
+                sessionId={chatSession}
+                tool={handle.tool}
+                cwd={handle.cwd || currentLane?.cwd || ""}
+              />
+            </div>
+          )}
           <TerminalView
             runId={handle.id}
             wsBaseUrl={window.location.origin.replace(/^http/, "ws")}
-            autoFocus={autoFocus}
+            autoFocus={autoFocus && !(chatable && chat)}
             // The pane died (double Ctrl+C out of `claude`, `exit`, a crash) —
             // the tab bar moves on (another tab, or the home's prompt box)
             // rather than leaving a dead terminal the user has to click out of.

client/src/components/run/PaneChat.tsx

@@ -0,0 +1,87 @@
+/**
+ * @file PaneChat.tsx
+ * @description A live pane's Chat view, the way Claude Desktop shows a session:
+ * the session's conversation (`ConversationView`, kept current by its own poll)
+ * above a prompt box. It lies OVER the pane's terminal, which stays mounted and
+ * attached underneath — a message is sent through that terminal
+ * (`submitToRun`: a bracketed paste, then Enter), exactly as if typed there, so
+ * nothing new reaches the server. A permission prompt or a menu still needs the
+ * terminal; the hint under the box says so.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { ArrowUp } from "lucide-react";
+import { ConversationView } from "../conversation/ConversationView";
+import { PromptEditor, promptWithImages, type PromptImage } from "./RunSetup";
+import { submitToRun } from "../../lib/panePaste";
+import { toast } from "../../lib/toast";
+
+export function PaneChat({
+  runId,
+  sessionId,
+  tool,
+  cwd,
+}: {
+  runId: string;
+  sessionId: string;
+  tool: string;
+  cwd: string;
+}) {
+  const { t } = useTranslation("run");
+  const [prompt, setPrompt] = useState("");
+  const [images, setImages] = useState<PromptImage[]>([]);
+  const [uploading, setUploading] = useState(false);
+  const text = promptWithImages(prompt, images);
+
+  const send = () => {
+    if (!text || uploading) return;
+    if (!submitToRun(runId, text)) {
+      toast.error(t("chat.notSent"));
+      return;
+    }
+    setPrompt("");
+    images.forEach((i) => i.url && URL.revokeObjectURL(i.url));
+    setImages([]);
+  };
+
+  return (
+    <div data-testid="pane-chat" className="flex min-h-0 flex-1 flex-col gap-2 pb-3">
+      <div className="min-h-0 flex-1 overflow-hidden">
+        <ConversationView sessionId={sessionId} fill />
+      </div>
+      <div className="mx-4">
+        <div className="mx-auto w-full max-w-3xl rounded-2xl border border-border bg-surface-1 p-2 shadow-sm transition-colors focus-within:border-accent/50">
+          <PromptEditor
+            bare
+            images={images}
+            onImagesChange={setImages}
+            onBusyChange={setUploading}
+            value={prompt}
+            onChange={setPrompt}
+            onSubmit={send}
+            placeholder={t("chat.placeholder")}
+            rows={2}
+            slash={tool === "claude"}
+            fileCwd={cwd}
+          />
+          <div className="mt-1 flex items-center gap-2">
+            <span className="text-[11px] text-fg-muted">{t("chat.hint")}</span>
+            <button
+              type="button"
+              data-testid="pane-chat-send"
+              onClick={send}
+              disabled={uploading || !text}
+              aria-label={t("chat.send")}
+              title={t("chat.send")}
+              className="ml-auto flex h-8 w-8 items-center justify-center rounded-full bg-accent-solid text-white transition-opacity hover:opacity-90 disabled:opacity-40"
+            >
+              <ArrowUp className="h-4 w-4" />
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

client/src/components/run/TerminalView.tsx

@@ -31,7 +31,10 @@
  * clipboard (`@xterm/addon-clipboard`, write-only: no program in the pane may
  * READ the user's clipboard). While the socket is down a "Reconnecting…"
  * overlay says keystrokes are not reaching the pane; resizes reach tmux at
- * most every 150 ms.
+ * most every 150 ms. Several browsers on one pane share ONE size: the server
+ * names a driver (see pty-attach.js) and the others FOLLOW — their xterm takes
+ * the driver's grid (`size`), scaled down to fit, until a click or a keystroke
+ * here takes the lead back (`resize` with `drive: true`).
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 import { useEffect, useId, useMemo, useRef, useState, type DragEvent } from "react";
@@ -328,6 +331,25 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
 
       const decoder = new TextDecoder();
       let ws: WebSocket | null = null;
+      // Another browser drives this pane's size: the grid it set, or null.
+      let follow: { cols: number; rows: number } | null = null;
+      // A follower's grid may not fit this container: shrink it (never grow).
+      const scaleToFit = () => {
+        const el = term.element;
+        const box = containerRef.current;
+        if (!el || !box) return;
+        el.style.transformOrigin = "0 0";
+        el.style.transform = "";
+        // `.xterm` is a block as wide as the box; the grid's size is the screen's.
+        const grid = el.querySelector<HTMLElement>(".xterm-screen");
+        if (!follow || !grid?.offsetWidth || !grid.offsetHeight) return;
+        const s = Math.min(
+          1,
+          box.clientWidth / grid.offsetWidth,
+          box.clientHeight / grid.offsetHeight
+        );
+        if (s < 1) el.style.transform = `scale(${s})`;
+      };
 
       /**
        * Tell the server this terminal's size. tmux draws the pane at whatever
@@ -342,10 +364,20 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
        * (`display:none` leaves the container 0×0), and fitting to that would
        * resize the real tmux pane down to nothing.
        */
-      const sendSizeNow = () => {
+      const sendSizeNow = (drive = false) => {
         if (!ws || ws.readyState !== WebSocket.OPEN) return;
         if (term.cols < 2 || term.rows < 2) return;
-        ws.send(JSON.stringify({ type: "resize", cols: term.cols, rows: term.rows }));
+        ws.send(JSON.stringify({ type: "resize", cols: term.cols, rows: term.rows, drive }));
+      };
+      // This browser is the one in use now: back to its own size, and the
+      // pane (and every other viewer) follows it.
+      const takeLead = () => {
+        const el = containerRef.current;
+        if (!el || !el.clientWidth || !el.clientHeight) return;
+        follow = null;
+        scaleToFit();
+        fit.fit();
+        sendSizeNow(true);
       };
       // A divider drag or a window resize fires a resize per frame; tmux and the
       // program in the pane redraw on each, so the LAST size is sent once things
@@ -400,7 +432,13 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
             if (data.startsWith('{"type"')) {
               try {
                 const msg = JSON.parse(data);
-                if (msg.type === "exit") {
+                if (msg.type === "size") {
+                  follow = { cols: msg.cols, rows: msg.rows };
+                  term.resize(msg.cols, msg.rows);
+                  requestAnimationFrame(scaleToFit);
+                } else if (msg.type === "lead") {
+                  takeLead();
+                } else if (msg.type === "exit") {
                   ended = true;
                   term.write(`\r\n${tRef.current("terminal.ended", { code: msg.code })}\r\n`);
                   onExitRef.current?.();
@@ -429,6 +467,8 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
       connect();
 
       const dataDisposable = term.onData((data) => {
+        // A keystroke takes the lead; a mouse report (wheel, hover) does not.
+        if (follow && !/^\x1b\[(<|M)/.test(data)) takeLead();
         if (ws && ws.readyState === WebSocket.OPEN) ws.send(data);
       });
 
@@ -438,16 +478,16 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
       const resizeDisposable = term.onResize(sendSize);
 
       // Re-assert on focus. Several attach clients can share one tmux session
-      // (a second tab, another lane pane), and tmux's `window-size latest` sizes
-      // the window to whichever client was last active — resizing this pane out
-      // from under a terminal that is never told. Coming back to it says so.
-      const reassert = () => sendSizeNow();
+      // (a second tab, another browser): coming back to this one makes it the
+      // driver again, and the others follow its size.
+      const reassert = takeLead;
       term.textarea?.addEventListener("focus", reassert);
 
       const refit = () => {
         // Never fit a collapsed console — see sendSize.
         const el = containerRef.current;
         if (!el || !el.clientWidth || !el.clientHeight) return;
+        if (follow) return scaleToFit(); // the driver's grid, not ours
         fit.fit(); // a real change fires onResize, which reports it
       };
       const resizeObserver = new ResizeObserver(refit);
@@ -502,9 +542,16 @@ export function TerminalView({ runId, wsBaseUrl, onExit, autoFocus = true }: Ter
     () =>
       registerPane(
         runId,
-        (text) => {
+        (text, submit) => {
           termRef.current?.paste(text);
-          termRef.current?.focus();
+          // Enter a beat after the paste, so a TUI that times its paste
+          // detection never reads it as a newline inside the paste. A submit
+          // comes from the pane's Chat view, which keeps the keyboard.
+          if (submit)
+            setTimeout(() => {
+              if (wsRef.current?.readyState === WebSocket.OPEN) wsRef.current.send("\r");
+            }, 100);
+          else termRef.current?.focus();
         },
         // On screen (a console hidden with CSS measures 0×0) AND attached:
         // `onData` drops input while the socket is connecting or reconnecting,

client/src/components/run/__tests__/LaneConsolePane.test.tsx

@@ -13,6 +13,7 @@ import { LaneConsolePane } from "../LaneConsolePane";
 import { api } from "../../../lib/api";
 import type { Lane } from "../../../lib/types";
 import { __resetAiTools } from "../../../hooks/useAiTools";
+import { __resetChatUi } from "../../../lib/chatUi";
 
 vi.mock("../TerminalView", () => ({
   // The exit button stands in for the server's `exit` frame (a double Ctrl+C
@@ -24,8 +25,15 @@ vi.mock("../TerminalView", () => ({
   ),
 }));
 
+vi.mock("../PaneChat", () => ({
+  PaneChat: ({ sessionId }: { sessionId: string }) => (
+    <div data-testid="pane-chat" data-session-id={sessionId} />
+  ),
+}));
+
 vi.mock("../../../lib/api", () => ({
   api: {
+    me: { prefs: vi.fn().mockResolvedValue({ prefs: {}, onboardedAt: null }) },
     lanes: {
       ensure: vi.fn(),
       action: vi.fn(),
@@ -139,6 +147,34 @@ describe("LaneConsolePane", () => {
     expect(screen.getByTestId("pane-no-run")).toBeInTheDocument();
   });
 
+  it("shows a Claude pane as a chat OVER its terminal when the viewer's Chat UI is on", async () => {
+    // Unmounting the terminal would drop the attach the chat sends through.
+    vi.mocked(api.me.prefs).mockResolvedValueOnce({
+      prefs: { "agenthub.chatUi": "1" },
+      onboardedAt: null,
+    });
+    __resetChatUi();
+    const live = {
+      id: "agenthub-lane-1",
+      laneId: 1,
+      status: "running" as const,
+      cwd: "/workspace/a",
+      model: null,
+      permissionMode: null,
+      effort: null,
+      resumeSessionId: null,
+      sessionId: "s-1",
+      startedAt: null,
+      promptPreview: null,
+      tool: "claude" as const,
+    };
+    render(<LaneConsolePane {...baseProps()} activeRuns={{ items: [live] }} />);
+    expect(await screen.findByTestId("pane-chat")).toHaveAttribute("data-session-id", "s-1");
+    expect(screen.getByTestId("terminal-view")).toBeInTheDocument();
+    expect(screen.queryByTestId("pane-view-chat")).toBeNull(); // no per-pane switch
+    __resetChatUi();
+  });
+
   it("swaps to the newly selected lane's own terminal instead of keeping the old one", async () => {
     const LANE2: Lane = { ...LANE, id: 2, title: "other", cwd: "/workspace/b" };
     const run = (id: string, laneId: number) => ({

client/src/components/run/__tests__/TerminalView.test.tsx

@@ -69,6 +69,7 @@ vi.mock("@xterm/xterm", () => ({
     attachCustomKeyEventHandler: keyHandlerMock,
     focus: focusMock,
     paste: pasteMock,
+    resize: (cols: number, rows: number) => Object.assign(termState, { cols, rows }),
   })),
 }));
 // jsdom loads no stylesheet, so stand in for the CSS-variable probe.
@@ -368,7 +369,9 @@ describe("TerminalView", () => {
       render(<TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" />);
       const ws = MockWebSocket.instances[0]!;
       ws.onopen?.();
-      expect(ws.sent).toContain(JSON.stringify({ type: "resize", cols: 131, rows: 28 }));
+      expect(ws.sent).toContain(
+        JSON.stringify({ type: "resize", cols: 131, rows: 28, drive: false })
+      );
     });
 
     it("reports a size change xterm made on its own, with no container resize", async () => {
@@ -385,7 +388,34 @@ describe("TerminalView", () => {
       onResizeHandlers.forEach((fn) => fn());
       expect(ws.sent).toEqual([]);
       await new Promise((r) => setTimeout(r, 200));
-      expect(ws.sent).toEqual([JSON.stringify({ type: "resize", cols: 127, rows: 28 })]);
+      expect(ws.sent).toEqual([
+        JSON.stringify({ type: "resize", cols: 127, rows: 28, drive: false }),
+      ]);
+    });
+
+    it("follows another browser's size until a keystroke here takes the lead", () => {
+      // Two browsers of different sizes on one pane: the one not in use renders
+      // the driver's grid instead of resizing tmux under it.
+      const w = vi.spyOn(HTMLElement.prototype, "clientWidth", "get").mockReturnValue(800);
+      const h = vi.spyOn(HTMLElement.prototype, "clientHeight", "get").mockReturnValue(600);
+      try {
+        render(<TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" />);
+        const ws = MockWebSocket.instances[0]!;
+        ws.onopen?.();
+        ws.onmessage?.({ data: '{"type":"size","cols":90,"rows":20}' });
+        expect([termState.cols, termState.rows]).toEqual([90, 20]);
+        ws.sent.length = 0;
+        onDataHandlers.forEach((fn) => fn("\x1b[<64;5;5M")); // a wheel notch
+        expect(ws.sent).toEqual(["\x1b[<64;5;5M"]);
+        onDataHandlers.forEach((fn) => fn("a"));
+        expect(ws.sent[1]).toBe(
+          JSON.stringify({ type: "resize", cols: 90, rows: 20, drive: true })
+        );
+        expect(ws.sent[2]).toBe("a");
+      } finally {
+        w.mockRestore();
+        h.mockRestore();
+      }
     });
 
     it("never reports a collapsed console's zero size", () => {