hop2 0.11.77 → 0.11.78

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

@@ -142,6 +142,13 @@ 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.
@@ -385,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() });
     });
 
@@ -440,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;
@@ -581,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",
@@ -1075,6 +1088,7 @@ export class Room extends EventEmitter {
   }
 
   private sendActiveSize(client: ClientState, ownerId: string) {
+    this.flushOutput();
     client.socket.send(
       JSON.stringify({
         type: "active_size",
@@ -1086,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",
@@ -1100,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()) {

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/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

@@ -50,6 +50,7 @@ import {
 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)}`;
 
@@ -88,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) {
@@ -1761,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())}`;
 
@@ -1771,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.
@@ -2043,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;
       }
@@ -2070,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;

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

@@ -2590,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) {
@@ -3761,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…
+                {/* 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>
-                )}
-                {sheetSession.type !== "port" && appLabel(sheetSession) !== "claude" && (
-                  <button type="button" onClick={() => { void forkSession(sheetSession, "claude"); }}>
-                    Continue in Claude…
-                  </button>
-                )}
+                ))}
                 <button
                   type="button"
                   onClick={() => {

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/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

@@ -10514,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>
@@ -10540,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 };
@@ -10884,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') {
@@ -12386,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' });
@@ -12427,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' }));
@@ -12439,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))) {
@@ -12474,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) {
@@ -14525,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.77",
+  "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

@@ -439,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'}`);
@@ -447,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);
         });
     });
 
@@ -554,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.