hop2 0.11.9 → 0.11.11

package/hay/CHANGELOG.md

@@ -32,6 +32,10 @@
 
 ### Bug Fixes
 
+#### Web terminal
+- **Claude screens render completely on attach without a scroll**: Hop now starts its authoritative screen grid when a session enters alternate-screen or mouse-reporting TUI mode, before startup rows can fall out of a bounded replay tail. Full-screen attaches use that serialized screen, and direct snapshot paints re-arm one delayed repaint in case the browser misses the first WebGL frame.
+- **Resizing another desktop view no longer leaves a terminal unable to reach the live bottom**: Hop now reconciles xterm's follow state after every geometry change and keeps authoritative screen resizes ordered behind the output that preceded them.
+
 #### Session restore
 - **`hop restore` actually restores now (Claude conversations included), from the SessionStart-hook records**: restore built its candidate list from the workspace-scoped session store, which is only populated when a workspace is active — and no workspace is ever activated in normal use, so `restore` found nothing and silently restored zero sessions. It now sources candidates directly from the durable per-session records the SessionStart hook writes (`~/.hop2/claude-sessions/<name>.json` = `{ sessionId, cwd }`), which survive a crash/reboot and carry the exact conversation id. So after a restart, `hop restore` recreates each session in its directory and resumes its Claude conversation with `claude --resume <id>` — no manual capture step. Sessions already live are skipped (idempotent), and `hop restore` now starts the daemon itself if it isn't running, so post-reboot recovery is a single command. `--dry-run` previews the plan. Records are pruned when a session is deleted, so restore never resurrects a session you intentionally closed (and if an unwanted one does come back, deleting it once keeps it gone).
 - **`hopx_agent_turn` no longer runs non-UI input twice**: in `readable_raw` mode (and `auto` resolving to it — i.e. a plain shell or any non-alternate-screen agent), a synchronous turn pre-sent the input and *then* sent it again via the combined send+wait, so a command driven through `hopx_agent_turn` executed twice. The pre-send is now done only for the paths that need it (the `ui` branch and async turns, which return before the combined call); non-UI synchronous turns let the single send+wait do the send. UI and async turns are unchanged.

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

@@ -179,6 +179,7 @@ class ClientState {
   // Output broadcasts are withheld meanwhile (see broadcast) and delivered
   // as catch-up appended to the snapshot itself.
   awaitingSnapshot = false;
+  snapshotCatchUp: string[] = [];
   id: string;
   name: string;
   color: string;
@@ -261,10 +262,15 @@ export class Room extends EventEmitter {
   // connect created the room, so its hello carries created=true.
   private hasHadClient = false;
   // Authoritative screen state for serialized attach (see screenGrid.ts).
-  // Created lazily once the headless deps load; hydrated from the retained
-  // ring at creation so bytes that arrived earlier are never missing.
+  // Start it as soon as a TUI advertises alternate-screen or mouse mode, so
+  // rows painted once at startup cannot age out of a bounded replay tail.
+  // Plain shells stay lazy and pay no grid cost until somebody attaches.
   private grid: ScreenGrid | null = null;
   private gridHydrated = false;
+  private gridStartPending = false;
+  private gridUnavailable = false;
+  private gridPendingSeed: string[] | null = null;
+  private gridPendingSeedBytes = 0;
 
   constructor(id: string, ptyFactory: PtyFactory, initialSize: { cols: number; rows: number }, options: RoomCreateOptions) {
     super();
@@ -297,6 +303,7 @@ export class Room extends EventEmitter {
       this.lastActivityAt = now();
       this.appendOutput(data);
       this.updateTerminalState(data);
+      this.startTuiGrid();
       this.answerTerminalQueriesIfHeadless(data);
       this.broadcast({ type: "output", data });
       this.emit("pty_output", { roomId: this.id, data, timestamp: now() });
@@ -445,19 +452,20 @@ export class Room extends EventEmitter {
       // Everything already in the ring at THIS moment will be in the
       // serialized screen; everything after it will not (grid writes queue
       // behind the serialize marker). Mute output to this client until the
-      // snapshot goes out, then hand it the exact delta from this cursor.
+      // snapshot goes out, retaining the exact withheld chunks for catch-up.
       client.awaitingSnapshot = true;
-      const catchUpFrom = this.outputStart + this.outputBytes;
+      client.snapshotCatchUp = [];
       gridForAttach.serialize((serialized) => {
         if (this.ended || !this.clients.has(client.id) || !socket.isOpen()) {
           client.awaitingSnapshot = false;
+          client.snapshotCatchUp = [];
           return;
         }
         if (serialized === null) {
-          // Raw fallback reads the ring as it stands NOW — everything the
-          // mute withheld is inside it. Unmute first so nothing new slips
-          // into the erased-by-reset gap either (raw has no RIS).
+          // Raw fallback reads the ring as it stands NOW. Unmute first so
+          // nothing new slips into the handoff (raw has no in-band RIS).
           client.awaitingSnapshot = false;
+          client.snapshotCatchUp = [];
           sendRawSnapshot();
           wiggle();
           return;
@@ -473,16 +481,17 @@ 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.
-        const catchUp = this.getOutputSince(catchUpFrom);
+        const catchUp = client.snapshotCatchUp.join("");
         socket.send(JSON.stringify({
           type: "snapshot",
           // In-band RIS: every client applies the serialized screen onto a
           // clean slate, including ones that don't reset on their own.
-          data: "\x1bc" + serialized + modeSeq + (catchUp.reset ? "" : catchUp.data),
+          data: "\x1bc" + serialized + modeSeq + catchUp,
           capped: this.outputBytes > SERIALIZED_CAPPED_HINT_BYTES,
           ...snapshotFlags()
         } satisfies ServerMessage));
         client.awaitingSnapshot = false;
+        client.snapshotCatchUp = [];
         // No wiggle: the serialized grid IS the current screen.
       }, serializedScrollback);
     } else {
@@ -564,16 +573,24 @@ export class Room extends EventEmitter {
 
   private updateTerminalState(data: string) {
     const combined = this.controlSequenceTail + data;
+    const tailLength = this.controlSequenceTail.length;
+    const risIndex = combined.lastIndexOf("\x1bc");
+    // Only reset tracked state for a RIS that ends in this chunk; one entirely
+    // inside the carry tail was already applied on the preceding call. Always
+    // ignore bytes before the last RIS so carried pre-reset mode enables cannot
+    // be parsed again on the next chunk.
+    const hasNewRis = risIndex !== -1 && risIndex + 2 > tailLength;
+    const stateInput = risIndex !== -1 ? combined.slice(risIndex + 2) : combined;
 
     // Parse CSI mode sequences (cursor visibility, alternate screen)
     const regex = /\x1b\[\?([0-9;]*)([hl])/g;
     let match: RegExpExecArray | null;
-    let nextAlternate = this.alternateScreen;
-    let nextCursorHidden = this.cursorHidden;
+    let nextAlternate = hasNewRis ? false : this.alternateScreen;
+    let nextCursorHidden = hasNewRis ? false : this.cursorHidden;
 
-    let nextMouseReporting = this.mouseReporting;
-    let nextMouseSgr = this.mouseSgr;
-    while ((match = regex.exec(combined)) !== null) {
+    let nextMouseReporting = hasNewRis ? false : this.mouseReporting;
+    let nextMouseSgr = hasNewRis ? false : this.mouseSgr;
+    while ((match = regex.exec(stateInput)) !== null) {
       const params = match[1].split(";").filter(Boolean);
       const mode = match[2];
       for (const param of params) {
@@ -593,10 +610,10 @@ export class Room extends EventEmitter {
 
     // Enhanced keyboard reporting: kitty keyboard protocol (CSI >flags u push /
     // CSI <n u pop / CSI =flags u set) and xterm modifyOtherKeys (CSI >4;n m).
-    let nextKeyboardEnhanced = this.keyboardEnhanced;
+    let nextKeyboardEnhanced = hasNewRis ? false : this.keyboardEnhanced;
     const kbdRegex = /\x1b\[([<>=])[0-9;:]*u|\x1b\[>([0-9;]*)m/g;
     let kbdMatch: RegExpExecArray | null;
-    while ((kbdMatch = kbdRegex.exec(combined)) !== null) {
+    while ((kbdMatch = kbdRegex.exec(stateInput)) !== null) {
       if (kbdMatch[1] !== undefined) {
         nextKeyboardEnhanced = kbdMatch[1] !== "<"; // push/set = on, pop = off
       } else {
@@ -954,7 +971,10 @@ export class Room extends EventEmitter {
       // serialize marker). That silent loss was 'the screen is stale until
       // the app repaints' on every attach that raced live output. The
       // withheld bytes are delivered as catch-up appended to the snapshot.
-      if (isOutput && client.awaitingSnapshot) continue;
+      if (isOutput && client.awaitingSnapshot) {
+        client.snapshotCatchUp.push((message as { data: string }).data);
+        continue;
+      }
       if (client.socket.isOpen()) {
         client.socket.send(payload);
       }
@@ -1052,13 +1072,38 @@ export class Room extends EventEmitter {
     }
   }
 
-  // Grids are LAZY: created on the first serialized attach, not on output,
-  // so a room nobody ever opens (agent fleets) pays no grid memory at all.
-  // Creation hydrates from a bounded ring tail — deep enough to contain any
-  // app's last full repaint plus every update since, which is all screen
-  // correctness needs; serialized scrollback is bounded anyway.
+  // Incremental TUIs paint some rows once and then update other regions for
+  // hours. Reconstructing their first grid from any bounded tail can therefore
+  // 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.
+  private startTuiGrid() {
+    if (!SERIALIZED_ATTACH_ENABLED || this.grid || this.gridStartPending || this.gridUnavailable || this.ended) return;
+    if (!this.alternateScreen && !this.mouseReporting) return;
+    if (screenGridsAvailable()) {
+      this.gridUnavailable = this.ensureGrid() === null;
+      return;
+    }
+    this.gridStartPending = true;
+    this.gridPendingSeed = [this.tailOutput(MAX_BUFFER_SIZE)];
+    this.gridPendingSeedBytes = this.gridPendingSeed[0].length;
+    void loadScreenGridDeps().then((available) => {
+      this.gridStartPending = false;
+      this.gridUnavailable = !available;
+      const seed = this.gridPendingSeed?.join("") ?? "";
+      this.gridPendingSeed = null;
+      this.gridPendingSeedBytes = 0;
+      if (available && !this.ended) {
+        this.gridUnavailable = this.ensureGrid(seed) === null;
+      }
+    });
+  }
+
+  // Plain-shell grids remain lazy until the first serialized attach. Creation
+  // hydrates from a bounded ring tail; append-only shell output is safely
+  // reconstructible from that tail, unlike the incremental TUI path above.
   private static readonly GRID_HYDRATE_BYTES = 2_000_000;
-  private ensureGrid(): ScreenGrid | null {
+  private ensureGrid(seed?: string): ScreenGrid | null {
     if (!SERIALIZED_ATTACH_ENABLED || this.ended) return this.grid;
     if (!this.grid && screenGridsAvailable()) {
       this.grid = createScreenGrid(this.activeCols, this.activeRows);
@@ -1067,8 +1112,8 @@ export class Room extends EventEmitter {
         if (this.outputBytes > 0) {
           // Cut at a line boundary (same trick as boundSnapshotReplay) so a
           // slice landing mid-escape-sequence can't garble the parse head.
-          let tail = this.tailOutput(Room.GRID_HYDRATE_BYTES);
-          if (this.outputBytes > tail.length) {
+          let tail = seed ?? this.tailOutput(Room.GRID_HYDRATE_BYTES);
+          if (seed === undefined && this.outputBytes > tail.length) {
             const nl = tail.indexOf("\n");
             if (nl !== -1 && nl < 8192) tail = tail.slice(nl + 1);
           }
@@ -1082,6 +1127,20 @@ export class Room extends EventEmitter {
   /** O(1) append; trims whole chunks from the head past MAX_BUFFER_SIZE. */
   private appendOutput(data: string) {
     if (!data) return;
+    if (this.gridPendingSeed) {
+      this.gridPendingSeed.push(data);
+      this.gridPendingSeedBytes += data.length;
+      while (this.gridPendingSeed.length > 1
+          && this.gridPendingSeedBytes - this.gridPendingSeed[0].length >= MAX_BUFFER_SIZE) {
+        this.gridPendingSeedBytes -= this.gridPendingSeed[0].length;
+        this.gridPendingSeed.shift();
+      }
+      if (this.gridPendingSeed.length === 1 && this.gridPendingSeedBytes > MAX_BUFFER_SIZE) {
+        const tail = this.gridPendingSeed[0].slice(-MAX_BUFFER_SIZE);
+        this.gridPendingSeed[0] = tail;
+        this.gridPendingSeedBytes = tail.length;
+      }
+    }
     this.outputChunks.push(data);
     this.outputBytes += data.length;
     while (this.outputChunks.length > 1 && this.outputBytes - this.outputChunks[0].length >= MAX_BUFFER_SIZE) {
@@ -1156,6 +1215,29 @@ export class Room extends EventEmitter {
     return { cols: this.activeCols, rows: this.activeRows, output: this.tailOutput(maxBytes) };
   }
 
+  /**
+   * The room's current screen, serialized — IDENTICAL in geometry and bytes
+   * to what a live attach snapshots. Previews painted from this cannot
+   * disagree with the terminal a click turns them into: that disagreement
+   * (daemon-side grids rendering at their own capped size while the room ran
+   * at another) was the preview → terminal size change. Modes ride in-band
+   * like the attach path so cursor/mouse state present identically too.
+   */
+  serializeScreen(
+    callback: (result: { data: string; cols: number; rows: number } | null) => void,
+    scrollback = 200
+  ) {
+    if (this.outputBytes === 0) { callback(null); return; }
+    const grid = this.ensureGrid();
+    if (!grid) { callback(null); return; }
+    grid.serialize((serialized) => {
+      if (serialized === null) { callback(null); return; }
+      const modeSeq = (this.mouseReporting ? "\x1b[?1002h" + (this.mouseSgr ? "\x1b[?1006h" : "") : "")
+        + (this.cursorHidden ? "\x1b[?25l" : "");
+      callback({ data: "\x1bc" + serialized + modeSeq, cols: this.activeCols, rows: this.activeRows });
+    }, scrollback);
+  }
+
   /**
    * Incremental output for a persistent consumer-side screen parser (the
    * daemon's preview grids). `since` is an absolute cursor from a previous
@@ -1295,6 +1377,16 @@ export class RoomManager {
     return room ? room.getPreviewSource(maxBytes) : null;
   }
 
+  serializeRoomScreen(
+    id: string,
+    callback: (result: { data: string; cols: number; rows: number } | null) => void,
+    scrollback?: number
+  ) {
+    const room = this.rooms.get(id);
+    if (!room) { callback(null); return; }
+    room.serializeScreen(callback, scrollback);
+  }
+
   getRoomOutputSince(id: string, since?: number, maxBytes?: number) {
     const room = this.rooms.get(id);
     return room ? room.getOutputSince(since, maxBytes) : null;

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

@@ -117,7 +117,17 @@ export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null
     },
     resize(nextCols: number, nextRows: number) {
       if (disposed) return;
-      try { term.resize(Math.max(2, nextCols), Math.max(1, nextRows)); } catch { /* keep old size */ }
+      const cols = Math.max(2, nextCols);
+      const rows = Math.max(1, nextRows);
+      try {
+        // xterm parses write() asynchronously. Queue the resize behind every
+        // earlier byte so room order stays PTY output → SIGWINCH, while later
+        // writes naturally queue behind this callback's synchronous resize.
+        term.write("", () => {
+          if (disposed) return;
+          try { term.resize(cols, rows); } catch { /* keep old size */ }
+        });
+      } catch { /* keep old size */ }
     },
     serialize(callback: (data: string | null) => void, scrollback: number = GRID_SCROLLBACK) {
       if (disposed) { callback(null); return; }

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

@@ -709,7 +709,7 @@ describe("Room", () => {
   });
 
   describe("serialized attach", () => {
-    const setup = async (roomId: string) => {
+    const setup = async (roomId: string, initialSize = { cols: 80, rows: 24 }) => {
       const { loadScreenGridDeps } = await import("../src/screenGrid");
       expect(await loadScreenGridDeps()).toBe(true);
       let ptyInstance: FakePty | null = null;
@@ -718,7 +718,7 @@ describe("Room", () => {
         return ptyInstance as any;
       };
       const manager = new RoomManager(factory);
-      const room = manager.getRoom(roomId, { cols: 80, rows: 24 }, "/tmp");
+      const room = manager.getRoom(roomId, initialSize, "/tmp");
       return { room, pty: () => ptyInstance! };
     };
 
@@ -766,6 +766,53 @@ describe("Room", () => {
       expect(snapshot.mouseReporting).toBe(true);
     });
 
+    it("tracks TUI rows before they age out of the grid hydration tail", async () => {
+      const { room, pty } = await setup("early-grid");
+      pty().emit("\x1b[?1002h\x1b[?1006h");
+      pty().emit("\x1b[2J\x1b[1;1HROW1-EARLY-GRID-MARKER");
+      // Repaint only row 20 for more than the lazy grid's 2MB hydration
+      // window. A grid first created at attach would have no row 1 to send.
+      const updateBatch = ("\x1b[20;1H\x1b[K" + "x".repeat(60)).repeat(64);
+      for (let i = 0; i < 500; i++) pty().emit(updateBatch);
+
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "late", name: "Late", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("ROW1-EARLY-GRID-MARKER");
+      expect(room.getPreviewSource(2_000_000).output).not.toContain("ROW1-EARLY-GRID-MARKER");
+    });
+
+    it("parses queued screen output before applying a later resize", async () => {
+      const { room, pty } = await setup("ordered-grid-resize", { cols: 80, rows: 60 });
+      const owner = new FakeSocket();
+      room.attachClient(
+        { id: "owner", name: "Owner", colorIndex: 0, cols: 80, rows: 60, replayBytes: 0, nudge: false },
+        owner
+      );
+      const rows = Array.from({ length: 60 }, (_, i) => {
+        const row = String(i + 1).padStart(2, "0");
+        return `\x1b[${i + 1};1HROW-${row}`;
+      }).join("");
+      pty().emit("\x1b[?1049h\x1b[2J" + rows);
+
+      // PTY order is old-size output, then SIGWINCH. The headless grid used
+      // to resize synchronously while its earlier write was still queued,
+      // clamping rows 25-59 away before a late attach serialized the screen.
+      owner.emitMessage({ type: "resize", cols: 80, rows: 25, user: true });
+      const late = new FakeSocket();
+      room.attachClient(
+        { id: "late", name: "Late", colorIndex: 1, cols: 80, rows: 25, replayBytes: 65536 },
+        late
+      );
+      const snapshot = await waitForSnapshot(late);
+      for (let row = 36; row <= 60; row++) {
+        expect(String(snapshot.data)).toContain(`ROW-${String(row).padStart(2, "0")}`);
+      }
+    });
+
     it("flags a serialized snapshot as capped when deeper raw history exists", async () => {
       const { room, pty } = await setup("capped");
       const big = "\x1b[20;1H" + "y".repeat(4096);
@@ -810,6 +857,71 @@ describe("Room", () => {
       expect(after.some((m) => String(m.data).includes("LATE-MARKER-XYZ"))).toBe(false);
     });
 
+    it("retains catch-up larger than the incremental preview limit", async () => {
+      const { room, pty } = await setup("large-race");
+      pty().emit("\x1b[?1002h\x1b[2J\x1b[1;1Hbefore large catch-up");
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "large-racer", name: "Large Racer", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      // Larger than getOutputSince's 1MB default: cursor-based catch-up used
+      // to reset here and silently drop every withheld byte.
+      const late = "x".repeat(1_100_000) + "LARGE-CATCHUP-MARKER";
+      pty().emit(late);
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("LARGE-CATCHUP-MARKER");
+      const live = readMessages(socket).filter((m) => m.type === "output");
+      expect(live.some((m) => String(m.data).includes("LARGE-CATCHUP-MARKER"))).toBe(false);
+    });
+
+    it("clears tracked private modes when the app sends RIS", async () => {
+      const { room, pty } = await setup("ris-modes");
+      pty().emit("\x1b[?1049h\x1b[?1002h\x1b[?1006h\x1b[?25l\x1b[>1u");
+      // Split ESC c across chunks to cover the control-sequence carry path.
+      pty().emit("\x1b");
+      pty().emit("c\x1b[2J\x1b[1;1HAFTER-RIS");
+      // A later chunk must not reparse mode enables that remain before RIS in
+      // the control-sequence carry buffer.
+      pty().emit("plain");
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "after-ris", name: "After RIS", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("AFTER-RIS");
+      expect(snapshot.alternateScreen).toBe(false);
+      expect(snapshot.mouseReporting).toBe(false);
+      expect(snapshot.mouseSgr).toBe(false);
+      expect(snapshot.cursorHidden).toBe(false);
+      expect(snapshot.keyboardEnhanced).toBe(false);
+    });
+
+    // The preview → terminal size change, killed at the root: a preview must
+    // be painted from the SAME grid, at the SAME geometry, as the snapshot a
+    // live attach would receive.
+    it("serializeScreen matches the live room's geometry and carries modes", async () => {
+      const { room, pty } = await setup("faithful");
+      pty().emit("\x1b[?1002h\x1b[?1006h");
+      pty().emit("\x1b[2J\x1b[1;1HFAITHFUL-MARKER");
+      const result = await new Promise((resolve) => room.serializeScreen(resolve));
+      expect(result).not.toBeNull();
+      expect((result as any).cols).toBe(80);
+      expect((result as any).rows).toBe(24);
+      expect(String((result as any).data).startsWith("\x1bc")).toBe(true);
+      expect(String((result as any).data)).toContain("FAITHFUL-MARKER");
+      expect(String((result as any).data)).toContain("\x1b[?1002h");
+      // After a size claim, the serialized geometry follows the room.
+      const socket = new FakeSocket();
+      room.attachClient({ id: "typer", name: "T", colorIndex: 0, cols: 100, rows: 30 }, socket);
+      socket.emitMessage({ type: "input", data: "x" });
+      socket.emitMessage({ type: "resize", cols: 100, rows: 30 });
+      const after = await new Promise((resolve) => room.serializeScreen(resolve));
+      expect((after as any).cols).toBe(100);
+      expect((after as any).rows).toBe(30);
+    });
+
     it("replay=0 means no snapshot at all — live stream only", async () => {
       const { room, pty } = await setup("claim");
       pty().emit("some prior output\r\n");

package/hay/apps/web/scripts/run-e2e.mjs

@@ -113,6 +113,59 @@ const runE2E = async () => {
     const switchedBuffer = await page1.evaluate(() => window.__hay?.getBufferText() || "");
     assert.ok(!switchedBuffer.includes("shared"), `old room output survived session switch: ${JSON.stringify(switchedBuffer)}`);
 
+    // A resize can collapse scrollback to y=base=0 without xterm emitting an
+    // onScroll event. App follow-mode must reconcile that state before the
+    // next real room output grows below a viewport parked at 0.
+    const followAfterResize = await page1.evaluate(async () => {
+      const terminal = window.__hay.terminal;
+      const write = (data) => new Promise((resolve) => terminal.write(data, resolve));
+      terminal.reset();
+      terminal.resize(20, 5);
+      await write(Array.from({ length: 20 }, (_, i) => `old-${i}\r\n`).join(""));
+      terminal.scrollLines(-2);
+      const before = {
+        y: terminal.buffer.active.viewportY,
+        base: terminal.buffer.active.baseY
+      };
+      terminal.resize(20, 30);
+      const afterResize = {
+        y: terminal.buffer.active.viewportY,
+        base: terminal.buffer.active.baseY
+      };
+      return { before, afterResize };
+    });
+    assert.ok(followAfterResize.before.y < followAfterResize.before.base, "follow-latch setup did not scroll above bottom");
+    assert.deepEqual(followAfterResize.afterResize, { y: 0, base: 0 }, "resize did not collapse the test scrollback");
+
+    // Deliver the new rows through the room, so this covers App's actual
+    // output/follow path rather than xterm's behavior for a direct test write.
+    await page1.evaluate(async ({ roomName, data }) => {
+      const peer = new WebSocket(
+        `ws://${location.host}/ws?room=${encodeURIComponent(roomName)}&name=FollowPeer&cols=20&rows=30`
+      );
+      await new Promise((resolve, reject) => {
+        peer.onopen = resolve;
+        peer.onerror = reject;
+      });
+      window.__followPeer = peer;
+      peer.send(JSON.stringify({ type: "input", data }));
+    }, {
+      roomName: freshRoom,
+      data: Array.from({ length: 15 }, (_, i) => `new-${i}\r\n`).join("")
+    });
+    await page1.waitForFunction(() => window.__hay.terminal.buffer.active.baseY > 0);
+    followAfterResize.afterWrite = await page1.evaluate(() => ({
+      y: window.__hay.terminal.buffer.active.viewportY,
+      base: window.__hay.terminal.buffer.active.baseY
+    }));
+    await page1.evaluate(() => window.__followPeer?.close());
+    assert.ok(followAfterResize.afterWrite.base > 0, "follow-latch test did not regrow scrollback");
+    assert.equal(
+      followAfterResize.afterWrite.y,
+      followAfterResize.afterWrite.base,
+      `terminal stopped following after resize: ${JSON.stringify(followAfterResize)}`
+    );
+
     const roomLock = `e2e-${Date.now()}-lock`;
     const context2 = await browser.newContext({ viewport: { width: 1280, height: 720 } });
     const page3 = await context2.newPage();

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

@@ -519,6 +519,16 @@ const App = () => {
   const shouldReconnectRef = useRef(true);
   const connectNonceRef = useRef(0);
   const userScrolledUpRef = useRef(false);
+  // A resize can collapse a previously scrolled viewport to y=base=0 without
+  // clearing xterm's internal user-scroll state. The next output must repair
+  // follow mode after xterm has actually grown the buffer again.
+  const followAfterResizeRef = useRef(false);
+  // Set by every write into the terminal; the render watchdog only spends a
+  // refresh when something actually changed since its last tick.
+  const outputSinceTickRef = useRef(true);
+  // Timestamp of the last bytes from the session — the ack signal that
+  // paces synthetic wheel steps (see scrollFlywheel appGlide).
+  const lastOutputAtRef = useRef(0);
   // Late-bound hooks for the voice controller (created before these exist).
   const handleUserInputRef = useRef<((data: string) => void) | null>(null);
   const pushNoticeRef = useRef<((m: string) => void) | null>(null);
@@ -928,8 +938,18 @@ const App = () => {
     return presence.find((client) => client.id === controllerId)?.name ?? "Someone";
   }, [presence, controllerId]);
 
+  // Local echo policy. Exclusive control keeps the old rule. In COLLAB mode
+  // (the default for every shared session) echo used to be flatly OFF — so
+  // each character waited a full round trip, tunnel RTT included, even when
+  // you were the only person typing, which is the overwhelmingly common
+  // case. Echo now stays on unless another client is ACTUALLY typing right
+  // now (presence carries the flag), and drops the instant one starts. A
+  // sub-second overlap before presence propagates is absorbed by the
+  // reconciler's guards (complex-chunk passthrough, two-strike clear).
+  const othersTyping = presence.some((c) => c.id !== clientId && c.typing);
   const optimisticActive =
-    LATENCY_COMP && status === "connected" && !collabMode && controllerId === clientId;
+    LATENCY_COMP && status === "connected" && !othersTyping
+    && (collabMode ? true : controllerId === clientId);
 
   useEffect(() => {
     if (optimisticPrevRef.current && !optimisticActive) {
@@ -1251,12 +1271,19 @@ const App = () => {
     if (!termRef.current) {
       return;
     }
+    outputSinceTickRef.current = true;
+    lastOutputAtRef.current = performance.now(); // same clock the flywheel compares
 
     // Filter focus reporting sequences that can leak as visible text
     const filtered = data.replace(/\x1b\[I/g, '').replace(/\x1b\[O/g, '');
+    const repairFollowAfterResize = followAfterResizeRef.current;
     termRef.current.write(filtered, () => {
+      if (repairFollowAfterResize) {
+        followAfterResizeRef.current = false;
+        userScrolledUpRef.current = false;
+      }
       // Auto-scroll to bottom unless the user has explicitly scrolled up
-      if (!userScrolledUpRef.current) {
+      if (repairFollowAfterResize || !userScrolledUpRef.current) {
         termRef.current?.scrollToBottom();
       }
     });
@@ -1301,6 +1328,12 @@ const App = () => {
     activeSizeRef.current = null;
     optimisticEchoRef.current.reset();
     userScrolledUpRef.current = false;
+    followAfterResizeRef.current = false;
+    // reset() can emit onScroll(0). Clear the previous room's history guards
+    // first so that event cannot masquerade as a real scroll-to-top gesture.
+    lastViewportYRef.current = 0;
+    snapshotSettledAtRef.current = 0;
+    snapshotWasCappedRef.current = false;
     termRef.current?.reset();
 
     // Fast first paint: the daemon can serialize the session's CURRENT
@@ -1339,6 +1372,9 @@ const App = () => {
           // snapshot and must land where the snapshot would.
           t.scrollToBottom();
           t.refresh(0, t.rows - 1);
+          // This write bypasses writeToTerminal(). Re-arm the delayed render
+          // invariant after parsing, so a missed WebGL frame self-heals.
+          outputSinceTickRef.current = true;
         });
       })
       .catch(() => { /* fast paint is best-effort */ });
@@ -1504,6 +1540,10 @@ const App = () => {
                 userScrolledUpRef.current = false;
               }
               t.refresh(0, t.rows - 1);
+              // Snapshot writes bypass writeToTerminal(). Set this only after
+              // parsing so a slow snapshot cannot have its retry consumed
+              // before there is anything complete to repaint.
+              outputSinceTickRef.current = true;
               // The snapshot has fully landed: only from here on can a
               // viewport-top event mean a user gesture.
               lastViewportYRef.current = t.buffer.active.viewportY;
@@ -1699,7 +1739,8 @@ const App = () => {
         () => termRef.current,
         {
           linesPerNotch: 4, // mirrors scrollSensitivity above
-          lineHeightPx: () => Math.max(1, ((terminal as any)._core?._renderService?.dimensions?.css?.cell?.height) || fontSize * 1.3)
+          lineHeightPx: () => Math.max(1, ((terminal as any)._core?._renderService?.dimensions?.css?.cell?.height) || fontSize * 1.3),
+          lastOutputAt: () => lastOutputAtRef.current
         }
       );
     }
@@ -1918,6 +1959,30 @@ const App = () => {
       syncOverlayScrollbar();
     };
     terminal.onScroll(onBufferScroll);
+    // xterm does not always emit onScroll when a resize collapses scrollback.
+    // Its public y/base can then say "bottom" while both our follow flag and
+    // xterm's private user-scroll latch remain stuck above it. Reconcile every
+    // resize from buffer truth and remember to repair follow mode after the
+    // next write has regrown the buffer (scrollToBottom is a no-op at 0/0).
+    terminal.onResize(() => {
+      // onResize fires inside xterm's resize transaction, before its private
+      // user-scroll latch has fully settled. Reconcile just after resize()
+      // returns, still ahead of terminal writes queued later in the turn.
+      queueMicrotask(() => {
+        if (termRef.current !== terminal) return;
+        const { y, base } = scrollState();
+        lastViewportYRef.current = y;
+        if (y >= base) {
+          userScrolledUpRef.current = false;
+          followAfterResizeRef.current = true;
+          terminal.scrollToBottom();
+        } else {
+          userScrolledUpRef.current = true;
+          followAfterResizeRef.current = false;
+        }
+        syncOverlayScrollbar();
+      });
+    });
     // Buffer growth while following doesn't always fire onScroll — a light
     // interval keeps the thumb honest.
     const overlayInterval = window.setInterval(syncOverlayScrollbar, 700);
@@ -2565,6 +2630,12 @@ const App = () => {
       if (document.hidden || switcherOpenRef.current) return;
       const t = termRef.current;
       if (!t) return;
+      // Idle sessions get no tick: a full refresh every 1.4s on a screen
+      // nothing wrote to re-rasterizes identical rows forever (measurable
+      // on battery with several sessions open). Output sets the flag; one
+      // enforcement pass clears it.
+      if (!outputSinceTickRef.current) return;
+      outputSinceTickRef.current = false;
       try {
         const buf = t.buffer.active;
         if (!userScrolledUpRef.current && buf.viewportY < buf.baseY) t.scrollToBottom();