hop2 0.11.76 → 0.11.78

package/hay/apps/server/src/rooms.ts

@@ -142,6 +142,18 @@ export type RoomSummary = {
 // 6MB still exceeds every reader: the deep-history replay asks 1.5MB, the
 // serialized attach reads the grid, and `hop restore` persists 64KB tails.
 // Override with HAY_SNAPSHOT_BUFFER_BYTES for deeper rings at GC's expense.
+// Output batching (see Room.queueOutput). HAY_OUTPUT_BATCH_MS=0 turns it off.
+const OUTPUT_BATCH_MS = (() => {
+  const env = Number(process.env.HAY_OUTPUT_BATCH_MS);
+  return Number.isFinite(env) && env >= 0 ? env : 2;
+})();
+const OUTPUT_BATCH_MAX_MS = 16;
+
+// DEC private modes worth restoring on adopt: cursor keys, mouse (any
+// flavour and encoding), focus events, alternate screen, bracketed paste,
+// cursor visibility.
+const TRACKED_DEC_MODES = new Set(["1", "25", "47", "1000", "1002", "1003", "1004", "1005", "1006", "1015", "1047", "1049", "2004"]);
+
 const MAX_BUFFER_SIZE = (() => {
   const env = Number(process.env.HAY_SNAPSHOT_BUFFER_BYTES);
   return Number.isFinite(env) && env > 0 ? env : 6_000_000;
@@ -321,6 +333,13 @@ export class Room extends EventEmitter {
   private mouseReporting = false;
   private mouseSgr = false;
   private cursorHidden = false;
+  // The DEC private modes an app set (alternate screen, mouse, focus,
+  // bracketed paste…), exactly. An app sets them once at startup; a host
+  // restart rebuilds the room from a bounded replay that no longer holds
+  // that moment, so the room forgot Codex was full-screen and the wheel
+  // scrolled the page instead of the app (2026-10-12). The host saves
+  // modePrefix() and puts it back in front of the replay on adopt.
+  private decModes = new Map<string, boolean>();
   private controlSequenceTail = "";
   private oscBuffer = "";
   private cleanupTimer: NodeJS.Timeout | null = null;
@@ -373,7 +392,7 @@ export class Room extends EventEmitter {
       this.updateTerminalState(data);
       this.startTuiGrid();
       this.answerTerminalQueriesIfHeadless(data);
-      this.broadcast({ type: "output", data });
+      this.queueOutput(data);
       this.emit("pty_output", { roomId: this.id, data, timestamp: now() });
     });
 
@@ -428,6 +447,9 @@ export class Room extends EventEmitter {
   }
 
   attachClient(info: ClientInfo, socket: SocketAdapter) {
+    // Output still waiting to go out belongs to the viewers already here;
+    // the newcomer's snapshot already contains it.
+    this.flushOutput();
     if (this.cleanupTimer) {
       clearTimeout(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -569,6 +591,9 @@ export class Room extends EventEmitter {
         // Catch-up: output that arrived while the snapshot was being
         // serialized. Appended INSIDE the snapshot payload so snapshot and
         // delta land as one atomic parse — no frame between reset and delta.
+        // Batched output not yet sent is behind the serialize marker too:
+        // flushing now routes it into this client's catch-up.
+        this.flushOutput();
         const catchUp = client.snapshotCatchUp.join("");
         socket.send(JSON.stringify({
           type: "snapshot",
@@ -678,10 +703,13 @@ export class Room extends EventEmitter {
 
     let nextMouseReporting = hasNewRis ? false : this.mouseReporting;
     let nextMouseSgr = hasNewRis ? false : this.mouseSgr;
+    const modesBefore = this.modePrefix();
+    if (hasNewRis) this.decModes.clear();
     while ((match = regex.exec(stateInput)) !== null) {
       const params = match[1].split(";").filter(Boolean);
       const mode = match[2];
       for (const param of params) {
+        if (TRACKED_DEC_MODES.has(param)) this.decModes.set(param, mode === "h");
         if (param === "25") {
           nextCursorHidden = mode === "l";
         } else if (param === "47" || param === "1047" || param === "1049") {
@@ -738,6 +766,9 @@ export class Room extends EventEmitter {
       stateChanged = true;
     }
 
+    const modesAfter = this.modePrefix();
+    if (modesAfter !== modesBefore) this.emit("modes", modesAfter);
+
     if (stateChanged) {
       this.emit("pty_state", {
         roomId: this.id,
@@ -1057,6 +1088,7 @@ export class Room extends EventEmitter {
   }
 
   private sendActiveSize(client: ClientState, ownerId: string) {
+    this.flushOutput();
     client.socket.send(
       JSON.stringify({
         type: "active_size",
@@ -1068,6 +1100,7 @@ export class Room extends EventEmitter {
   }
 
   private broadcastActiveSize(client: ClientState) {
+    this.flushOutput();
     // Broadcast to OTHER clients (not the one typing)
     const payload = JSON.stringify({
       type: "active_size",
@@ -1082,7 +1115,42 @@ export class Room extends EventEmitter {
     }
   }
 
+  /**
+   * Live output is sent in screen-sized messages, not one per pty read:
+   * Codex writes a redraw in ~10 pieces, so one wheel tick was ten
+   * WebSocket messages through the tunnel (321 for 30 ticks). Pieces that
+   * arrive within OUTPUT_BATCH_MS of each other go out together, capped at
+   * OUTPUT_BATCH_MAX_MS after the first so a steady stream still flows.
+   */
+  private pendingOutput: string[] = [];
+  private pendingOutputSince = 0;
+  private outputFlushTimer: NodeJS.Timeout | null = null;
+
+  private queueOutput(data: string) {
+    if (OUTPUT_BATCH_MS <= 0) { this.broadcast({ type: "output", data }); return; }
+    const t = now();
+    if (this.pendingOutput.length === 0) this.pendingOutputSince = t;
+    this.pendingOutput.push(data);
+    if (this.outputFlushTimer) clearTimeout(this.outputFlushTimer);
+    if (t - this.pendingOutputSince >= OUTPUT_BATCH_MAX_MS) { this.flushOutput(); return; }
+    this.outputFlushTimer = setTimeout(() => this.flushOutput(), OUTPUT_BATCH_MS);
+  }
+
+  private flushOutput() {
+    if (this.outputFlushTimer) { clearTimeout(this.outputFlushTimer); this.outputFlushTimer = null; }
+    if (this.pendingOutput.length === 0) return;
+    const data = this.pendingOutput.length === 1 ? this.pendingOutput[0] : this.pendingOutput.join("");
+    this.pendingOutput = [];
+    this.sendToClients({ type: "output", data });
+  }
+
   private broadcast(message: ServerMessage) {
+    // Anything else keeps its place after the output that preceded it.
+    if ((message as { type?: string }).type !== "output") this.flushOutput();
+    this.sendToClients(message);
+  }
+
+  private sendToClients(message: ServerMessage) {
     const payload = JSON.stringify(message);
     const isOutput = (message as { type?: string }).type === "output";
     for (const client of this.clients.values()) {
@@ -1204,6 +1272,22 @@ export class Room extends EventEmitter {
   // omit cells until the app happens to repaint (for example, on scroll).
   // Begin tracking at TUI entry; dependency loading is shared and normally
   // finishes first, but the callback covers a TUI that starts immediately.
+  /**
+   * The escape sequences that put a fresh terminal into this app's current
+   * modes: the alternate screen first (so the rest apply to it), then each
+   * mode that is on, and a hidden cursor. "" for a plain shell.
+   */
+  modePrefix(): string {
+    let alt = "", rest = "";
+    for (const [mode, on] of this.decModes) {
+      if (mode === "25") { if (!on) rest += "\x1b[?25l"; continue; }
+      if (!on) continue;
+      if (mode === "1049" || mode === "1047" || mode === "47") alt = `\x1b[?${mode}h`;
+      else rest += `\x1b[?${mode}h`;
+    }
+    return alt + rest;
+  }
+
   private startTuiGrid() {
     if (!SERIALIZED_ATTACH_ENABLED || this.grid || this.gridStartPending || this.gridUnavailable || this.ended) return;
     if (!this.alternateScreen && !this.mouseReporting) return;
@@ -1244,7 +1328,11 @@ export class Room extends EventEmitter {
             const nl = tail.indexOf("\n");
             if (nl !== -1 && nl < 8192) tail = tail.slice(nl + 1);
           }
-          this.grid.write(tail);
+          // The tail rarely reaches back to where the app set its modes
+          // (an adopted room's saved prefix sits at the very front of the
+          // ring): put the room's current modes first, or the grid serializes
+          // a full-screen app as a plain shell. The tail's own changes win.
+          this.grid.write(this.modePrefix() + tail);
         }
       }
     }

package/hay/apps/server/test/outputBatch.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { RoomManager } from "../src/rooms";
+import type { PtyFactory } from "../src/pty";
+
+class FakePty {
+  private handlers: Array<(data: string) => void> = [];
+  onData(handler: (data: string) => void) { this.handlers.push(handler); }
+  onExit() {}
+  emit(data: string) { for (const h of this.handlers) h(data); }
+  write() {}
+  resize() {}
+  kill() {}
+}
+class FakeSocket {
+  messages: Array<{ type: string; [k: string]: unknown }> = [];
+  send(data: string) { this.messages.push(JSON.parse(data)); }
+  onMessage() {}
+  onClose() {}
+  onError() {}
+  isOpen() { return true; }
+  close() {}
+}
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("live output batching", () => {
+  it("pieces of one redraw go out as one message, in order", async () => {
+    const pty = new FakePty();
+    const room = new RoomManager((() => pty) as unknown as PtyFactory).getRoom("b", { cols: 80, rows: 24 }, "/tmp");
+    const sock = new FakeSocket();
+    room.attachClient({ id: "a", name: "A", colorIndex: 0, cols: 80, rows: 24, nudge: false }, sock as never);
+    await sleep(50);
+    sock.messages = [];
+    for (const piece of ["\x1b[H", "row one\r\n", "row two\r\n", "\x1b[?25h"]) pty.emit(piece);
+    await sleep(30);
+    const out = sock.messages.filter((m) => m.type === "output");
+    expect(out).toHaveLength(1);
+    expect(out[0].data).toBe("\x1b[Hrow one\r\nrow two\r\n\x1b[?25h");
+  });
+
+  it("a steady stream still flows (capped wait)", async () => {
+    const pty = new FakePty();
+    const room = new RoomManager((() => pty) as unknown as PtyFactory).getRoom("s", { cols: 80, rows: 24 }, "/tmp");
+    const sock = new FakeSocket();
+    room.attachClient({ id: "a", name: "A", colorIndex: 0, cols: 80, rows: 24, nudge: false }, sock as never);
+    await sleep(50);
+    sock.messages = [];
+    const t0 = Date.now();
+    while (Date.now() - t0 < 60) { pty.emit("x"); await sleep(1); }
+    // Without the cap, pieces 1 ms apart would be held until the stream stopped.
+    expect(sock.messages.filter((m) => m.type === "output").length).toBeGreaterThan(1);
+  });
+
+  it("output pending when a second viewer attaches reaches the first, and isn't repeated to the second", async () => {
+    const pty = new FakePty();
+    const room = new RoomManager((() => pty) as unknown as PtyFactory).getRoom("j", { cols: 80, rows: 24 }, "/tmp");
+    const first = new FakeSocket();
+    room.attachClient({ id: "a", name: "A", colorIndex: 0, cols: 80, rows: 24, nudge: false }, first as never);
+    await sleep(50);
+    first.messages = [];
+    pty.emit("PENDING-BEFORE-JOIN");
+    const second = new FakeSocket();
+    room.attachClient({ id: "b", name: "B", colorIndex: 1, cols: 80, rows: 24, nudge: false }, second as never);
+    expect(first.messages.some((m) => m.type === "output" && String(m.data).includes("PENDING-BEFORE-JOIN"))).toBe(true);
+    await sleep(50);
+    expect(second.messages.some((m) => m.type === "output" && String(m.data).includes("PENDING-BEFORE-JOIN"))).toBe(false);
+  });
+});

package/hay/apps/server/test/roomModes.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { RoomManager } from "../src/rooms";
+import type { PtyFactory } from "../src/pty";
+
+class FakePty {
+  private handlers: Array<(data: string) => void> = [];
+  onData(handler: (data: string) => void) { this.handlers.push(handler); }
+  onExit() {}
+  emit(data: string) { for (const h of this.handlers) h(data); }
+  write() {}
+  resize() {}
+  kill() {}
+}
+
+describe("terminal modes a room remembers", () => {
+  it("a room reports the DEC modes its app set, alternate screen first", () => {
+    const pty = new FakePty();
+    const manager = new RoomManager((() => pty) as unknown as PtyFactory);
+    const room = manager.getRoom("codex", { cols: 80, rows: 24 }, "/tmp");
+    const seen: string[] = [];
+    room.on("modes", (p: string) => seen.push(p));
+    pty.emit("\x1b[?2004h\x1b[?1004h\x1b[?1049h\x1b[?1003h\x1b[?1006h\x1b[?25l hello");
+    expect(room.modePrefix()).toBe("\x1b[?1049h\x1b[?2004h\x1b[?1004h\x1b[?1003h\x1b[?1006h\x1b[?25l");
+    expect(seen.at(-1)).toBe(room.modePrefix());
+    pty.emit("\x1b[?1003l\x1b[?1049l");
+    expect(room.modePrefix()).toBe("\x1b[?2004h\x1b[?1004h\x1b[?1006h\x1b[?25l");
+    pty.emit("\x1bc");
+    expect(room.modePrefix()).toBe("");
+  });
+});

package/hay/apps/server/test/rooms.test.ts

@@ -146,7 +146,7 @@ describe("Room", () => {
     expect(readMessages(phone).some((m) => m.type === "active_size" && m.clientId === "phone")).toBe(true);
   });
 
-  it("broadcasts pty output to all clients", () => {
+  it("broadcasts pty output to all clients", async () => {
     let ptyInstance: FakePty | null = null;
     const factory: PtyFactory = () => {
       ptyInstance = new FakePty() as unknown as FakePty;
@@ -162,6 +162,7 @@ describe("Room", () => {
     room.attachClient({ id: "b", name: "Blake", colorIndex: 1, cols: 80, rows: 24 }, socketB);
 
     ptyInstance?.emit("hello");
+    await new Promise((r) => setTimeout(r, 20)); // output is batched (Room.queueOutput)
 
     const outputsA = findMessages(socketA, "output");
     const outputsB = findMessages(socketB, "output");
@@ -962,6 +963,7 @@ describe("Room", () => {
       expect(String(snapshot.data)).toContain("LATE-MARKER-XYZ");
       // After the snapshot the stream flows live again, no duplication.
       pty().emit("AFTER-MARKER\r\n");
+      await new Promise((r) => setTimeout(r, 20)); // output is batched
       const after = readMessages(socket).filter((m) => m.type === "output");
       expect(after.some((m) => String(m.data).includes("AFTER-MARKER"))).toBe(true);
       expect(after.some((m) => String(m.data).includes("LATE-MARKER-XYZ"))).toBe(false);

package/hay/apps/web/src/App.tsx

@@ -49,6 +49,8 @@ import {
 } from "./utils/paneTree";
 import { ViewsPanel, hasUnseenViews, loadViewsSeen } from "./components/ViewsPanel";
 import type { ViewsSummary } from "./utils/switcherModel";
+import { isAppCtrlEnter, isFullscreenChord } from "./utils/fullscreenChord";
+import { isLocalLinkUrl, localLinkFailed, localWsBase, startLocalLink } from "./utils/localLink";
 
 const createRoomId = () => `room-${Math.random().toString(36).slice(2, 7)}`;
 
@@ -87,6 +89,9 @@ const getLocationRoom = () => {
 const buildSessionPath = (sessionName: string) => `/s/${encodeURIComponent(sessionName)}/`;
 
 const resolveWsUrl = () => {
+  // On the machine hop runs on, terminal sockets skip the tunnel.
+  const local = localWsBase();
+  if (local) return local;
   // Check for hop session config (when embedded in hop)
   const hopSession = (window as unknown as { __HOP_SESSION__?: { wsUrl?: string } }).__HOP_SESSION__;
   if (hopSession?.wsUrl) {
@@ -1760,7 +1765,7 @@ const App = () => {
     // dark) then match the screen instead of a guess.
     const surface = resolveTerminalTheme(themeMode);
     const hex = (c?: string) => (c || "").replace("#", "").slice(0, 6);
-    const url = `${wsUrl}?room=${encodeURIComponent(nextSession.room)}&name=${encodeURIComponent(
+    const url = `${wsUrl}${wsUrl.includes("?") ? "&" : "?"}room=${encodeURIComponent(nextSession.room)}&name=${encodeURIComponent(
       nextSession.name
     )}&cols=${cols}&rows=${rows}&replay=${replay}&bg=${hex(surface.background)}&fg=${hex(surface.foreground)}&device=${encodeURIComponent(resolveDeviceKey())}`;
 
@@ -1770,6 +1775,9 @@ const App = () => {
 
     const ws = new WebSocket(url);
     wsRef.current = ws;
+    const viaLocalLink = isLocalLinkUrl(url);
+    let opened = false;
+    ws.addEventListener("open", () => { opened = true; });
     // When this socket began CONNECTING — the watchdog uses it to catch a
     // handshake that hangs (accepted TCP, WS upgrade never completes through
     // the tunnel): it fires no open/close/error, so nothing else can notice.
@@ -2042,6 +2050,9 @@ const App = () => {
     });
 
     ws.addEventListener("close", () => {
+      // The fast path refused or vanished: fall back to the tunnel, which
+      // the reconnect below then uses.
+      if (viaLocalLink && !opened) localLinkFailed();
       if (connectionNonce !== connectNonceRef.current) {
         return;
       }
@@ -2069,6 +2080,11 @@ const App = () => {
     });
   };
 
+  // Once the same-machine fast path answers, reconnect onto it.
+  useEffect(() => {
+    startLocalLink(() => setReconnectToken((value) => value + 1));
+  }, []);
+
   useEffect(() => {
     if (!session || !terminalReady) {
       return;
@@ -2329,13 +2345,21 @@ const App = () => {
     terminal.attachCustomKeyEventHandler((event) => {
       // ⌘⏎ leaves full screen for the wall — the mirror of ⌘⏎ on a wall
       // tile entering it. One chord toggles the mode from either side.
-      if (event.key === 'Enter' && (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey) {
+      // On a Mac only ⌘⏎ — Ctrl⏎ goes to the app (see fullscreenChord.ts).
+      if (isFullscreenChord(event)) {
         if (event.type === 'keydown') {
           event.preventDefault();
           setSwitcherOpen(true);
         }
         return false;
       }
+      if (isAppCtrlEnter(event) && (remoteKbdEnhancedRef.current || foregroundIsClaude())) {
+        if (event.type === 'keydown') {
+          event.preventDefault();
+          handleUserInput('\x1b[13;5u');
+        }
+        return false;
+      }
       // Long-press SPACE = voice input — shared controller; see voiceHold.ts.
       {
         const verdict = voiceHoldRef.current?.handleKey(event);

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -37,6 +37,7 @@ import {
   type SwitcherSortMode,
   insertAfter, describeAccount, type AgentHome, type AgentHomes } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
+import { isAppCtrlEnter, isFullscreenChord } from "../utils/fullscreenChord";
 import { DigestCard } from "./DigestCard";
 import { hasUnseenViews, loadViewsSeen } from "./ViewsPanel";
 
@@ -693,10 +694,15 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
         if (ev.type === "keydown") sendInputRef.current?.("\x1b[13;2u");
         return false;
       }
-      if ((ev.metaKey || ev.ctrlKey) && !ev.altKey && !ev.shiftKey && ev.key === "Enter") {
+      // On a Mac only ⌘⏎ — Ctrl⏎ goes to the app (see fullscreenChord.ts).
+      if (isFullscreenChord(ev)) {
         if (ev.type === "keydown") onFullscreenRef.current();
         return false;
       }
+      if (isAppCtrlEnter(ev) && (kbdEnhancedRef.current || looksLikeClaude())) {
+        if (ev.type === "keydown") sendInputRef.current?.("\x1b[13;5u");
+        return false;
+      }
       if ((ev.metaKey || ev.ctrlKey) && !ev.altKey && !ev.shiftKey && ev.key === ".") {
         if (ev.type === "keydown") onUnfocusRef.current();
         return false;
@@ -2584,12 +2590,12 @@ export const SessionSwitcher = ({
 
   const forkSession = async (s: SwitcherSession, target?: "claude" | "codex") => {
     setSheet(null);
-    onNotice(target ? `Handing off to ${target === "codex" ? "Codex" : "Claude"}…` : "Forking…");
+    onNotice(target ? `Condensing for ${target === "codex" ? "Codex" : "Claude"}…` : "Forking…");
     try {
       const res = await fetch("/api/sessions/fork", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ internalName: sessionKey(s), ...(target ? { target } : {}) })
+        body: JSON.stringify({ internalName: sessionKey(s), ...(target ? { target, condense: true } : {}) })
       });
       const data = await res.json().catch(() => ({} as { error?: string; name?: string; internalName?: string; kind?: string; extract?: { turns?: number; bytes?: number } }));
       if (!res.ok) {
@@ -3755,21 +3761,19 @@ export const SessionSwitcher = ({
                 <button type="button" onClick={() => { void forkSession(sheetSession); }}>
                   Fork session
                 </button>
-                {/* Crossing tools: the conversation is extracted to a document
-                    the new agent reads first (context handoff, not a resume).
-                    Offered for every terminal — the daemon knows what a
-                    restored session runs better than the process name here —
-                    minus the tool this one is visibly running already. */}
-                {sheetSession.type !== "port" && appLabel(sheetSession) !== "codex" && (
-                  <button type="button" onClick={() => { void forkSession(sheetSession, "codex"); }}>
-                    Continue in Codex…
-                  </button>
-                )}
-                {sheetSession.type !== "port" && appLabel(sheetSession) !== "claude" && (
-                  <button type="button" onClick={() => { void forkSession(sheetSession, "claude"); }}>
-                    Continue in Claude…
+                {/* Continue in an agent: the conversation is condensed to a
+                    document the new agent reads first (a context handoff, not
+                    a resume). Into the OTHER tool that is the only way across;
+                    into the SAME tool it is a fresh start without the full,
+                    context-heavy history. Offered for every terminal — the
+                    daemon knows what a restored session runs better than the
+                    process name here. */}
+                {sheetSession.type !== "port" && (["claude", "codex"] as const).map((target) => (
+                  <button key={target} type="button" onClick={() => { void forkSession(sheetSession, target); }}>
+                    {appLabel(sheetSession) === target ? "Continue in fresh " : "Continue in "}
+                    {target === "codex" ? "Codex" : "Claude"}…
                   </button>
-                )}
+                ))}
                 <button
                   type="button"
                   onClick={() => {

package/hay/apps/web/src/utils/fullscreenChord.ts

@@ -0,0 +1,18 @@
+// The full-screen ⇄ wall chord inside a terminal. On a Mac it is ⌘⏎ only:
+// Ctrl⏎ belongs to the app (Claude Code binds it), and hop taking it meant
+// the keystroke never arrived. Elsewhere there is no ⌘, so Ctrl⏎ stays.
+export const IS_MAC = typeof navigator !== "undefined"
+  && /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent || "");
+
+type Chord = { key: string; metaKey: boolean; ctrlKey: boolean; altKey: boolean; shiftKey: boolean };
+
+export function isFullscreenChord(ev: Chord, mac = IS_MAC): boolean {
+  if (ev.key !== "Enter" || ev.altKey || ev.shiftKey) return false;
+  return mac ? ev.metaKey && !ev.ctrlKey : ev.metaKey || ev.ctrlKey;
+}
+
+/** Ctrl⏎ passed to the app: CSI-u (13;5u), since xterm.js would send a bare \r. */
+export function isAppCtrlEnter(ev: Chord, mac = IS_MAC): boolean {
+  return ev.key === "Enter" && ev.ctrlKey && !ev.metaKey && !ev.altKey && !ev.shiftKey
+    && !isFullscreenChord(ev, mac);
+}

package/hay/apps/web/src/utils/localLink.ts

@@ -0,0 +1,101 @@
+// Same-machine fast path. On the Mac hop runs on, a page opened through the
+// public hostname still sent every keystroke and scroll tick through
+// Cloudflare and back (70–240 ms, spikes past 1 s) to a daemon a
+// millisecond away. The daemon hands this login a ticket over the tunnel
+// (/api/local-link); if a WebSocket to 127.0.0.1 accepts it, terminal
+// sockets attach there instead. Everything else (API calls, the page itself)
+// stays on the public hostname. Anywhere but that Mac the probe fails and
+// nothing changes.
+
+// Chrome asks once before a public page may reach this machine ("apps and
+// services on this device"); the probe waits while that prompt is up. It runs
+// beside the tunnel connection, so waiting costs nothing.
+const PROBE_TIMEOUT_MS = 120_000;
+const RETRY_AFTER_FAILURE_MS = 30_000;
+const OPT_OUT_KEY = "hop.localLink"; // "off" disables the fast path in this browser
+
+let localBase: string | null = null;
+let probing = false;
+let retryTimer = 0;
+let onFound: (() => void) | null = null;
+
+export const isLocalLinkUrl = (url: string) => /^ws:\/\/127\.0\.0\.1:\d+\//.test(url);
+
+// The ws base terminal sockets should use instead of the page's own host,
+// or null to use the page's host.
+export const localWsBase = () => localBase;
+
+export function localLinkEligible(
+  loc: { protocol: string; hostname: string } = window.location,
+  ua: string = navigator.userAgent,
+  touchPoints: number = navigator.maxTouchPoints || 0
+) {
+  if (loc.protocol !== "https:") return false; // already local, or a dev server
+  if (/^(localhost|127\.0\.0\.1|\[::1\])$/i.test(loc.hostname)) return false;
+  // Phones and tablets are never the machine hop runs on (iPadOS reports
+  // itself as a Mac, but with touch points).
+  if (/iPhone|iPad|Android|Mobile/i.test(ua)) return false;
+  if (/Macintosh/.test(ua) && touchPoints > 1) return false;
+  try { if (localStorage.getItem(OPT_OUT_KEY) === "off") return false; } catch { /* storage blocked */ }
+  return true;
+}
+
+function probe(port: number, ticket: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    let done = false;
+    let sock: WebSocket;
+    const finish = (ok: boolean) => {
+      if (done) return;
+      done = true;
+      window.clearTimeout(timer);
+      try { sock.close(); } catch { /* already closed */ }
+      resolve(ok);
+    };
+    const timer = window.setTimeout(() => finish(false), PROBE_TIMEOUT_MS);
+    try {
+      sock = new WebSocket(`ws://127.0.0.1:${port}/ws?token=${encodeURIComponent(ticket)}&probe=1`);
+    } catch {
+      finish(false);
+      return;
+    }
+    sock.onmessage = (ev) => finish(ev.data === "ok");
+    sock.onerror = () => finish(false);
+    sock.onclose = () => finish(false);
+  });
+}
+
+async function attempt() {
+  if (probing || localBase) return;
+  probing = true;
+  try {
+    const res = await fetch("/api/local-link", { credentials: "same-origin", cache: "no-store" });
+    if (!res.ok) return;
+    const body = (await res.json()) as { port?: number; ticket?: string };
+    if (!Number.isInteger(body.port) || typeof body.ticket !== "string") return;
+    if (!(await probe(body.port as number, body.ticket))) return;
+    localBase = `ws://127.0.0.1:${body.port}/ws?token=${encodeURIComponent(body.ticket)}`;
+    onFound?.();
+  } catch {
+    /* no fast path; the tunnel works as before */
+  } finally {
+    probing = false;
+  }
+}
+
+// Probe once; `found` runs when terminal sockets should reconnect to use the
+// fast path.
+export function startLocalLink(found: () => void) {
+  onFound = found;
+  if (!localLinkEligible()) return;
+  void attempt();
+}
+
+// A terminal socket to the fast path closed before it opened (the daemon
+// restarted and forgot the ticket, or it stopped): use the tunnel, and look
+// again a little later with a fresh ticket.
+export function localLinkFailed() {
+  if (!localBase) return;
+  localBase = null;
+  window.clearTimeout(retryTimer);
+  retryTimer = window.setTimeout(() => void attempt(), RETRY_AFTER_FAILURE_MS);
+}

package/hay/apps/web/test/fullscreenChord.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { isAppCtrlEnter, isFullscreenChord } from "../src/utils/fullscreenChord";
+
+const key = (mods: Partial<{ metaKey: boolean; ctrlKey: boolean; altKey: boolean; shiftKey: boolean }>, k = "Enter") =>
+  ({ key: k, metaKey: false, ctrlKey: false, altKey: false, shiftKey: false, ...mods });
+
+describe("full-screen chord", () => {
+  it("on a Mac only ⌘⏎ toggles; Ctrl⏎ is the app's", () => {
+    expect(isFullscreenChord(key({ metaKey: true }), true)).toBe(true);
+    expect(isFullscreenChord(key({ ctrlKey: true }), true)).toBe(false);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }), true)).toBe(true);
+  });
+  it("without ⌘ (Windows/Linux) Ctrl⏎ still toggles", () => {
+    expect(isFullscreenChord(key({ ctrlKey: true }), false)).toBe(true);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }), false)).toBe(false);
+  });
+  it("other chords are untouched", () => {
+    expect(isFullscreenChord(key({ metaKey: true, shiftKey: true }), true)).toBe(false);
+    expect(isFullscreenChord(key({}), true)).toBe(false);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }, "a"), true)).toBe(false);
+  });
+});

package/hay/apps/web/test/localLink.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { isLocalLinkUrl, localLinkEligible } from "../src/utils/localLink";
+
+const MAC = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0 Safari/537.36";
+const IPHONE = "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148";
+const pub = { protocol: "https:", hostname: "hop.zhoulab.io" };
+
+describe("same-machine fast path", () => {
+  it("is tried from a desktop browser on the public hostname", () => {
+    expect(localLinkEligible(pub, MAC, 0)).toBe(true);
+  });
+  it("is not tried from a phone or an iPad posing as a Mac", () => {
+    expect(localLinkEligible(pub, IPHONE, 5)).toBe(false);
+    expect(localLinkEligible(pub, MAC, 5)).toBe(false);
+  });
+  it("is not tried when the page is already local", () => {
+    expect(localLinkEligible({ protocol: "http:", hostname: "localhost" }, MAC, 0)).toBe(false);
+    expect(localLinkEligible({ protocol: "https:", hostname: "127.0.0.1" }, MAC, 0)).toBe(false);
+  });
+  it("recognises a fast-path socket url", () => {
+    expect(isLocalLinkUrl("ws://127.0.0.1:13575/ws?token=ll_x&room=a")).toBe(true);
+    expect(isLocalLinkUrl("wss://hop.zhoulab.io/ws?room=a")).toBe(false);
+  });
+});

package/hop

@@ -802,7 +802,18 @@ async function withLifecycleLock(op, fn, { waitMs = 120_000, onWait } = {}) {
 }
 // Marker so the authenticator setup QR is only shown on first run (UX only; no auth logic).
 const AUTH_QR_SHOWN_FILE = path.join(HOME_DIR, '.auth_qr_shown');
-const HAY_HOST_READY_TIMEOUT_MS = parsePositiveIntEnv('HOP_HAY_HOST_READY_TIMEOUT_MS', 5000);
+// A keeper-backed host re-adopts every running terminal (replaying each
+// screen) BEFORE it opens its port. With 30 rooms that took ~8 s, then ~41 s
+// once one replay timed out (2026-10-12), so first a 5 s and then a 25 s
+// limit killed each new host mid-adoption and spawned the next — a restart
+// loop that left hop with no host, and took the daemon down with it ("Fatal:
+// Hay host did not open its port in time") while a `hop restore` was in
+// flight, which the CLI reported as "socket hang up". This is now a ceiling,
+// not the expected wait: the spawner keeps waiting while the host process is
+// alive (see waitForHayHostPort), gives up early only once it has died, and
+// refreshes the spawn lock as it waits so a rival spawner never mistakes a
+// long adoption for a stale lock.
+const HAY_HOST_READY_TIMEOUT_MS = parsePositiveIntEnv('HOP_HAY_HOST_READY_TIMEOUT_MS', 180000);
 const HAY_HOST_DISCOVERY_CACHE_MS = parsePositiveIntEnv('HOP_HAY_HOST_DISCOVERY_CACHE_MS', 10000);
 const HAY_HOST_HOME_HASH = crypto.createHash('sha256').update(path.resolve(HOME_DIR)).digest('hex').slice(0, 24);
 const HAY_HOST_HOME_FLAG = `--hop-home-hash=${HAY_HOST_HOME_HASH}`;
@@ -9706,6 +9717,27 @@ async function stopExternalHayHostProcess(hostState, timeoutMs = 1500) {
     return !isProcessAlive(pid);
 }
 
+// Wait for a freshly spawned host to open its port. Adopting a big fleet from
+// the pty-keeper can take a minute or more, so the wait is bounded by the
+// host's LIFE first and the ceiling second: a host that dies returns at once
+// instead of burning the whole ceiling, and one still working keeps the spawn
+// lock's mtime fresh so a concurrent spawner (30 s staleness rule) never calls
+// the lock stale and starts a rival host mid-adoption.
+async function waitForHayHostPort(started, ceilingMs) {
+    const deadline = Date.now() + ceilingMs;
+    let lastLockTouch = 0;
+    while (Date.now() < deadline) {
+        if (await waitForPort(started.port, '127.0.0.1', 1000, 120)) return true;
+        if (!isProcessAlive(started.pid)) return false;
+        if (Date.now() - lastLockTouch > 5000) {
+            lastLockTouch = Date.now();
+            const now = new Date();
+            try { fs.utimesSync(HAY_HOST_SPAWN_LOCK, now, now); } catch (e) { /* lock gone — nothing to refresh */ }
+        }
+    }
+    return false;
+}
+
 function markExternalHayHostResponsive(host) {
     const recovered = hayHostProbeFailures.recordSuccess(Number(host?.pid));
     if (recovered) {
@@ -9832,6 +9864,9 @@ async function ensureExternalHayHostReadyOnce() {
                 if (spawned && isProcessAlive(spawned.pid) && await probeExternalHayHostFromHost(spawned, 1500)) {
                     return markExternalHayHostResponsive(spawned);
                 }
+                // The winner releases the lock on success and failure alike;
+                // once it is gone there is nothing left to wait for.
+                if (!fs.existsSync(HAY_HOST_SPAWN_LOCK)) break;
             }
             // Winner never delivered — fall through and spawn ourselves.
         }
@@ -9917,10 +9952,13 @@ async function ensureExternalHayHostReadyOnce() {
         throw new Error(`Hay host failed to start; see ${hayHostLogFile}`);
     }
 
-    const ready = await waitForPort(started.port, '127.0.0.1', HAY_HOST_READY_TIMEOUT_MS, 120);
+    const ready = await waitForHayHostPort(started, HAY_HOST_READY_TIMEOUT_MS);
     if (!ready) {
+        const died = !isProcessAlive(started.pid);
         await stopExternalHayHostProcess(started);
-        throw new Error(`Hay host did not open its port in time; see ${hayHostLogFile}`);
+        throw new Error(died
+            ? `Hay host (pid ${started.pid}) exited before opening its port; see ${hayHostLogFile}`
+            : `Hay host did not open its port within ${Math.round(HAY_HOST_READY_TIMEOUT_MS / 1000)}s (still adopting its terminals? HOP_HAY_HOST_READY_TIMEOUT_MS raises the ceiling); see ${hayHostLogFile}`);
     }
     const healthy = await probeExternalHayHostFromHost(started, 1500);
     if (!healthy) {
@@ -10476,6 +10514,33 @@ function isDirectLoopbackRequest(req) {
     return addr === '127.0.0.1' || addr === '::1' || addr === '::ffff:127.0.0.1';
 }
 
+// Same-machine fast path. A browser on this Mac that opens hop through the
+// public hostname pays Cloudflare's round trip on every keystroke and scroll
+// tick (70–240 ms, spikes past 1 s, measured 2026-10-13) while the daemon is
+// a millisecond away. The page asks for a ticket over the tunnel and, if it
+// can open a WebSocket to 127.0.0.1 with it, attaches there instead. A ticket
+// stands in for the login that asked for it and only on a DIRECT loopback
+// connection, so a copy is worthless off this machine; revoking the login
+// ends its tickets too. Kept in memory: a daemon restart drops them, and the
+// page falls back to the tunnel and asks again.
+const LOCAL_LINK_TTL_MS = 12 * 3600 * 1000;
+const localLinkTickets = new Map(); // ticket -> { token, expiresAt }
+function issueLocalLinkTicket(sessionToken) {
+    const now = Date.now();
+    for (const [t, rec] of localLinkTickets) if (rec.expiresAt <= now) localLinkTickets.delete(t);
+    while (localLinkTickets.size >= 500) localLinkTickets.delete(localLinkTickets.keys().next().value);
+    const ticket = 'll_' + crypto.randomBytes(24).toString('base64url');
+    localLinkTickets.set(ticket, { token: sessionToken, expiresAt: now + LOCAL_LINK_TTL_MS });
+    return ticket;
+}
+function verifyLocalLinkTicket(ticket) {
+    const rec = localLinkTickets.get(ticket);
+    if (!rec) return null;
+    const session = rec.expiresAt > Date.now() ? authSessions.verify(rec.token) : null;
+    if (!session) localLinkTickets.delete(ticket);
+    return session;
+}
+
 // Every way a request can prove itself, in one place.
 //   cookie — a per-device login session (browser, hop-ios)
 //   token  — Authorization: Bearer <device session token>
@@ -10502,6 +10567,10 @@ function authenticateRequest(req, cookies, { queryToken = null } = {}) {
     }
     if (typeof queryToken === 'string' && queryToken) {
         if (queryToken === SESSION_SECRET && isDirectLoopbackRequest(req)) return { ok: true, via: 'ipc', session: null };
+        if (queryToken.startsWith('ll_') && isDirectLoopbackRequest(req)) {
+            const session = verifyLocalLinkTicket(queryToken);
+            if (session) return { ok: true, via: 'cookie', session };
+        }
         if (isAuthSessionToken(queryToken)) {
             const session = authSessions.verify(queryToken);
             if (session) return { ok: true, via: 'token', session };
@@ -10846,6 +10915,21 @@ function startAuthProxy(authEmitter) {
             return;
         }
 
+        // API: a ticket for the same-machine fast path (see issueLocalLinkTicket).
+        // Browsers only — it stands in for the login cookie.
+        if (parsedUrl.pathname === '/api/local-link' && req.method === 'GET') {
+            setNoCache(res);
+            const token = cookies[SESSION_COOKIE_NAME];
+            if (!isAuthenticated || auth.via !== 'cookie' || !isAuthSessionToken(token)) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Unauthorized' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, port: PROXY_PORT, ticket: issueLocalLinkTicket(token) }));
+            return;
+        }
+
         // API: per-device login sessions — list, revoke, mint device tokens —
         // and logout (revokes the caller's own session).
         if (parsedUrl.pathname.startsWith('/api/auth/sessions') || parsedUrl.pathname === '/api/logout') {
@@ -12348,7 +12432,7 @@ happens until someone clicks it.
             req.on('data', chunk => body += chunk);
             req.on('end', async () => {
                 try {
-                    const { name, internalName, target } = JSON.parse(body);
+                    const { name, internalName, target, condense } = JSON.parse(body);
                     const source = resolveSessionInternalName(name, internalName);
                     if (!source || !(hopSessionExists(source) || getEffectiveSessionConfig(source))) {
                         res.writeHead(404, { 'Content-Type': 'application/json' });
@@ -12389,8 +12473,11 @@ happens until someone clicks it.
                     // resume the other's transcript, so the conversation is
                     // extracted to a document the new agent reads before its
                     // first turn (scripts/trajectory-extract.js). Same tool,
-                    // or no target, is the conversation fork as before.
-                    const handoff = !!wantTarget && wantTarget !== sourceKind;
+                    // or no target, is the conversation fork as before —
+                    // unless `condense` asks for the handoff anyway: a fresh
+                    // session of the SAME agent that starts from the condensed
+                    // trajectory instead of the full, context-heavy history.
+                    const handoff = !!wantTarget && (wantTarget !== sourceKind || condense === true);
                     if (handoff && sourceKind === 'shell') {
                         res.writeHead(400, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ error: 'This session has no claude or codex conversation to hand off' }));
@@ -12401,7 +12488,7 @@ happens until someone clicks it.
                         : null;
 
                     const sourceDisplay = getSessionDisplayName(source) || source;
-                    const suffix = handoff ? '-' + wantTarget : '-fork';
+                    const suffix = !handoff ? '-fork' : wantTarget === sourceKind ? '-cont' : '-' + wantTarget;
                     let forkName = sourceDisplay + suffix;
                     let n = 2;
                     while (isDisplayNameInUse(forkName) || hopSessionExists(toInternalSessionName(forkName))) {
@@ -12436,7 +12523,10 @@ happens until someone clicks it.
                         writePrivateFile(extractPath, result.text);
                         const bytes = Buffer.byteLength(result.text);
                         const prompt = trajectoryExtract.handoffPrompt(extractPath, bytes, sourceKind);
-                        command = `${wantTarget} ${shq(prompt)}`;
+                        // A claude source keeps its own launch (config dir,
+                        // model, flags) when the receiver is claude too.
+                        const launcher = wantTarget === 'claude' && rec ? (rebuildClaudeLaunch(rec.launchCmd) || 'claude') : wantTarget;
+                        command = `${launcher} ${shq(prompt)}`;
                         kind = 'handoff';
                         extract = { path: extractPath, bytes, turns: result.turns, totalTurns: result.totalTurns };
                     } else if (rec) {
@@ -14487,6 +14577,17 @@ happens until someone clicks it.
             return;
         }
 
+        // The fast-path probe: a page on the public hostname checking that
+        // this machine's daemon answers on loopback and takes its ticket.
+        if (parsedUrl.pathname === '/ws' && parsedUrl.query.probe === '1') {
+            const probe = new WebSocket.Server({ noServer: true });
+            probe.handleUpgrade(req, socket, head, (ws) => {
+                try { ws.send('ok'); ws.close(1000); } catch (e) { }
+                probe.close();
+            });
+            return;
+        }
+
         // Support both /ws?room=X (hay CLI format) and /s/{session}/ws (legacy)
         let sessionName = null;
         let sessionInfo = null;
@@ -17559,7 +17660,13 @@ async function main() {
         try {
             res = await callLocalApi(state, '/api/sessions/restore', 'POST', { dryRun, includeAgents, only: only.length ? only : undefined });
         } catch (e) {
-            log(`Restore request failed: ${e.message}`, RED);
+            // "socket hang up" here means the daemon closed the connection
+            // without answering: it was restarted, or died (e.g. its host
+            // never came up), while the restore was in flight. Nothing about
+            // the restore itself failed, so say what to do next.
+            const gone = !isServerRunning();
+            log(`Restore request failed: ${e.message}${gone ? ' — the daemon went away mid-request' : ''}.`, RED);
+            log(`  ${DIM}Check ${CYAN}hop logs${RESET}${DIM} (look for "Fatal:" or "Cleaning up"), then run ${CYAN}hop restore${RESET}${DIM} again — it only recreates sessions that are not running.${RESET}`, RESET);
             process.exit(1);
         }
         if (!res || res.status < 200 || res.status >= 300) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.76",
+  "version": "0.11.78",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {

package/scripts/hay-host.js

@@ -91,10 +91,19 @@ function loadViewerColors(hay) {
         if (typeof hay.setDefaultViewerColors === 'function') hay.setDefaultViewerColors(saved.bg, saved.fg);
     } catch (e) { /* none yet: the dark default */ }
 }
+// Compared against what is on disk, not setDefaultViewerColors' "changed":
+// room.setClientColors already updates the defaults before this runs, so
+// that always said "unchanged" and the file was never written — every host
+// restart went back to the dark default (Codex's charcoal composer).
+let savedViewerColors = null;
 function rememberViewerColors(hay, bg, fg) {
     if (typeof hay.setDefaultViewerColors !== 'function') return;
-    if (!hay.setDefaultViewerColors(bg, fg)) return;
-    try { fs.writeFileSync(VIEWER_COLORS_FILE, JSON.stringify(hay.getDefaultViewerColors())); } catch (e) { /* best effort */ }
+    hay.setDefaultViewerColors(bg, fg);
+    const json = JSON.stringify(hay.getDefaultViewerColors());
+    if (savedViewerColors === null) { try { savedViewerColors = fs.readFileSync(VIEWER_COLORS_FILE, 'utf8'); } catch (e) { savedViewerColors = ''; } }
+    if (json === savedViewerColors) return;
+    try { fs.writeFileSync(VIEWER_COLORS_FILE, json); savedViewerColors = json; } catch (e) { /* best effort */ }
+}
 const CLAUDE_SESSIONS_DIR = path.join(HOP_HOME, 'claude-sessions');
 
 // Scrub Claude Code SESSION markers from our environment before any PTY is
@@ -153,9 +162,29 @@ const watchedRooms = new WeakSet();
 // restore <name>`): their records must survive the close, exactly as they
 // survive a host shutdown. Consumed once, on the next session_end.
 const preserveRecordsOnClose = new Set();
+// Each room's terminal modes (Room.modePrefix), saved as they change so a
+// re-adopted room starts in them: an app turns alternate screen and mouse
+// reporting on once, at startup, which a bounded replay no longer holds.
+const ROOM_MODES_DIR = path.join(HOP_HOME, 'room-modes');
+const roomModesFile = (id) => path.join(ROOM_MODES_DIR, `${id}.modes`);
+function loadRoomModes(id) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(String(id || ''))) return '';
+    try { return fs.readFileSync(roomModesFile(id), 'utf8'); } catch (e) { return ''; }
+}
+function saveRoomModes(id, prefix) {
+    try {
+        if (!prefix) { fs.unlinkSync(roomModesFile(id)); return; }
+        fs.mkdirSync(ROOM_MODES_DIR, { recursive: true });
+        fs.writeFileSync(roomModesFile(id), prefix);
+    } catch (e) { /* best effort */ }
+}
 function watchRoomEnd(room) {
     if (!room || typeof room.on !== 'function' || watchedRooms.has(room)) return room;
     watchedRooms.add(room);
+    if (/^[A-Za-z0-9_.-]+$/.test(String(room.id || ''))) {
+        room.on('modes', (prefix) => saveRoomModes(String(room.id), String(prefix || '')));
+        if (typeof room.modePrefix === 'function') saveRoomModes(String(room.id), room.modePrefix());
+    }
     room.on('session_end', () => {
         if (shuttingDown) return;
         const id = String(room.id || '');
@@ -168,6 +197,7 @@ function watchRoomEnd(room) {
         // request to forget its conversation; that is an explicit delete's
         // job, daemon-side.
         try { fs.unlinkSync(path.join(BUFFER_DIR, `${id}.raw`)); } catch (e) { /* best effort */ }
+        try { fs.unlinkSync(roomModesFile(id)); } catch (e) { /* best effort */ }
     });
     return room;
 }
@@ -409,7 +439,23 @@ async function main() {
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
+    // Compressed when the client offers it (every browser does). A Codex
+    // scroll redraws ~6.7 KB per wheel tick and compresses 4.3x with a full
+    // window (2.3x with a small one: consecutive frames repeat the screen) —
+    // the difference between a trackpad flick queueing ~400 KB/s behind the
+    // tunnel and ~90 KB/s. Level 1: the CPU cost is a fraction of a ms.
+    // HAY_WS_DEFLATE=0 turns it off. Browsers only: the hop CLI and other
+    // local clients attach over loopback, where compressing buys nothing.
     const wss = new WebSocketServer({ noServer: true });
+    const wssDeflate = process.env.HAY_WS_DEFLATE === '0' ? wss : new WebSocketServer({
+        noServer: true,
+        perMessageDeflate: {
+            zlibDeflateOptions: { level: 1 },
+            threshold: 256,
+            concurrencyLimit: 16
+        }
+    });
+    if (wssDeflate !== wss) wssDeflate.on('connection', (ws, req) => wss.emit('connection', ws, req));
 
     server.on('upgrade', (req, socket, head) => {
         const wsUrl = new URL(req.url || '', `http://${req.headers.host || 'localhost'}`);
@@ -417,8 +463,9 @@ async function main() {
             socket.destroy();
             return;
         }
-        wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit('connection', ws, req);
+        const target = /Mozilla\//.test(String(req.headers['user-agent'] || '')) ? wssDeflate : wss;
+        target.handleUpgrade(req, socket, head, (ws) => {
+            target.emit('connection', ws, req);
         });
     });
 
@@ -524,6 +571,7 @@ async function main() {
         } catch (e) { }
         try {
             wss.close();
+            if (wssDeflate !== wss) wssDeflate.close();
         } catch (e) { }
         server.close(() => process.exit(0));
         setTimeout(() => process.exit(0), 500).unref();

package/tests/terminal-api.integration.test.cjs

@@ -870,6 +870,67 @@ test('fork falls past a poisoned record cwd to the durable one', async () => {
 });
 
 
+// "Continue in fresh Claude": the same agent, started over from the
+// condensed trajectory instead of resuming the full history. The new session
+// runs the SOURCE's claude launch (a fake one here, so no real agent starts)
+// with the prompt to read the extract first.
+test('condense into the same agent hands off the trajectory to a fresh session', async () => {
+  const create = await requestJson(state.port, state.sessionSecret, 'POST', '/api/terminals', {
+    name: 'condensesrc',
+    cwd: tempDir
+  }, agentHeaders);
+  assert.equal(create.status, 200);
+  const internal = create.data.sessionName;
+
+  const sessionId = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
+  const configDir = path.join(tempDir, 'claude-cfg');
+  const projectDir = path.join(configDir, 'projects', tempDir.replace(/[^A-Za-z0-9]/g, '-'));
+  await fs.mkdir(projectDir, { recursive: true });
+  await fs.writeFile(path.join(projectDir, `${sessionId}.jsonl`), [
+    { type: 'user', timestamp: '2026-10-13T10:00:00Z', message: { role: 'user', content: 'tune the scroll pacing' } },
+    { type: 'assistant', timestamp: '2026-10-13T10:00:05Z', message: { content: [{ type: 'text', text: 'Batched output to one message per redraw.' }] } }
+  ].map((e) => JSON.stringify(e)).join('\n') + '\n');
+  const argvFile = path.join(tempDir, 'fake-claude-argv.txt');
+  const fakeClaude = path.join(tempDir, 'claude-fake');
+  await fs.writeFile(fakeClaude, `#!/bin/sh\nprintf '%s\\n' "$@" > '${argvFile}'\nsleep 30\n`, { mode: 0o755 });
+  await fs.mkdir(path.join(hopHome, 'claude-sessions'), { recursive: true });
+  await fs.writeFile(path.join(hopHome, 'claude-sessions', `${internal}.json`), JSON.stringify({
+    sessionId, cwd: tempDir, configDir, launchCmd: `${fakeClaude} --model opus`,
+    updatedAt: new Date().toISOString()
+  }), { mode: 0o600 });
+
+  const fresh = await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/fork', {
+    internalName: internal, target: 'claude', condense: true
+  });
+  assert.equal(fresh.status, 200, JSON.stringify(fresh.data));
+  assert.equal(fresh.data.kind, 'handoff');
+  assert.match(fresh.data.name, /^condensesrc-cont\d*$/);
+  assert.equal(fresh.data.extract.turns, 1);
+  const extract = await fs.readFile(fresh.data.extract.path, 'utf8');
+  assert.match(extract, /tune the scroll pacing/);
+
+  let argv = '';
+  for (let i = 0; i < 40 && !argv; i++) {
+    await delay(150);
+    argv = await fs.readFile(argvFile, 'utf8').catch(() => '');
+  }
+  assert.match(argv, /^--model\nopus\n/, `the source's own claude launch, got ${JSON.stringify(argv)}`);
+  assert.ok(argv.includes(fresh.data.extract.path), 'the prompt names the extract');
+
+  const plain = await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/fork', {
+    internalName: internal, target: 'claude'
+  });
+  assert.equal(plain.status, 200);
+  assert.equal(plain.data.kind, 'claude', 'without condense, the same agent is a conversation fork');
+
+
+  for (const name of [internal, plain.data.internalName, fresh.data.internalName]) {
+    await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/delete',
+      { name, internalName: name });
+  }
+});
+
+
 // The briefing generator's coverage signal: the server witnesses who was
 // looking at what, and when. Only a HUMAN-viewing attach may stamp it —
 // wall tiles are spectators and terminal-api clients are agents.