agent-yes 1.206.0 → 1.208.0

package/lab/ui/index.html

@@ -695,14 +695,14 @@
         align-items: center;
         gap: 8px;
       }
-      /* Peers badge beside the agent counter — how many other humans are in the
-         fleet right now. Yellow ("here") when a peer shares the agent you have
-         open, muted otherwise. Hidden entirely when you're alone. */
-      .peers {
-        color: var(--muted);
+      /* The single consolidated fleet summary: "N/M agents · R rooms · 👤 P".
+         Rooms/peers segments appear only when there's more than one room / any
+         peer, so a solo fleet just reads "N/M agents". Turns yellow ("here") when
+         another peer is watching the agent you have open. */
+      .count {
         cursor: default;
       }
-      .peers.here {
+      .count.here {
         color: var(--peer);
       }
       .connbadge {
@@ -1851,20 +1851,11 @@
           </div>
           <div class="meta">
             <span class="metaleft">
-              <span id="count"></span>
-              <span id="peers" class="peers" hidden></span>
+              <span id="count" class="count"></span>
             </span>
             <span class="metaright">
               <button id="foldbtn" class="viewbtn" title="fold subagent trees">⊞ subs</button>
               <button id="sortbtn" class="viewbtn" title="cycle sort order">⇅ state</button>
-              <button
-                id="viewbtn"
-                class="viewbtn"
-                title="toggle compact list"
-                aria-label="Toggle compact list view"
-              >
-                ☰
-              </button>
               <button id="portsbtn" class="viewbtn" title="manage exposed localhost ports">
                 ⇄ ports
               </button>
@@ -2173,7 +2164,7 @@
         selFromBottom,
         parseSel,
         selSegments,
-        fitTransform,
+        fitTransformCentered,
         docTitle,
         omniScore,
       } from "./console-logic.js";
@@ -2192,6 +2183,7 @@
       // row keeps pulsing to. See advanceStdinFlashes/focusSummary (console-logic).
       let focusByKey = new Map();
       let peerTotal = 0;
+      let shownAgentCount = 0; // agents matching the current filter (for the summary badge)
       const stdinSeen = new Map();
       const flashUntil = new Map();
       const STDIN_FLASH_MS = 1200;
@@ -2230,7 +2222,15 @@
         } catch {}
         if (term) {
           term.options.fontSize = termFontSize;
-          if (fit)
+          // Negotiating host: the grid is canonical (host-owned) — a font change
+          // here only alters our glyph px, so re-letterbox and report the new
+          // capacity; the host reflows the PTY if our readable cols/rows moved.
+          // This is what makes font size a ZOOM control on mobile: bigger font →
+          // fewer readable cells → the PTY itself shrinks → bigger crisp text.
+          if (negoActive) {
+            applyCanvasScale();
+            sendPresence();
+          } else if (fit)
             try {
               fit.fit();
             } catch {}
@@ -3132,6 +3132,13 @@
       // short lease after that, the heartbeat won't follow/override — so our own
       // push isn't fought while the agent's /api/size is still catching up.
       let lastDroveAt = 0;
+      // The selected agent's host negotiates the PTY size from viewer
+      // capacities (its /api/size responses carry nego:true). On such hosts we
+      // never push /api/resize — we report our readable capacity in presence
+      // (sendPresence cap) and follow the negotiated canonical grid, so a phone
+      // and a desktop watching the same agent converge on the smallest
+      // viewer's readable size instead of fighting last-writer-wins.
+      let negoActive = false;
 
       function isDarkColor(c) {
         try {
@@ -3277,6 +3284,18 @@
           const s = term.getSelectionPosition && term.getSelectionPosition();
           selR = selFromBottom(s, term.buffer.active.length);
         } catch {}
+        // Our readable capacity: the grid our pane fits at the current font —
+        // measured from the container (transform-independent), NOT term.cols
+        // (which may be a foreign canonical grid we're letterboxing). The host
+        // negotiates the PTY to the min cap across viewers; read-only viewers
+        // report none (they can't influence the PTY). Older hosts ignore it.
+        let cap = null;
+        try {
+          if (!isReadonlyEnt(cur.e) && fit) {
+            const d = fit.proposeDimensions();
+            if (d && d.cols > 0 && d.rows > 0) cap = { cols: d.cols, rows: d.rows };
+          }
+        } catch {}
         cur.tx
           .post("/api/presence", {
             viewer: myViewerId,
@@ -3284,6 +3303,7 @@
             cols: term.cols,
             rows: term.rows,
             sel: selR,
+            cap,
           })
           .catch(() => {});
       }
@@ -3333,29 +3353,34 @@
         const sum = focusSummary(recs);
         focusByKey = sum.byKey;
         peerTotal = sum.total;
-        paintPeersBadge();
+        updateSummary();
         renderList();
       }
-      // "N peers" badge beside the agent counter. Yellow when a peer shares the
-      // agent you have open ("same agent"); its tooltip breaks the count down by
-      // agent so you can see who's where. Hidden when you're the only one here.
-      function paintPeersBadge() {
-        const el = $("peers");
+      // The ONE consolidated fleet summary in the header, replacing the separate
+      // agent-count and "N peers" badges: "<shown>/<total> agents" plus, only when
+      // relevant, "· R rooms" (multi-room fleets) and "· 👤 P" (other humans here).
+      // Yellow ("here") when a peer shares the agent you have open; the tooltip
+      // breaks the peer count down by agent so you can see who's where. Called both
+      // from renderList (agent list changed) and on presence updates (peers).
+      function updateSummary() {
+        const el = $("count");
         if (!el) return;
-        if (!peerTotal) {
-          el.hidden = true;
+        const rooms = new Set(entries.filter((e) => e._room).map((e) => e._room)).size;
+        let s = `${shownAgentCount} / ${entries.length} agents`;
+        if (rooms > 1) s += ` · ${rooms} rooms`;
+        if (peerTotal > 0) s += ` · 👤 ${peerTotal}`;
+        el.textContent = s;
+        el.classList.toggle("here", !!(sel && focusByKey.get(sel)));
+        if (peerTotal > 0) {
+          const lines = [...focusByKey.entries()].map(([k, n]) => {
+            const e = entries.find((x) => x._key === k);
+            const name = e ? e.title || cliLabel(e) || ident(e) || `pid ${e.pid}` : k;
+            return `  ${n} on ${name}`;
+          });
+          el.title = "peers watching agents in this fleet:\n" + lines.join("\n");
+        } else {
           el.removeAttribute("title");
-          return;
         }
-        el.hidden = false;
-        el.textContent = `👤 ${peerTotal} peer${peerTotal === 1 ? "" : "s"}`;
-        el.classList.toggle("here", !!(sel && focusByKey.get(sel)));
-        const lines = [...focusByKey.entries()].map(([k, n]) => {
-          const e = entries.find((x) => x._key === k);
-          const name = e ? e.title || cliLabel(e) || ident(e) || `pid ${e.pid}` : k;
-          return `  ${n} on ${name}`;
-        });
-        el.title = "peers watching agents in this fleet:\n" + lines.join("\n");
       }
       // 3s heartbeat (< the host's 12s TTL): refresh our presence + read others',
       // and follow the canonical grid size (resize+scale, never reflow) so all
@@ -3600,14 +3625,36 @@
           const cs = getComputedStyle(logEl);
           const pw = logEl.clientWidth - parseFloat(cs.paddingLeft) - parseFloat(cs.paddingRight);
           const ph = logEl.clientHeight - parseFloat(cs.paddingTop) - parseFloat(cs.paddingBottom);
-          // fitTransform (console-logic.js) decides none-vs-scale (unit-tested).
-          xt.style.transform = fitTransform(gw, gh, pw, ph);
+          // fitTransformCentered (console-logic.js, unit-tested) decides
+          // none-vs-scale and centers the letterboxed grid in the pane (fit
+          // width → vertically centered, fit height → horizontally). The peer
+          // overlay reads the transformed screen rect back via
+          // getBoundingClientRect, so the translate needs no extra bookkeeping.
+          xt.style.transform = fitTransformCentered(gw, gh, pw, ph).transform;
         } catch {}
       }
+      // Pane geometry changed (window resize, splitter drag, soft keyboard, tab
+      // refocus): on legacy hosts re-fit the grid to the pane (the size push
+      // rides term.onResize → pushSize); on negotiating hosts the grid is
+      // canonical — never reflow it locally, just re-letterbox and report the
+      // new capacity so the host can move the min if needed.
+      function refitPane() {
+        if (!term) return;
+        if (negoActive) {
+          applyCanvasScale();
+          sendPresence();
+          return;
+        }
+        if (fit)
+          try {
+            fit.fit();
+          } catch {}
+      }
       // Follow the canonical grid: resize our xterm to the agent's size (set by the
       // active driver / local owner) WITHOUT reflowing to our pane, then scale to
       // fit. No-op when we already match (we're the driver, or sizes agree).
       function followAgentSize(sz) {
+        if (sz && sz.nego != null) negoActive = !!sz.nego;
         if (!term || !sz || !sz.cols || !sz.rows) return;
         // While our own recent push is still settling, don't fight it.
         if (Date.now() - lastDroveAt < 6000) {
@@ -4654,8 +4701,9 @@
         s.streaming = false;
       }
 
-      // Compact list: one line per agent (dot + cli + title), persisted per device.
-      let compactList = localStorage.getItem("ay.compactList") === "1";
+      // Compact list is now the ONLY list view (one line per agent: dot + cli +
+      // title). The toggle button was removed — compact is always on.
+      const compactList = true;
 
       // Fold subagent trees: hide nested (sub)agent rows and roll each root's
       // hidden descendants into a summary chip. Folded BY DEFAULT (only "0" opts
@@ -4844,11 +4892,10 @@
         const rows = foldSubs
           ? fullRows.filter((r) => !(r.kind === "agent" && r.parentEntry))
           : fullRows;
-        $("count").textContent = `${agentRows.length} / ${entries.length} agents`;
-        paintPeersBadge(); // keep the peers badge in step with sel / the entry list
+        shownAgentCount = agentRows.length;
+        updateSummary(); // one consolidated "agents · rooms · peers" badge
         $("foldbtn").textContent = foldSubs ? "⊞ subs" : "⊟ subs";
         $("foldbtn").classList.toggle("on", !foldSubs);
-        $("viewbtn").classList.toggle("on", compactList);
         // Show the active sort mode on the button so it's self-documenting; the
         // default ("state") is also highlighted to hint it's the implicit order.
         $("sortbtn").textContent = `⇅ ${sortMode}`;
@@ -4985,25 +5032,22 @@
         // the new mtime, so a silent `ay send` still trips the flash within ~1s.
         const until = Date.now() + STDIN_FLASH_MS;
         for (const k of advanceStdinFlashes(entries, stdinSeen)) flashUntil.set(k, until);
-        // Badge: total agents + how many rooms are live. Red only when nothing
-        // at all is reachable (no source answered).
-        // Count ROOMS, not machines — a codehost room with three machines is still
-        // one room, and it can be connecting before any machine has appeared.
+        // Connection-status badge ONLY (dot + state). The agent/room/peer COUNTS
+        // live in one place now — the #count summary on the left — so this badge no
+        // longer repeats them; it just shows liveness and stays the rooms-manager
+        // click target (see its title). Red only when nothing is reachable.
         const roomSrcs = srcs.filter((s) => s.id !== LOCAL);
-        const liveRooms = new Set(roomSrcs.filter((s) => s.live).map((s) => s.room || s.id)).size;
         const anyLive = srcs.some((s) => s.live);
         const connecting =
           roomSrcs.some((s) => !s.tried) || [...chRooms.values()].some((r) => !r.tried);
         const roomCount = roomSrcs.length || chRooms.size;
-        const n = entries.length;
         if (!srcs.length && !chRooms.size) {
           setConn("● no fleet", "var(--muted)");
         } else if (!anyLive) {
           if (connecting) setConn("● connecting…", "var(--amber)");
           else setConn(roomCount ? "● rooms offline" : "● ay serve down", "var(--red)");
         } else {
-          const roomBit = liveRooms ? ` · ${liveRooms} room${liveRooms === 1 ? "" : "s"}` : "";
-          setConn(`● ${n} agent${n === 1 ? "" : "s"}${roomBit}`, "var(--green)");
+          setConn("● live", "var(--green)");
         }
         renderRoomsIfOpen();
         renderList();
@@ -5187,6 +5231,14 @@
               applyCanvasScale();
               return;
             }
+            // Negotiating host: the PTY size is the host's min over viewer
+            // capacities, not ours to push. Re-letterbox and refresh our cap
+            // (the pane may have changed) — the host resizes if the min moved.
+            if (negoActive) {
+              applyCanvasScale();
+              sendPresence();
+              return;
+            }
             lastDroveAt = Date.now(); // we're driving the size now (lease the grid)
             tx.post("/api/resize/" + encodeURIComponent(pid), {
               cols: term.cols,
@@ -5227,6 +5279,7 @@
         const selKey = e._key;
         const fitAndSync = (sz) => {
           if (sel !== selKey || !term) return;
+          negoActive = !!(sz && sz.nego);
           if (sz && sz.cols && sz.rows) agentSize = sz; // remember for the badge tooltip
           // Read-only viewer: don't reflow the agent to our pane (we can't resize
           // it, and shouldn't). Adopt the AGENT's own grid and CSS-scale it to fit,
@@ -5238,6 +5291,22 @@
             suppressPush = false;
             return;
           }
+          // Negotiating host: adopt the canonical (negotiated) grid like a
+          // watcher and report our capacity via presence — the host takes the
+          // min over all viewers and resizes the PTY itself. No direct push, so
+          // two viewers can't fight over the size.
+          if (negoActive) {
+            if (sz.cols && sz.rows) followAgentSize(sz);
+            else {
+              // agent has no size on record yet — seed from our own fit
+              try {
+                fit.fit();
+              } catch {}
+            }
+            suppressPush = false;
+            sendPresence(); // cap → host negotiates → size event brings the grid
+            return;
+          }
           try {
             fit.fit();
           } catch {}
@@ -5381,11 +5450,6 @@
         } catch {}
         renderList();
       });
-      $("viewbtn").addEventListener("click", () => {
-        compactList = !compactList;
-        localStorage.setItem("ay.compactList", compactList ? "1" : "0");
-        renderList();
-      });
       // Fold / unfold every subagent tree (global toggle, persisted per device).
       $("foldbtn").addEventListener("click", () => {
         foldSubs = !foldSubs;
@@ -5413,13 +5477,9 @@
         renderList();
       });
       window.addEventListener("resize", () => {
-        // Resizing our window is strong intent → re-fit to our pane (we become the
-        // size driver; the push rides term.onResize). applyCanvasScale then clears
-        // the transform since our grid now matches our pane.
-        if (fit)
-          try {
-            fit.fit();
-          } catch {}
+        // Resizing our window is strong intent → re-fit / re-report capacity
+        // (refitPane picks the legacy-push vs negotiate path).
+        refitPane();
         applyCanvasScale();
         renderPeerSelections(); // cell size changed → reposition peer-selection overlays
       });
@@ -5434,15 +5494,76 @@
         const onVV = () => {
           const kb = Math.max(0, Math.round(window.innerHeight - vv.height - vv.offsetTop));
           document.documentElement.style.setProperty("--kb", kb + "px");
-          if (fit)
-            try {
-              fit.fit();
-            } catch {}
+          refitPane();
         };
         vv.addEventListener("resize", onVV);
         vv.addEventListener("scroll", onVV);
         onVV();
       }
+      // ── mobile pinch on the terminal = terminal zoom, not page zoom ─────────
+      // Two fingers over the log pane adjust the terminal FONT SIZE. On a
+      // negotiating host that reflows the PTY itself (bigger font → fewer
+      // readable cells → the host shrinks the grid → bigger crisp text; smaller
+      // font → more rows/cols), which is what a phone user actually means by
+      // pinch: "show me more / make it readable", with the surrounding UI
+      // staying put. Only 2-touch gestures over .log are intercepted — 1-finger
+      // scroll/selection passes to xterm, and the page keeps its native
+      // pinch-zoom everywhere else (an a11y requirement, WCAG 1.4.4).
+      (function () {
+        const logEl = $("log");
+        if (!logEl) return;
+        let startDist = 0; // 0 = no pinch in flight
+        let startFont = 0;
+        let lastRatio = 1;
+        let baseTransform = "";
+        const dist = (t) => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY);
+        logEl.addEventListener(
+          "touchstart",
+          (ev) => {
+            if (ev.touches.length !== 2) return;
+            ev.preventDefault(); // this gesture is ours — no page zoom
+            startDist = dist(ev.touches);
+            startFont = termFontSize;
+            lastRatio = 1;
+            const xt = logEl.querySelector(".xterm");
+            baseTransform = xt ? xt.style.transform || "none" : "none";
+          },
+          { passive: false },
+        );
+        logEl.addEventListener(
+          "touchmove",
+          (ev) => {
+            if (ev.touches.length !== 2 || !startDist) return;
+            ev.preventDefault();
+            lastRatio = dist(ev.touches) / startDist;
+            // Live preview: compose the pinch onto the fitted transform. The
+            // grid truly reflows only when the negotiated size lands after the
+            // gesture commits — a brief settle, traded for zero SIGWINCH storm
+            // while the fingers are still moving.
+            const xt = logEl.querySelector(".xterm");
+            if (xt)
+              xt.style.transform =
+                `scale(${lastRatio.toFixed(3)})` +
+                (baseTransform === "none" ? "" : " " + baseTransform);
+          },
+          { passive: false },
+        );
+        const endPinch = () => {
+          if (!startDist) return;
+          const target = Math.round(startFont * lastRatio);
+          startDist = 0;
+          if (target !== termFontSize) setTermFontSize(target); // nego: cap → host reflows
+          applyCanvasScale(); // clear the preview; re-letterbox at the real grid
+        };
+        logEl.addEventListener("touchend", (ev) => {
+          if (ev.touches.length < 2) endPinch();
+        });
+        logEl.addEventListener("touchcancel", () => endPinch());
+        // Safari's proprietary gesture events fire for pinch regardless of
+        // touch-action; swallow them over the terminal so the page never zooms.
+        for (const t of ["gesturestart", "gesturechange", "gestureend"])
+          logEl.addEventListener(t, (ev) => ev.preventDefault());
+      })();
 
       // Step the selection up/down the (filtered) list — same order the left panel
       // renders. Clamps at the ends, scrolls the row into view.
@@ -6983,11 +7104,7 @@
             // terminal of a different size) that re-push fights the local terminal
             // and reflows the stream on every tab switch — the glitch the eager
             // per-focus resync introduced. The one-shot adopt still runs on select.
-            if (term && fit) {
-              try {
-                fit.fit();
-              } catch {}
-            }
+            refitPane();
           }
         });
         watchVersion();
@@ -7039,10 +7156,7 @@
           if (!dragging) return;
           const w = Math.min(Math.max(e.clientX, 280), window.innerWidth - 360);
           app.style.setProperty("--leftw", w + "px");
-          if (fit)
-            try {
-              fit.fit();
-            } catch {}
+          refitPane();
         });
         const end = (e) => {
           if (!dragging) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.206.0",
+  "version": "1.208.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/serve.ts

@@ -48,6 +48,7 @@ import { findSpawnHiddenLauncher } from "./rustBinary.ts";
 import { pgidForWrapper } from "./reaper.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { getInstalledPackage } from "./versionChecker.ts";
+import { negotiateSize, sanitizeCap, type SizeCap } from "./sizeNego.ts";
 import { listStrayServeProcesses } from "./strayServe.ts";
 import {
   getProvisionHook,
@@ -235,10 +236,19 @@ const SESSION_PIN_ENV = new Set([
 // ~/.bun/bin, ~/.cargo/bin, Homebrew, nvm shims, etc. A console-spawned agent
 // that inherits that env can't find `bun`/`bunx`/etc. (the user reported "bunx:
 // command not found" when spawning a new agent from the web UI). We recover the
-// real environment by running the user's interactive login shell and dumping its
-// env, exactly as a fresh terminal would have it. Returns null on Windows (no
-// rc-file model — the process env is already the right one) or on any failure, so
-// callers fall back to process.env.
+// real environment by running the user's LOGIN shell and dumping its env.
+//
+// IMPORTANT: NON-interactive (`-lc`, not `-ilc`). An interactive shell (`-i`)
+// HANGS indefinitely when the daemon has no controlling TTY — exactly the case
+// under any process manager (oxmgr/systemd/launchd/pm2) — and Bun's `spawnSync`
+// `timeout` does NOT kill the hung interactive shell. Because this runs
+// synchronously on the event loop from the /api/spawn handler, the interactive
+// variant PERMANENTLY WEDGED the daemon on the first console spawn (heartbeat
+// froze → healthcheck restart → cache lost → next spawn wedged again), making
+// console spawns impossible on a headless daemon. `-l` still sources the profile
+// chain (`~/.profile`/`~/.bash_profile` → `~/.bashrc`), so the tool PATHs are
+// still recovered. Returns null on Windows (no rc-file model — the process env is
+// already the right one) or on any failure, so callers fall back to process.env.
 let loginShellEnvCache: Record<string, string> | null | undefined;
 function loginShellEnv(): Record<string, string> | null {
   if (loginShellEnvCache !== undefined) return loginShellEnvCache;
@@ -250,7 +260,7 @@ function loginShellEnv(): Record<string, string> | null {
     // print to stdout; `env -0` is NUL-separated so values with newlines survive.
     const delim = "_AY_SHELL_ENV_DELIM_";
     const res = Bun.spawnSync(
-      [shell, "-ilc", `printf %s "${delim}"; env -0; printf %s "${delim}"`],
+      [shell, "-lc", `printf %s "${delim}"; env -0; printf %s "${delim}"`],
       {
         stdin: "ignore",
         stderr: "ignore",
@@ -1850,10 +1860,91 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // never a security surface — viewers self-report. Pruned by TTL on read.
   const presence = new Map<
     string,
-    { viewer: string; agent: string; cols: number; rows: number; sel: string | null; ts: number }
+    {
+      viewer: string;
+      agent: string;
+      cols: number;
+      rows: number;
+      sel: string | null;
+      cap: SizeCap | null;
+      ts: number;
+    }
   >();
   const PRESENCE_TTL_MS = 12_000;
 
+  // ── PTY size negotiation — tmux's "smallest client wins" ──────────────────
+  // Writable viewers report their readable capacity (`cap`) alongside their
+  // presence; we resize the agent's PTY to the elementwise min across live caps
+  // (see sizeNego.ts), so a phone gets a grid it can read while wider viewers
+  // letterbox the shared canvas. Uses the same winsize-file + SIGWINCH path as
+  // POST /api/resize. When the last cap leaves (viewer switched agent, tab
+  // died → TTL), the size is withdrawn: the file is deleted ONLY if its content
+  // is still our own last write (so `ay attach`'s pushed size is never
+  // clobbered) and the wrapper falls back to the real tty size.
+  const negoApplied = new Map<number, { cols: number; rows: number; content: string }>();
+  const negoTimers = new Map<number, ReturnType<typeof setTimeout>>();
+  const NEGO_DEBOUNCE_MS = 350;
+  const winsizePathFor = (pid: number) =>
+    path.join(
+      process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes"),
+      "winsize",
+      String(pid),
+    );
+  const liveCapsFor = (pid: number): SizeCap[] => {
+    const now = Date.now();
+    const caps: SizeCap[] = [];
+    for (const v of presence.values())
+      if (now - v.ts <= PRESENCE_TTL_MS && String(v.agent) === String(pid) && v.cap)
+        caps.push(v.cap);
+    return caps;
+  };
+  const applyNego = async (pid: number) => {
+    negoTimers.delete(pid);
+    const eff = negotiateSize(liveCapsFor(pid));
+    const file = winsizePathFor(pid);
+    const prev = negoApplied.get(pid);
+    try {
+      if (eff) {
+        if (prev && prev.cols === eff.cols && prev.rows === eff.rows) return;
+        const content = `${eff.cols} ${eff.rows} ${Date.now()}\n`;
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, content);
+        negoApplied.set(pid, { ...eff, content });
+      } else {
+        if (!prev) return;
+        negoApplied.delete(pid);
+        try {
+          // withdraw only what we wrote — a different content means ay attach
+          // (or a direct /api/resize) owns the size now; leave it alone.
+          if ((await readFile(file, "utf-8")) !== prev.content) return;
+          await unlink(file);
+        } catch {
+          return; // already gone — nothing to signal
+        }
+      }
+      try {
+        process.kill(pid, "SIGWINCH");
+      } catch {
+        /* agent gone */
+      }
+    } catch {
+      /* best-effort: a failed write just leaves the previous size in place */
+    }
+  };
+  const scheduleNego = (pid: number) => {
+    if (!Number.isFinite(pid) || pid <= 0 || negoTimers.has(pid)) return;
+    negoTimers.set(
+      pid,
+      setTimeout(() => void applyNego(pid), NEGO_DEBOUNCE_MS),
+    );
+  };
+  // TTL grow-back sweep: a viewer that vanished without clearing its presence
+  // (tab killed, phone locked) stops refreshing; once its entry expires the
+  // negotiated size must be recomputed even though no presence POST arrives.
+  setInterval(() => {
+    for (const pid of negoApplied.keys()) scheduleNego(pid);
+  }, 5_000);
+
   // The whole API as a plain handler: served over HTTP by Bun.serve (--http)
   // and called in-process by the WebRTC bridge (--webrtc) — the latter needs
   // no TCP port at all.
@@ -2330,6 +2421,10 @@ export async function cmdServe(rest: string[]): Promise<number> {
           pid: record.pid,
           cols: size?.cols ?? null,
           rows: size?.rows ?? null,
+          // This host negotiates the PTY size from viewer capacities (presence
+          // `cap`) — a capable console should report its cap instead of pushing
+          // /api/resize directly, so viewers stop fighting last-writer-wins.
+          nego: true,
         });
       } catch (e) {
         return new Response((e as Error).message, { status: 404 });
@@ -2735,6 +2830,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
         cols?: number;
         rows?: number;
         sel?: string;
+        cap?: { cols?: number; rows?: number };
       };
       try {
         b = (await req.json()) as typeof b;
@@ -2743,6 +2839,9 @@ export async function cmdServe(rest: string[]): Promise<number> {
       }
       const viewer = String(b.viewer ?? "").slice(0, 64);
       if (!viewer) return new Response("missing viewer", { status: 400 });
+      // The agent this viewer WAS on — if the entry moves (agent switch) or
+      // clears, that agent's negotiated size must be recomputed (grow-back).
+      const prevAgent = presence.get(viewer)?.agent;
       if (b.agent == null) presence.delete(viewer);
       else
         presence.set(viewer, {
@@ -2751,8 +2850,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
           cols: Math.max(0, Math.floor(Number(b.cols) || 0)),
           rows: Math.max(0, Math.floor(Number(b.rows) || 0)),
           sel: typeof b.sel === "string" ? b.sel.slice(0, 200) : null,
+          cap: sanitizeCap(b.cap),
           ts: Date.now(),
         });
+      if (b.agent != null) scheduleNego(Number(b.agent));
+      if (prevAgent != null && String(prevAgent) !== String(b.agent ?? ""))
+        scheduleNego(Number(prevAgent));
       return new Response(null, { status: 204 });
     }
     // GET /api/presence — all live viewers (TTL-pruned), for "who's watching".