hop2 0.11.11 → 0.11.12

package/hay/CHANGELOG.md

@@ -23,6 +23,7 @@
 - **Status bar / hints toggles are session-only**: `Opt+B` (status bar) and `Opt+T` (hints) no longer persist to `.hop.json`, so an in-session toggle can't silently become your permanent default. The default is taken from `.hop.json` (`showStatusBar`/`showHints`, both default `true`); toggles affect only the current session and the notice now says so. (Other toggles like mouse capture and sync-size still persist.)
 
 #### Web Client
+- **One size rule everywhere — the last user action owns the terminal size**: the server-side size election (typing-recency plus 60s/2.5s idle windows) is replaced by a single ownership rule: whoever acted last — opened the session or pressed a key — owns the PTY size, and their refits (window drag, rotation, keyboard) flow straight through. A keystroke transfers ownership and snaps the PTY to the typist's declared fit immediately. `active_size` is now interpreted by **identity** (the owner's clientId) instead of by comparing sizes. When a peer owns the size, the web terminal in Auto-fit now **follows the owner's grid** — rendered at the PTY's true geometry, scaled and letterboxed to the viewport — instead of rewrapping the buffer at its own width; typing (or the drawer's Fit button) takes the size back. Scrolling doesn't count: wheel/mouse reports never transfer ownership, so reading a session on the phone no longer steals the size from a desk. Resize sends are debounced (150ms) and the stale pre-switch resize on reconnect is gone, so a session switch reshapes the PTY once, not twice.
 - **Restyle to the hop identity**: the web client now shares the CLI bars' palette and language — accent session chip, semantic state dot, and keycap-style find control in a real status-bar footer; mono-led chrome (brand, presence names, session labels); refined light/dark themes; dot-grid join page. The hop session picker got the same treatment, including dark-mode support.
 - **Drawer polish**: quick actions split into two clusters — utility icons (keyboard / share / find) then named actions (Fit / Manage) — and the drawer FAB now defaults to the top-right (clear of the status bar, mirroring the close button) instead of bottom-left. It stays draggable.
 - **Autofit by default + fit on every session load**: the terminal fits the viewport on connect and on each session switch, on every platform. Autofit resizes the shared PTY, so other viewers follow this client; switch to Manual in the drawer to opt out.
@@ -34,7 +35,7 @@
 
 #### 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.
+- **Resizing another desktop view no longer leaves a terminal unable to reach the live bottom**: Wall/watch tiles now resize only unattended sessions instead of overriding an open desktop's Claude grid, Hop reconciles xterm's follow state after local geometry changes, and authoritative screen resizes stay 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).

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

@@ -75,6 +75,7 @@ wss.on("connection", (ws, req) => {
   const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
   const roomId = sanitizeRoom(url.searchParams.get("room"));
   const name = sanitizeName(url.searchParams.get("name"));
+  const source = url.searchParams.get("source") || "";
   const cols = Number(url.searchParams.get("cols") ?? 80);
   const rows = Number(url.searchParams.get("rows") ?? 24);
 
@@ -91,6 +92,7 @@ wss.on("connection", (ws, req) => {
     {
       id: clientId,
       name,
+      source,
       colorIndex,
       cols,
       rows

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

@@ -119,6 +119,7 @@ export function attachTermshare(options: TermshareServerOptions) {
     const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
     const roomId = sanitizeRoom(url.searchParams.get("room"));
     const name = sanitizeName(url.searchParams.get("name"));
+    const source = url.searchParams.get("source") || "";
     const cols = Number(url.searchParams.get("cols") ?? 80);
     const rows = Number(url.searchParams.get("rows") ?? 24);
 
@@ -135,6 +136,7 @@ export function attachTermshare(options: TermshareServerOptions) {
       {
         id: clientId,
         name,
+        source,
         colorIndex,
         cols,
         rows

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

@@ -117,25 +117,20 @@ const SERIALIZED_MAX_REQUEST = 524_288;
 // snapshot never trips).
 const SERIALIZED_CAPPED_HINT_BYTES = 262_144;
 
-// Autofit-on-attach: a resize may claim the shared size when every OTHER
-// client has been input-idle at least this long. Someone actively typing keeps
-// the size they set; a viewer opening the session after everyone went idle
-// takes it over immediately instead of waiting to type first.
-const RESIZE_CLAIM_IDLE_MS = (() => {
-  const env = Number(process.env.HAY_RESIZE_CLAIM_IDLE_MS);
-  return Number.isFinite(env) && env >= 0 ? env : 60_000;
-})();
-// A claim:"attach" resize (a fresh client's first autofit) is deliberate:
-// someone just opened the session there. It takes the shared size unless a
-// peer typed within this window — only an actively-typing peer holds it.
-// 2.5s (was 5s): an actively typing peer keeps refreshing its own window, so
-// this only decides how long a PAUSED typist blocks a deliberate new attach —
-// measured 5s made wall-tile focus feel stuck (converged at ~5s through the
-// tunnel; ~3s with this).
-const ATTACH_CLAIM_IDLE_MS = (() => {
-  const env = Number(process.env.HAY_ATTACH_CLAIM_IDLE_MS);
-  return Number.isFinite(env) && env >= 0 ? env : 2_500;
-})();
+// Size ownership: the last USER ACTION owns the PTY size — opening the
+// session (a claim:"attach" or user:true resize) or a real keystroke,
+// whichever happened last. No idle windows, no election. The owner's
+// resizes apply unconditionally (their viewport IS the session's size);
+// everyone else's are recorded as that client's declared fit and answered
+// with a corrective active_size so followers can adopt the owner's grid.
+// When a keystroke transfers ownership, the PTY immediately takes the new
+// owner's declared fit. Monitors (source=monitor: wall tiles, preview
+// sockets) never own the size; they may size an UNATTENDED session so
+// previews render true. Wheel/mouse reports are reading, not typing, and
+// transfer nothing. SGR mouse reports only — every hop client sends wheel
+// as CSI < b;x;y M/m. Anchored and exclusive: a payload containing
+// anything besides mouse reports still counts as typing.
+const PURE_MOUSE_REPORT = /^(?:\x1b\[<\d+;\d+;\d+[Mm])+$/;
 const CONTROL_SEQUENCE_TAIL = 32;
 const DEBUG_STATE = process.env.HAY_DEBUG === "1";
 
@@ -185,12 +180,11 @@ class ClientState {
   color: string;
   typing = false;
   lastActive = now();
-  // Timestamp of this client's last real keystroke input (not resize, not the
-  // typing indicator, not connect). 0 = has never typed. Drives the active PTY
-  // size election so size follows the active typer, not whoever last resized.
-  lastInputAt = 0;
   socket: SocketAdapter;
   source: string;
+  // Declared fit: the size this client's viewport wants, updated by every
+  // resize message whether or not it applied. Becomes the PTY size the
+  // moment a keystroke makes this client the size owner.
   cols: number;
   rows: number;
 
@@ -224,7 +218,9 @@ export class Room extends EventEmitter {
   private clients = new Map<string, ClientState>();
   private collabMode = true;
   private controllerId: string | null = null;
-  private activeClientId: string | null = null;
+  // The client whose last user action (open or keystroke) owns the PTY size.
+  // null = up for grabs (fresh room, or the owner detached).
+  private sizeOwnerId: string | null = null;
   private activeCols: number;
   private activeRows: number;
   // Retained raw output as a chunk ring: append is O(1) and trimming drops
@@ -385,7 +381,7 @@ export class Room extends EventEmitter {
     socket.send(
       JSON.stringify({
         type: "active_size",
-        clientId: this.activeClientId ?? client.id,
+        clientId: this.sizeOwnerId ?? client.id,
         cols: this.activeCols,
         rows: this.activeRows
       } satisfies ServerMessage)
@@ -880,7 +876,21 @@ export class Room extends EventEmitter {
       return;
     }
     client.lastActive = now();
-    client.lastInputAt = now();
+    // A real keystroke takes the size: transfer ownership and bring the PTY
+    // to the new owner's declared fit immediately, so typing from a phone
+    // reshapes the session even before its next resize message arrives.
+    // Wheel/mouse reports are reading, not typing — a phone scrolling claude
+    // must not take the size from someone typing at a desk.
+    if (
+      client.source !== "monitor" &&
+      this.sizeOwnerId !== client.id &&
+      !PURE_MOUSE_REPORT.test(data)
+    ) {
+      this.sizeOwnerId = client.id;
+      if (client.cols !== this.activeCols || client.rows !== this.activeRows) {
+        this.applySize(client, client.cols, client.rows);
+      }
+    }
     this.pty.write(data);
     this.emit("pty_input", { roomId: this.id, clientId: client.id, data, timestamp: now() });
   }
@@ -889,60 +899,76 @@ export class Room extends EventEmitter {
     if (!Number.isFinite(cols) || !Number.isFinite(rows)) return;
     if (cols < 1 || cols > 500 || rows < 1 || rows > 200) return;
 
+    // Always record the declared fit, applied or not — a later keystroke
+    // makes it the PTY size (see handleInput).
     client.cols = cols;
     client.rows = rows;
-    // The active PTY size follows whoever is actively typing — not whoever last
-    // resized. Previously a resize bumped lastActive and then checked "am I the
-    // most active?", which was trivially true for the resizer, so every resize
-    // won: a passive viewer resizing their window yanked the size from the
-    // active typer, and two differently-sized clients flapped. Elect on typing
-    // recency (lastInputAt) instead. A client that has never typed (lastInputAt
-    // 0) only wins when no one else has typed either — so the first/sole client
-    // can still size the PTY before typing.
-    const maxInputAt = Math.max(...[...this.clients.values()].map((c) => c.lastInputAt));
-    const othersMaxInputAt = Math.max(
-      0,
-      ...[...this.clients.values()].filter((c) => c.id !== client.id).map((c) => c.lastInputAt)
-    );
-    const claimIdleMs = claim === "attach" ? ATTACH_CLAIM_IDLE_MS : RESIZE_CLAIM_IDLE_MS;
-    // A user-flagged claim is a deliberate human act (clicking a wall tile,
-    // switching to the session): it wins outright. Anyone actively typing
-    // elsewhere reclaims with their next keystroke, so misfires self-heal.
-    const isActive = userClaim ||
-      client.lastInputAt >= maxInputAt || now() - othersMaxInputAt > claimIdleMs;
-    if (isActive) {
-      this.pty.resize(cols, rows);
-      this.activeCols = cols;
-      this.activeRows = rows;
-      this.grid?.resize(cols, rows);
-      this.activeClientId = client.id;
-      // Broadcast the new active size to other clients so they can adjust —
-      // and CONFIRM to the winner: a claimant otherwise learns nothing on
-      // success and can only distinguish accept from reject by timeout.
-      this.broadcastActiveSize(client);
-      client.socket.send(
-        JSON.stringify({
-          type: "active_size",
-          clientId: client.id,
-          cols,
-          rows
-        } satisfies ServerMessage)
-      );
-      this.emit("pty_resize", { roomId: this.id, clientId: client.id, cols, rows, timestamp: now() });
-    } else if (cols !== this.activeCols || rows !== this.activeRows) {
-      // The resize lost the election (a passive viewer auto-fitted itself).
-      // Snap that client back to the shared size — otherwise its local
-      // terminal re-wraps the buffer at a size the PTY isn't, and it has no
-      // way to learn the real size until the next winning resize.
-      client.socket.send(
-        JSON.stringify({
-          type: "active_size",
-          clientId: this.activeClientId ?? client.id,
-          cols: this.activeCols,
-          rows: this.activeRows
-        } satisfies ServerMessage)
+
+    // A wall/watch tile may size an unattended session so previews render
+    // true, but must never clip a live client by forcing Claude's alternate
+    // screen to the tile's grid — and never takes ownership.
+    if (client.source === "monitor") {
+      const hasInteractivePeer = [...this.clients.values()].some(
+        (peer) => peer.id !== client.id && peer.source !== "monitor"
       );
+      if (!hasInteractivePeer) {
+        this.applySize(client, cols, rows);
+      } else if (cols !== this.activeCols || rows !== this.activeRows) {
+        this.sendActiveSize(client, this.sizeOwnerId ?? client.id);
+      }
+      return;
+    }
+
+    // Opening the session here (claim:"attach") or a deliberate click
+    // (user:true) is a user action: strict recency, it takes ownership
+    // outright. Whoever was typing elsewhere takes it back with their next
+    // keystroke, so misfires self-heal.
+    if (claim === "attach" || userClaim) {
+      this.sizeOwnerId = client.id;
+      this.applySize(client, cols, rows);
+      return;
     }
+
+    // The owner's viewport IS the session's size: its refits (rotation,
+    // keyboard show/hide, window drag) flow straight through. While nobody
+    // owns the size (fresh room, owner detached), any interactive client
+    // may size it without claiming it.
+    if (this.sizeOwnerId === client.id || this.sizeOwnerId === null) {
+      this.applySize(client, cols, rows);
+      return;
+    }
+
+    // Not the owner: the declaration is recorded; snap the client back to
+    // the shared size — otherwise its local terminal re-wraps the buffer at
+    // a size the PTY isn't, and it has no way to learn the real size until
+    // the next broadcast.
+    if (cols !== this.activeCols || rows !== this.activeRows) {
+      this.sendActiveSize(client, this.sizeOwnerId);
+    }
+  }
+
+  private applySize(client: ClientState, cols: number, rows: number) {
+    this.pty.resize(cols, rows);
+    this.activeCols = cols;
+    this.activeRows = rows;
+    this.grid?.resize(cols, rows);
+    // Broadcast to the others so they can adopt — and CONFIRM to the
+    // applier: a claimant otherwise learns nothing on success and can only
+    // distinguish accept from reject by timeout.
+    this.broadcastActiveSize(client);
+    this.sendActiveSize(client, client.id);
+    this.emit("pty_resize", { roomId: this.id, clientId: client.id, cols, rows, timestamp: now() });
+  }
+
+  private sendActiveSize(client: ClientState, ownerId: string) {
+    client.socket.send(
+      JSON.stringify({
+        type: "active_size",
+        clientId: ownerId,
+        cols: this.activeCols,
+        rows: this.activeRows
+      } satisfies ServerMessage)
+    );
   }
 
   private broadcastActiveSize(client: ClientState) {
@@ -995,6 +1021,11 @@ export class Room extends EventEmitter {
   private removeClient(clientId: string) {
     const wasController = this.controllerId === clientId;
     this.clients.delete(clientId);
+    if (this.sizeOwnerId === clientId) {
+      // The owner left: the size is up for grabs, so a remaining client's
+      // next refit (not just its next keystroke) may take it.
+      this.sizeOwnerId = null;
+    }
     if (wasController && !this.collabMode) {
       this.collabMode = true;
       this.controllerId = null;

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

@@ -39,6 +39,9 @@ export const GRID_SCROLLBACK = (() => {
   const env = Number(process.env.HAY_GRID_SCROLLBACK);
   return Number.isFinite(env) && env >= 0 ? Math.floor(env) : 1000;
 })();
+// Preserve ordinary shrink/grow sequences exactly while bounding an abusive
+// resize storm's retained work behind a single xterm write marker.
+const MAX_QUEUED_RESIZE_TRANSITIONS = 256;
 
 let deps: GridDeps | null = null;
 let loading: Promise<boolean> | null = null;
@@ -110,27 +113,52 @@ export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null
     return null;
   }
   let disposed = false;
+  let coalescibleResizes: number[] | null = null;
   return {
     write(data: string) {
       if (disposed) return;
+      // Output is an ordering boundary: a later resize must run after it,
+      // rather than coalescing into a resize marker queued before it.
+      if (data) coalescibleResizes = null;
       try { term.write(data); } catch { /* parser hiccup — next write continues */ }
     },
     resize(nextCols: number, nextRows: number) {
       if (disposed) return;
       const cols = Math.max(2, nextCols);
       const rows = Math.max(1, nextRows);
+      if (coalescibleResizes) {
+        if (coalescibleResizes.length < MAX_QUEUED_RESIZE_TRANSITIONS * 2) {
+          coalescibleResizes.push(cols, rows);
+        } else {
+          coalescibleResizes[coalescibleResizes.length - 2] = cols;
+          coalescibleResizes[coalescibleResizes.length - 1] = rows;
+        }
+        return;
+      }
+      const scheduled = [cols, rows];
+      coalescibleResizes = scheduled;
       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.
+        // Consecutive resizes share this marker. Replay ordinary geometry
+        // changes exactly: shrink/grow transitions mutate xterm's grid even
+        // without output. Only an abusive overflow degrades to the latest size.
         term.write("", () => {
           if (disposed) return;
-          try { term.resize(cols, rows); } catch { /* keep old size */ }
+          if (coalescibleResizes === scheduled) coalescibleResizes = null;
+          for (let i = 0; i < scheduled.length; i += 2) {
+            try { term.resize(scheduled[i], scheduled[i + 1]); } catch { /* keep previous size */ }
+          }
         });
-      } catch { /* keep old size */ }
+      } catch {
+        if (coalescibleResizes === scheduled) coalescibleResizes = null;
+      }
     },
     serialize(callback: (data: string | null) => void, scrollback: number = GRID_SCROLLBACK) {
       if (disposed) { callback(null); return; }
+      // A later resize must not move ahead of this point-in-time snapshot.
+      coalescibleResizes = null;
       try {
         // An empty write's callback fires once all queued data has parsed —
         // the serialize then reflects every byte up to this attach.

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

@@ -243,50 +243,85 @@ describe("Room", () => {
     expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 90, rows: 20 });
   });
 
-  it('claim:"attach" takes the size unless a peer typed seconds ago', () => {
-    vi.useFakeTimers();
-    try {
-      let ptyInstance: FakePty | null = null;
-      const factory: PtyFactory = () => {
-        ptyInstance = new FakePty() as unknown as FakePty;
-        return ptyInstance as any;
-      };
-      const manager = new RoomManager(factory);
-      const room = manager.getRoom("attach-claim", { cols: 80, rows: 24 }, "/tmp");
-      const cli = new FakeSocket();
-      room.attachClient({ id: "cli", name: "Local", colorIndex: 0, cols: 80, rows: 24 }, cli);
-
-      // The desktop CLI is actively typing right now.
-      cli.emitMessage({ type: "input", data: "ls" });
-
-      // A phone opens the session 2s later and attach-claims its fitted size:
-      // an actively-typing peer keeps the size — the claim loses.
-      vi.advanceTimersByTime(2_000);
-      const phone = new FakeSocket();
-      room.attachClient({ id: "ph", name: "Phone", colorIndex: 1, cols: 46, rows: 28 }, phone);
-      const before = ptyInstance!.resizes.length;
-      phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
-      expect(ptyInstance!.resizes.length).toBe(before);
-
-      // 10s after the CLI's last keystroke (well inside the 60s a plain
-      // resize would need), the attach claim wins: opening a session is
-      // intent, and nobody is typing anymore.
-      vi.advanceTimersByTime(10_000);
-      phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
-      expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 46, rows: 28 });
-
-      // A plain (unclaimed) resize from another fresh viewer still cannot
-      // yank the size at 10s idle — the 60s election guards those.
-      const viewer = new FakeSocket();
-      room.attachClient({ id: "v", name: "Viewer", colorIndex: 2, cols: 200, rows: 50 }, viewer);
-      phone.emitMessage({ type: "input", data: "x" });
-      vi.advanceTimersByTime(10_000);
-      const beforeViewer = ptyInstance!.resizes.length;
-      viewer.emitMessage({ type: "resize", cols: 200, rows: 50 });
-      expect(ptyInstance!.resizes.length).toBe(beforeViewer);
-    } finally {
-      vi.useRealTimers();
-    }
+  it("lets a monitor size only an unattended session", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("monitor-resize", { cols: 80, rows: 24 }, "/tmp");
+    const desktop = new FakeSocket();
+    const monitor = new FakeSocket();
+    room.attachClient(
+      { id: "desktop", name: "Desktop", colorIndex: 0, cols: 80, rows: 24, nudge: false },
+      desktop
+    );
+    room.attachClient(
+      { id: "wall", name: "Wall", source: "monitor", colorIndex: 1, cols: 80, rows: 40, nudge: false },
+      monitor
+    );
+
+    const before = ptyInstance!.resizes.length;
+    monitor.emitMessage({ type: "resize", cols: 80, rows: 40, claim: "attach", user: true });
+    expect(ptyInstance!.resizes.length).toBe(before);
+    expect(findMessages(monitor, "active_size").at(-1)).toMatchObject({ cols: 80, rows: 24 });
+
+    desktop.close();
+    monitor.emitMessage({ type: "resize", cols: 80, rows: 40, claim: "attach", user: true });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 80, rows: 40 });
+  });
+
+  it("the last user action — open or keystroke — owns the size", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("attach-claim", { cols: 80, rows: 24 }, "/tmp");
+    const cli = new FakeSocket();
+    room.attachClient({ id: "cli", name: "Local", colorIndex: 0, cols: 80, rows: 24 }, cli);
+
+    // The desktop CLI is actively typing right now.
+    cli.emitMessage({ type: "input", data: "ls" });
+
+    // A phone opens the session and attach-claims its fitted size: opening
+    // is the latest user action, so the claim wins outright — even over
+    // someone who typed a moment ago. Strict recency, no idle windows.
+    const phone = new FakeSocket();
+    room.attachClient({ id: "ph", name: "Phone", colorIndex: 1, cols: 46, rows: 28 }, phone);
+    phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 46, rows: 28 });
+
+    // The CLI's next keystroke is now the latest user action: ownership
+    // transfers back and the PTY snaps to the CLI's declared fit
+    // immediately — before any resize message from it.
+    cli.emitMessage({ type: "input", data: "x" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 80, rows: 24 });
+
+    // A plain (unclaimed) resize from a fresh viewer is a declaration, not
+    // a user action — it cannot move an owned size, and the viewer is
+    // snapped back to the shared grid.
+    const viewer = new FakeSocket();
+    room.attachClient({ id: "v", name: "Viewer", colorIndex: 2, cols: 200, rows: 50 }, viewer);
+    const beforeViewer = ptyInstance!.resizes.length;
+    viewer.emitMessage({ type: "resize", cols: 200, rows: 50 });
+    expect(ptyInstance!.resizes.length).toBe(beforeViewer);
+    expect(findMessages(viewer, "active_size").at(-1)).toMatchObject({ cols: 80, rows: 24, clientId: "cli" });
+
+    // But that declaration is remembered: the viewer's first keystroke makes
+    // it the owner and the PTY takes its declared 200×50 in the same beat.
+    viewer.emitMessage({ type: "input", data: "y" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 200, rows: 50 });
+
+    // Wheel reports are reading, not typing: a pure SGR mouse payload from
+    // the phone transfers nothing.
+    const beforeWheel = ptyInstance!.resizes.length;
+    phone.emitMessage({ type: "input", data: "\x1b[<64;40;12M\x1b[<65;40;12M" });
+    phone.emitMessage({ type: "resize", cols: 46, rows: 28 });
+    expect(ptyInstance!.resizes.length).toBe(beforeWheel);
   });
 
   it("bounds the join-time snapshot replay to a tail cut at a line boundary", () => {
@@ -408,41 +443,31 @@ describe("Room", () => {
     expect(last?.clientId).toBe("typer");
   });
 
-  it("lets a resize claim the size once every other client is input-idle", () => {
-    vi.useFakeTimers();
-    try {
-      vi.setSystemTime(1_000_000);
-      let ptyInstance: FakePty | null = null;
-      const factory: PtyFactory = () => {
-        ptyInstance = new FakePty() as unknown as FakePty;
-        return ptyInstance as any;
-      };
-      const manager = new RoomManager(factory);
-      const room = manager.getRoom("claim", { cols: 120, rows: 30 }, "/tmp");
-      const typer = new FakeSocket();
-      const viewer = new FakeSocket();
-      room.attachClient({ id: "typer", name: "Alex", colorIndex: 0, cols: 120, rows: 30 }, typer);
-      room.attachClient({ id: "viewer", name: "Blake", colorIndex: 1, cols: 60, rows: 20 }, viewer);
-
-      typer.emitMessage({ type: "input", data: "ls\r" });
-      typer.emitMessage({ type: "resize", cols: 120, rows: 30 });
-
-      // Recently-typed elsewhere: the viewer's autofit is refused (and snapped back).
-      viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
-      expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 120, rows: 30 });
-
-      // Everyone else idle past the claim window: the same autofit now wins.
-      vi.setSystemTime(1_000_000 + 61_000);
-      viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
-      expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 60, rows: 20 });
-
-      // The previous holder is told the size moved.
-      const sizes = findMessages(typer, "active_size");
-      expect(sizes.at(-1)?.cols).toBe(60);
-      expect(sizes.at(-1)?.clientId).toBe("viewer");
-    } finally {
-      vi.useRealTimers();
-    }
+  it("frees the size when the owner detaches — no idle window needed", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("claim", { cols: 120, rows: 30 }, "/tmp");
+    const typer = new FakeSocket();
+    const viewer = new FakeSocket();
+    room.attachClient({ id: "typer", name: "Alex", colorIndex: 0, cols: 120, rows: 30 }, typer);
+    room.attachClient({ id: "viewer", name: "Blake", colorIndex: 1, cols: 60, rows: 20 }, viewer);
+
+    typer.emitMessage({ type: "input", data: "ls\r" });
+    typer.emitMessage({ type: "resize", cols: 120, rows: 30 });
+
+    // The owner is elsewhere: the viewer's autofit is refused (and snapped back).
+    viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
+    expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 120, rows: 30 });
+
+    // The owner leaves: the size is up for grabs, and the viewer's next
+    // plain refit takes it — no keystroke, no claim, no waiting.
+    typer.close();
+    viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
+    expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 60, rows: 20 });
   });
 
   it("counts attention bells but not OSC-terminator BELs", () => {
@@ -813,6 +838,31 @@ describe("Room", () => {
       }
     });
 
+    it("preserves consecutive shrink and grow transitions in the screen grid", async () => {
+      const { room, pty } = await setup("ordered-grid-resize-burst", { cols: 20, rows: 5 });
+      const owner = new FakeSocket();
+      room.attachClient(
+        { id: "owner", name: "Owner", colorIndex: 0, cols: 20, rows: 5, replayBytes: 0, nudge: false },
+        owner
+      );
+      const rows = Array.from({ length: 5 }, (_, i) => `\x1b[${i + 1};1HROW-${i + 1}`).join("");
+      pty().emit("\x1b[?1049h\x1b[2J" + rows);
+
+      // Even with no output between them, shrink then grow is not equivalent
+      // to only the final size: xterm discards the rows clipped by the shrink.
+      owner.emitMessage({ type: "resize", cols: 20, rows: 2, user: true });
+      owner.emitMessage({ type: "resize", cols: 20, rows: 5, user: true });
+      const late = new FakeSocket();
+      room.attachClient(
+        { id: "late", name: "Late", colorIndex: 1, cols: 20, rows: 5, replayBytes: 65536 },
+        late
+      );
+      const snapshot = await waitForSnapshot(late);
+      expect(String(snapshot.data)).not.toContain("ROW-1");
+      expect(String(snapshot.data)).toContain("ROW-4");
+      expect(String(snapshot.data)).toContain("ROW-5");
+    });
+
     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);

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

@@ -113,6 +113,46 @@ 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 wall/watch tile may fit an unattended room, but it must not replace
+    // the PTY geometry underneath an attached desktop. Claude's alternate
+    // screen has no local scrollback, so foreign rows can otherwise be clipped.
+    const monitorClaim = await page1.evaluate(async (roomName) => {
+      const peer = new WebSocket(
+        `ws://${location.host}/ws?room=${encodeURIComponent(roomName)}&name=Wall&source=monitor&replay=0&cols=240&rows=70`
+      );
+      const nextActiveSize = () => new Promise((resolve) => {
+        const handler = (event) => {
+          const message = JSON.parse(String(event.data));
+          if (message.type !== "active_size") return;
+          peer.removeEventListener("message", handler);
+          resolve(message);
+        };
+        peer.addEventListener("message", handler);
+      });
+      const initialSize = nextActiveSize();
+      await new Promise((resolve, reject) => {
+        peer.onopen = resolve;
+        peer.onerror = reject;
+      });
+      const before = await initialSize;
+      const claimedSize = nextActiveSize();
+      peer.send(JSON.stringify({
+        type: "resize",
+        cols: 240,
+        rows: 70,
+        claim: "attach",
+        user: true
+      }));
+      const after = await claimedSize;
+      peer.close();
+      return { before, after };
+    }, freshRoom);
+    assert.deepEqual(
+      { cols: monitorClaim.after.cols, rows: monitorClaim.after.rows },
+      { cols: monitorClaim.before.cols, rows: monitorClaim.before.rows },
+      `monitor replaced an attached desktop's PTY size: ${JSON.stringify(monitorClaim)}`
+    );
+
     // 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.