agent-yes 1.206.0 → 1.207.0

package/dist/{SUPPORTED_CLIS-DQSgURGW.js → SUPPORTED_CLIS-B1CDJwYn.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-DnqRreF4.js";
+import { t as CLIS_CONFIG } from "./ts-DZWZvbLM.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-DQSgURGW.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-B1CDJwYn.js.map

package/dist/SUPPORTED_CLIS-vH8hvcZr.js

@@ -0,0 +1,9 @@
+import "./ts-DZWZvbLM.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-C2CV9VOX.js";
+import "./pidStore-BIvsBQ8X.js";
+import "./globalPidIndex-CoNr7tS8.js";
+import "./messageLog-CxrKJj77.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-B1CDJwYn.js";
+
+export { SUPPORTED_CLIS };

package/dist/{agentShare-k8224qiZ.js → agentShare-DdEbHtAn.js}

@@ -2,7 +2,7 @@ import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";
 import "./configShared-aKTg-sa5.js";
-import { M as resolveOne } from "./subcommands-DkrMRVNh.js";
+import { M as resolveOne } from "./subcommands-6AQ8egRn.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-Cim0dBU7.js";
@@ -229,4 +229,4 @@ function transformEvent(rawEvent, agentId, forwarded) {
 
 //#endregion
 export { createScopedShare, listShares, revokeAllShares, revokeShare };
-//# sourceMappingURL=agentShare-k8224qiZ.js.map
+//# sourceMappingURL=agentShare-DdEbHtAn.js.map

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-d5c6_vgS.js";
-import { n as getRustBinary } from "./rustBinary-BjRvvEs8.js";
+import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-C2CV9VOX.js";
+import { n as getRustBinary } from "./rustBinary-CuBIr-zX.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
@@ -285,7 +285,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DCGZjr4t.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-CeRH9-_h.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		await cmdHelp(managerCommands);
 		process.exit(0);
@@ -327,7 +327,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CQ6e94ln.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-vH8hvcZr.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DnqRreF4.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DZWZvbLM.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-d5c6_vgS.js";
+import "./versionChecker-C2CV9VOX.js";
 import "./pidStore-BIvsBQ8X.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";

package/dist/{notifyDaemon-BbVnNvlo.js → notifyDaemon-DivHVzZx.js}

@@ -2,7 +2,7 @@ import { n as logger } from "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";
 import "./configShared-aKTg-sa5.js";
-import { $ as daemonLockOwnerPath, G as gcInboxes, J as listInboxParents, K as hostId, Q as daemonLockDir, S as listRecords, W as appendEvent, X as readInbox, Y as liveWatchers, Z as shouldStealLock, _ as isPidAlive, c as deriveLiveState, et as notifyDir, k as renderLogTailLines } from "./subcommands-DkrMRVNh.js";
+import { $ as daemonLockOwnerPath, G as gcInboxes, J as listInboxParents, K as hostId, Q as daemonLockDir, S as listRecords, W as appendEvent, X as readInbox, Y as liveWatchers, Z as shouldStealLock, _ as isPidAlive, c as deriveLiveState, et as notifyDir, k as renderLogTailLines } from "./subcommands-6AQ8egRn.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-Cim0dBU7.js";
@@ -589,4 +589,4 @@ async function ensureDaemon() {
 
 //#endregion
 export { daemonStatus, ensureDaemon, requestDaemonStop, runDaemon };
-//# sourceMappingURL=notifyDaemon-BbVnNvlo.js.map
+//# sourceMappingURL=notifyDaemon-DivHVzZx.js.map

package/dist/{rustBinary-BjRvvEs8.js → rustBinary-CuBIr-zX.js}

@@ -1,4 +1,4 @@
-import { r as getInstalledPackage } from "./versionChecker-d5c6_vgS.js";
+import { r as getInstalledPackage } from "./versionChecker-C2CV9VOX.js";
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
@@ -225,4 +225,4 @@ async function getRustBinary(options = {}) {
 
 //#endregion
 export { getRustBinary as n, findSpawnHiddenLauncher as t };
-//# sourceMappingURL=rustBinary-BjRvvEs8.js.map
+//# sourceMappingURL=rustBinary-CuBIr-zX.js.map

package/dist/{schedule-DJ-v4yVa.js → schedule-Bg_CDt2j.js}

@@ -1,10 +1,10 @@
-import "./ts-DnqRreF4.js";
+import "./ts-DZWZvbLM.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-d5c6_vgS.js";
+import "./versionChecker-C2CV9VOX.js";
 import "./pidStore-BIvsBQ8X.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DQSgURGW.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-B1CDJwYn.js";
 import { d as resolveSpawnCwd } from "./workspaceConfig-CjaRvTjf.js";
 import { n as liveEnv, t as ensureNodeRuntime } from "./nodeRuntime-CwNJuwH5.js";
 import { createHash } from "node:crypto";
@@ -151,4 +151,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-DJ-v4yVa.js.map
+//# sourceMappingURL=schedule-Bg_CDt2j.js.map

package/dist/{serve-crLypY_c.js → serve-B-ZCy67S.js}

@@ -1,15 +1,15 @@
-import "./ts-DnqRreF4.js";
+import "./ts-DZWZvbLM.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-d5c6_vgS.js";
-import { t as findSpawnHiddenLauncher } from "./rustBinary-BjRvvEs8.js";
+import { r as getInstalledPackage } from "./versionChecker-C2CV9VOX.js";
+import { t as findSpawnHiddenLauncher } from "./rustBinary-CuBIr-zX.js";
 import { t as agentYesHome$1 } from "./agentYesHome-CtHb5b71.js";
 import "./pidStore-BIvsBQ8X.js";
 import { a as updateGlobalPidStatus } from "./globalPidIndex-CoNr7tS8.js";
 import { r as recordInbox } from "./messageLog-CxrKJj77.js";
 import { t as pgidForWrapper } from "./reaper-BUHCyxdF.js";
 import "./configShared-aKTg-sa5.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DQSgURGW.js";
-import { A as renderRawLog, D as recentMessageEdges, E as readPtysize, L as snapshotStatus, M as resolveOne, O as recentReadEdges, S as listRecords, T as readNotes, U as writeToIpc, b as isUserTyping, f as extractNeedsInput, k as renderLogTailLines, l as deriveLiveStatus, o as controlCodeFromName, p as extractTaskCounts, q as isTransientLockMkdirError, tt as TYPING_BADGE, u as extractBadges } from "./subcommands-DkrMRVNh.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-B1CDJwYn.js";
+import { A as renderRawLog, D as recentMessageEdges, E as readPtysize, L as snapshotStatus, M as resolveOne, O as recentReadEdges, S as listRecords, T as readNotes, U as writeToIpc, b as isUserTyping, f as extractNeedsInput, k as renderLogTailLines, l as deriveLiveStatus, o as controlCodeFromName, p as extractTaskCounts, q as isTransientLockMkdirError, tt as TYPING_BADGE, u as extractBadges } from "./subcommands-6AQ8egRn.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-Cim0dBU7.js";
@@ -207,6 +207,48 @@ async function acquireWebrtcHostLock(opts) {
 	}
 }
 
+//#endregion
+//#region ts/sizeNego.ts
+/** Reject junk caps (a viewer mid-layout can report 0×0 or absurd numbers). */
+const CAP_MIN_COLS = 20;
+const CAP_MIN_ROWS = 5;
+const CAP_MAX_COLS = 500;
+const CAP_MAX_ROWS = 200;
+/** Never negotiate below this — TUIs (claude, codex) break down when the grid
+* gets absurdly narrow, so a tiny watch-sized viewer can't wedge the agent. */
+const NEGO_FLOOR_COLS = 40;
+const NEGO_FLOOR_ROWS = 10;
+/** Parse a presence-reported cap into a sane SizeCap, or null if unusable. */
+function sanitizeCap(cap) {
+	if (typeof cap !== "object" || cap === null) return null;
+	const c = Math.floor(Number(cap.cols) || 0);
+	const r = Math.floor(Number(cap.rows) || 0);
+	if (c < CAP_MIN_COLS || c > CAP_MAX_COLS) return null;
+	if (r < CAP_MIN_ROWS || r > CAP_MAX_ROWS) return null;
+	return {
+		cols: c,
+		rows: r
+	};
+}
+/**
+* Elementwise minimum over the live viewers' capacities, clamped to the floor.
+* Returns null when no viewer reports a capacity — meaning "withdraw the
+* negotiated size, let the real tty size rule again".
+*/
+function negotiateSize(caps) {
+	let cols = Infinity;
+	let rows = Infinity;
+	for (const cap of caps) {
+		if (cap.cols < cols) cols = cap.cols;
+		if (cap.rows < rows) rows = cap.rows;
+	}
+	if (!Number.isFinite(cols) || !Number.isFinite(rows)) return null;
+	return {
+		cols: Math.max(NEGO_FLOOR_COLS, cols),
+		rows: Math.max(NEGO_FLOOR_ROWS, rows)
+	};
+}
+
 //#endregion
 //#region ts/strayServe.ts
 const MANAGEMENT_COMMAND_RE = /\b(?:install|uninstall|status|logs|restart)\b/;
@@ -387,7 +429,7 @@ function loginShellEnv() {
 		const delim = "_AY_SHELL_ENV_DELIM_";
 		const out = Bun.spawnSync([
 			shell,
-			"-ilc",
+			"-lc",
 			`printf %s "${delim}"; env -0; printf %s "${delim}"`
 		], {
 			stdin: "ignore",
@@ -1467,6 +1509,53 @@ Options:
 	};
 	const presence = /* @__PURE__ */ new Map();
 	const PRESENCE_TTL_MS = 12e3;
+	const negoApplied = /* @__PURE__ */ new Map();
+	const negoTimers = /* @__PURE__ */ new Map();
+	const NEGO_DEBOUNCE_MS = 350;
+	const winsizePathFor = (pid) => path.join(process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes"), "winsize", String(pid));
+	const liveCapsFor = (pid) => {
+		const now = Date.now();
+		const caps = [];
+		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) => {
+		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 {
+					if (await readFile(file, "utf-8") !== prev.content) return;
+					await unlink(file);
+				} catch {
+					return;
+				}
+			}
+			try {
+				process.kill(pid, "SIGWINCH");
+			} catch {}
+		} catch {}
+	};
+	const scheduleNego = (pid) => {
+		if (!Number.isFinite(pid) || pid <= 0 || negoTimers.has(pid)) return;
+		negoTimers.set(pid, setTimeout(() => void applyNego(pid), NEGO_DEBOUNCE_MS));
+	};
+	setInterval(() => {
+		for (const pid of negoApplied.keys()) scheduleNego(pid);
+	}, 5e3);
 	const apiFetch = async (req) => {
 		if (!checkAuth(req, token)) return new Response("Unauthorized", { status: 401 });
 		const url = new URL(req.url);
@@ -1779,7 +1868,7 @@ Options:
 			}
 		});
 		if (req.method === "GET" && p === "/api/ws") {
-			const ws = await import("./ws-BmHpWaG_.js");
+			const ws = await import("./ws-CGNmxCPD.js");
 			try {
 				await ws.loadProvision();
 			} catch (e) {
@@ -1799,7 +1888,7 @@ Options:
 		if (req.method === "GET" && p === "/api/ws/status") {
 			const dirRaw = url.searchParams.get("path");
 			if (!dirRaw) return new Response("missing ?path=<workspace dir>", { status: 400 });
-			const ws = await import("./ws-BmHpWaG_.js");
+			const ws = await import("./ws-CGNmxCPD.js");
 			let prov;
 			try {
 				prov = await ws.loadProvision();
@@ -1864,7 +1953,8 @@ Options:
 				return Response.json({
 					pid: record.pid,
 					cols: size?.cols ?? null,
-					rows: size?.rows ?? null
+					rows: size?.rows ?? null,
+					nego: true
 				});
 			} catch (e) {
 				return new Response(e.message, { status: 404 });
@@ -2145,6 +2235,7 @@ Options:
 			}
 			const viewer = String(b.viewer ?? "").slice(0, 64);
 			if (!viewer) return new Response("missing viewer", { status: 400 });
+			const prevAgent = presence.get(viewer)?.agent;
 			if (b.agent == null) presence.delete(viewer);
 			else presence.set(viewer, {
 				viewer,
@@ -2152,8 +2243,11 @@ Options:
 				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 });
 		}
 		if (req.method === "GET" && p === "/api/presence") {
@@ -2355,7 +2449,7 @@ Options:
 			const perm = body.perm ?? "r";
 			if (perm !== "r" && perm !== "rw") return new Response(`invalid perm ${perm} (want r or rw)`, { status: 400 });
 			try {
-				const { createScopedShare } = await import("./agentShare-k8224qiZ.js");
+				const { createScopedShare } = await import("./agentShare-DdEbHtAn.js");
 				const share = await createScopedShare({
 					agent: body.agent,
 					perm,
@@ -2370,12 +2464,12 @@ Options:
 			}
 		}
 		if (req.method === "GET" && p === "/api/shares") {
-			const { listShares } = await import("./agentShare-k8224qiZ.js");
+			const { listShares } = await import("./agentShare-DdEbHtAn.js");
 			return Response.json(listShares());
 		}
 		const revokeM = /^\/api\/share\/([^/]+)$/.exec(p);
 		if (req.method === "DELETE" && revokeM) {
-			const { revokeShare } = await import("./agentShare-k8224qiZ.js");
+			const { revokeShare } = await import("./agentShare-DdEbHtAn.js");
 			const ok = revokeShare(decodeURIComponent(revokeM[1]));
 			return new Response(ok ? "revoked" : "no such share", { status: ok ? 200 : 404 });
 		}
@@ -2561,7 +2655,7 @@ Options:
 	const shutdown = (resolve) => {
 		if (heartbeat) clearInterval(heartbeat);
 		closeShare?.();
-		import("./agentShare-k8224qiZ.js").then((m) => m.revokeAllShares()).catch(() => {});
+		import("./agentShare-DdEbHtAn.js").then((m) => m.revokeAllShares()).catch(() => {});
 		server?.stop();
 		Promise.resolve(releaseHostLock?.()).catch(() => {}).then(resolve);
 	};
@@ -2574,4 +2668,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-crLypY_c.js.map
+//# sourceMappingURL=serve-B-ZCy67S.js.map

package/dist/{setup-BPNkeSmY.js → setup-D6UBzk4-.js}

@@ -32,7 +32,7 @@ async function cmdSetup(rest) {
 	if (!existsSync(abs)) process.stderr.write(`  note: that directory doesn't exist yet — create it, or agents spawned there will fail\n`);
 	if (noShare) return 0;
 	process.stdout.write(`\nsharing this machine to agent-yes.com…\n`);
-	const { cmdServe } = await import("./serve-crLypY_c.js");
+	const { cmdServe } = await import("./serve-B-ZCy67S.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-BPNkeSmY.js.map
+//# sourceMappingURL=setup-D6UBzk4-.js.map

package/dist/{subcommands-DkrMRVNh.js → subcommands-6AQ8egRn.js}

@@ -1237,19 +1237,19 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-crLypY_c.js");
+				const { cmdServe } = await import("./serve-B-ZCy67S.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-BPNkeSmY.js");
+				const { cmdSetup } = await import("./setup-D6UBzk4-.js");
 				return cmdSetup(rest);
 			}
 			case "ws": {
-				const { cmdWs } = await import("./ws-BmHpWaG_.js");
+				const { cmdWs } = await import("./ws-CGNmxCPD.js");
 				return cmdWs(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-DJ-v4yVa.js");
+				const { cmdSchedule } = await import("./schedule-Bg_CDt2j.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -4269,7 +4269,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-BbVnNvlo.js");
+		const { ensureDaemon } = await import("./notifyDaemon-DivHVzZx.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4343,7 +4343,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-BbVnNvlo.js");
+	const daemon = await import("./notifyDaemon-DivHVzZx.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4370,4 +4370,4 @@ async function cmdNotifyd(rest) {
 
 //#endregion
 export { daemonLockOwnerPath as $, renderRawLog as A, submitAndConfirm as B, matchKeyword as C, recentMessageEdges as D, readPtysize as E, restartHintLines as F, gcInboxes as G, writeKeysPaced as H, runSubcommand as I, listInboxParents as J, hostId as K, snapshotStatus as L, resolveOne as M, resolveReadWindow as N, recentReadEdges as O, resolveResumeArgs as P, daemonLockDir as Q, stdinActivityPath as R, listRecords as S, readNotes as T, writeToIpc as U, waitForLogQuiet as V, appendEvent as W, readInbox as X, liveWatchers as Y, shouldStealLock as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, notifyDir as et, extractNeedsInput as f, isExitRequest as g, isAgentStuck as h, backoffWhileTyping as i, renderRawLogLines as j, renderLogTailLines as k, deriveLiveStatus as l, finalizedLines as m, READ_PAGE_DEFAULT as n, controlCodeFromName as o, extractTaskCounts as p, isTransientLockMkdirError as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, TYPING_BADGE as tt, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, stopTipForCli as z };
-//# sourceMappingURL=subcommands-DkrMRVNh.js.map
+//# sourceMappingURL=subcommands-6AQ8egRn.js.map

package/dist/{subcommands-DCGZjr4t.js → subcommands-CeRH9-_h.js}

@@ -2,7 +2,7 @@ import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";
 import "./configShared-aKTg-sa5.js";
-import { A as renderRawLog, B as submitAndConfirm, C as matchKeyword, D as recentMessageEdges, E as readPtysize, F as restartHintLines, H as writeKeysPaced, I as runSubcommand, L as snapshotStatus, M as resolveOne, N as resolveReadWindow, O as recentReadEdges, P as resolveResumeArgs, R as stdinActivityPath, S as listRecords, T as readNotes, U as writeToIpc, V as waitForLogQuiet, _ as isPidAlive, a as cmdHelp, b as isUserTyping, c as deriveLiveState, d as extractMenu, f as extractNeedsInput, g as isExitRequest, h as isAgentStuck, i as backoffWhileTyping, j as renderRawLogLines, k as renderLogTailLines, l as deriveLiveStatus, m as finalizedLines, n as READ_PAGE_DEFAULT, o as controlCodeFromName, p as extractTaskCounts, r as TYPING_WINDOW_MS, s as cursorAbs, t as GRACEFUL_EXIT_COMMANDS, u as extractBadges, v as isSlashCommand, w as menuSelectKeys, x as lastStdinAt, y as isSubcommand, z as stopTipForCli } from "./subcommands-DkrMRVNh.js";
+import { A as renderRawLog, B as submitAndConfirm, C as matchKeyword, D as recentMessageEdges, E as readPtysize, F as restartHintLines, H as writeKeysPaced, I as runSubcommand, L as snapshotStatus, M as resolveOne, N as resolveReadWindow, O as recentReadEdges, P as resolveResumeArgs, R as stdinActivityPath, S as listRecords, T as readNotes, U as writeToIpc, V as waitForLogQuiet, _ as isPidAlive, a as cmdHelp, b as isUserTyping, c as deriveLiveState, d as extractMenu, f as extractNeedsInput, g as isExitRequest, h as isAgentStuck, i as backoffWhileTyping, j as renderRawLogLines, k as renderLogTailLines, l as deriveLiveStatus, m as finalizedLines, n as READ_PAGE_DEFAULT, o as controlCodeFromName, p as extractTaskCounts, r as TYPING_WINDOW_MS, s as cursorAbs, t as GRACEFUL_EXIT_COMMANDS, u as extractBadges, v as isSlashCommand, w as menuSelectKeys, x as lastStdinAt, y as isSubcommand, z as stopTipForCli } from "./subcommands-6AQ8egRn.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-Cim0dBU7.js";

package/dist/{ts-DnqRreF4.js → ts-DZWZvbLM.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-d5c6_vgS.js";
+import { r as getInstalledPackage } from "./versionChecker-C2CV9VOX.js";
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CNMl13dC.js";
 import { t as PidStore } from "./pidStore-BIvsBQ8X.js";
@@ -1901,4 +1901,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-DnqRreF4.js.map
+//# sourceMappingURL=ts-DZWZvbLM.js.map

package/dist/{versionChecker-d5c6_vgS.js → versionChecker-C2CV9VOX.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.206.0";
+var version = "1.207.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-d5c6_vgS.js.map
+//# sourceMappingURL=versionChecker-C2CV9VOX.js.map

package/dist/{ws-BmHpWaG_.js → ws-CGNmxCPD.js}

@@ -2,7 +2,7 @@ import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./messageLog-CxrKJj77.js";
 import "./configShared-aKTg-sa5.js";
-import { S as listRecords } from "./subcommands-DkrMRVNh.js";
+import { S as listRecords } from "./subcommands-6AQ8egRn.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-Cim0dBU7.js";
@@ -418,4 +418,4 @@ async function cmdWs(args) {
 
 //#endregion
 export { WS_JSON_SCHEMA, cmdWs, collectWorkspaces, isPathInside, loadProvision, workspaceStatus };
-//# sourceMappingURL=ws-BmHpWaG_.js.map
+//# sourceMappingURL=ws-CGNmxCPD.js.map

package/lab/ui/console-logic.js

@@ -701,6 +701,26 @@ export function fitTransform(gridW, gridH, paneW, paneH) {
   return s > 0.985 && s < 1.04 ? "none" : "scale(" + s.toFixed(4) + ")";
 }
 
+// Centered variant: same scale selection as fitTransform, plus a translate that
+// centers the scaled grid in the pane (fit-width → vertically centered,
+// fit-height → horizontally centered). transform-origin stays top-left, so the
+// translate is in pane px and consumers mapping grid→screen coords (peer
+// overlays) can read the offset back off this same object. "none" (the crisp
+// driver path) never gets a translate — grid ≈ pane, nothing to center.
+export function fitTransformCentered(gridW, gridH, paneW, paneH) {
+  const t = fitTransform(gridW, gridH, paneW, paneH);
+  if (t === "none") return { transform: "none", scale: 1, dx: 0, dy: 0 };
+  const s = Math.min(paneW / gridW, paneH / gridH);
+  const dx = Math.max(0, (paneW - gridW * s) / 2);
+  const dy = Math.max(0, (paneH - gridH * s) / 2);
+  return {
+    transform: `translate(${dx.toFixed(1)}px, ${dy.toFixed(1)}px) ` + t,
+    scale: s,
+    dx,
+    dy,
+  };
+}
+
 // Browser-tab title: "<glyph> <selected agent title> - agent-yes", or the bare
 // console title when nothing is selected (blank/whitespace name). The leading
 // glyph mirrors the agent's status dot — ⌨ needs_input ("your turn"), ⚠ stuck,

package/lab/ui/index.html

@@ -2173,7 +2173,7 @@
         selFromBottom,
         parseSel,
         selSegments,
-        fitTransform,
+        fitTransformCentered,
         docTitle,
         omniScore,
       } from "./console-logic.js";
@@ -2230,7 +2230,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 +3140,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 +3292,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 +3311,7 @@
             cols: term.cols,
             rows: term.rows,
             sel: selR,
+            cap,
           })
           .catch(() => {});
       }
@@ -3600,14 +3628,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) {
@@ -5187,6 +5237,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 +5285,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 +5297,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 {}
@@ -5413,13 +5488,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 +5505,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 +7115,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 +7167,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.207.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,87 @@ 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 +2417,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 +2826,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 +2835,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 +2846,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".

package/ts/serveLock.spec.ts

@@ -140,7 +140,8 @@ describe("acquireWebrtcHostLock — held-lock lifecycle", () => {
   });
 
   const ownerFile = () => path.join(home, "webrtc-host.lock", "owner.json");
-  const readOwnerFile = async () => JSON.parse(await readFile(ownerFile(), "utf-8")) as ServeLockOwner;
+  const readOwnerFile = async () =>
+    JSON.parse(await readFile(ownerFile(), "utf-8")) as ServeLockOwner;
 
   it("heartbeats refresh beat_at while held", async () => {
     const got = await acquireWebrtcHostLock({ graceMs: 0, beatMs: 40 });
@@ -190,19 +191,19 @@ describe("acquireWebrtcHostLock — held-lock lifecycle", () => {
   it.skipIf(process.platform === "win32")(
     "escalates to SIGKILL when the owner ignores SIGTERM",
     async () => {
-    const { spawn } = await import("node:child_process");
-    const stubborn = spawn("/bin/sh", ["-c", "trap '' TERM; sleep 30"], { stdio: "ignore" });
-    const pid = stubborn.pid!;
-    await new Promise((r) => setTimeout(r, 100)); // let the trap install
-    const { mkdir: mkd, writeFile: wf } = await import("fs/promises");
-    await mkd(path.join(home, "webrtc-host.lock"), { recursive: true });
-    await wf(ownerFile(), JSON.stringify({ pid, started_at: Date.now(), beat_at: Date.now() }));
-
-    const got = await acquireWebrtcHostLock({ takeover: true, graceMs: 0, takeoverWaitMs: 200 });
-    expect(got.ok).toBe(true);
-    if (got.ok) releases.push(got.release);
-    await new Promise((r) => setTimeout(r, 100));
-    expect(stubborn.signalCode).toBe("SIGKILL");
+      const { spawn } = await import("node:child_process");
+      const stubborn = spawn("/bin/sh", ["-c", "trap '' TERM; sleep 30"], { stdio: "ignore" });
+      const pid = stubborn.pid!;
+      await new Promise((r) => setTimeout(r, 100)); // let the trap install
+      const { mkdir: mkd, writeFile: wf } = await import("fs/promises");
+      await mkd(path.join(home, "webrtc-host.lock"), { recursive: true });
+      await wf(ownerFile(), JSON.stringify({ pid, started_at: Date.now(), beat_at: Date.now() }));
+
+      const got = await acquireWebrtcHostLock({ takeover: true, graceMs: 0, takeoverWaitMs: 200 });
+      expect(got.ok).toBe(true);
+      if (got.ok) releases.push(got.release);
+      await new Promise((r) => setTimeout(r, 100));
+      expect(stubborn.signalCode).toBe("SIGKILL");
     },
   );
 

package/ts/sizeNego.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import {
+  NEGO_FLOOR_COLS,
+  NEGO_FLOOR_ROWS,
+  negotiateSize,
+  sanitizeCap,
+} from "./sizeNego.ts";
+
+describe("sanitizeCap", () => {
+  it("accepts a normal viewer capacity", () => {
+    expect(sanitizeCap({ cols: 80, rows: 24 })).toEqual({ cols: 80, rows: 24 });
+  });
+  it("floors fractional values", () => {
+    expect(sanitizeCap({ cols: 80.9, rows: 24.7 })).toEqual({ cols: 80, rows: 24 });
+  });
+  it("rejects null / non-object / missing fields", () => {
+    expect(sanitizeCap(null)).toBeNull();
+    expect(sanitizeCap(undefined)).toBeNull();
+    expect(sanitizeCap("80x24")).toBeNull();
+    expect(sanitizeCap({})).toBeNull();
+    expect(sanitizeCap({ cols: 80 })).toBeNull();
+  });
+  it("rejects out-of-range junk (mid-layout 0x0, absurd sizes)", () => {
+    expect(sanitizeCap({ cols: 0, rows: 0 })).toBeNull();
+    expect(sanitizeCap({ cols: 10, rows: 24 })).toBeNull(); // below min cols
+    expect(sanitizeCap({ cols: 80, rows: 2 })).toBeNull(); // below min rows
+    expect(sanitizeCap({ cols: 9999, rows: 24 })).toBeNull();
+    expect(sanitizeCap({ cols: 80, rows: 9999 })).toBeNull();
+    expect(sanitizeCap({ cols: NaN, rows: 24 })).toBeNull();
+  });
+});
+
+describe("negotiateSize", () => {
+  it("returns null with no caps (withdraw → tty size rules)", () => {
+    expect(negotiateSize([])).toBeNull();
+  });
+  it("single viewer: adopts its capacity", () => {
+    expect(negotiateSize([{ cols: 133, rows: 40 }])).toEqual({ cols: 133, rows: 40 });
+  });
+  it("phone + desktop: elementwise min (the tmux rule)", () => {
+    // phone is narrow but tall, desktop is wide but short → min of each axis
+    const phone = { cols: 51, rows: 60 };
+    const desktop = { cols: 200, rows: 50 };
+    expect(negotiateSize([phone, desktop])).toEqual({ cols: 51, rows: 50 });
+  });
+  it("clamps to the floor so a tiny viewer can't wedge the agent", () => {
+    expect(negotiateSize([{ cols: 20, rows: 5 }])).toEqual({
+      cols: NEGO_FLOOR_COLS,
+      rows: NEGO_FLOOR_ROWS,
+    });
+  });
+  it("three viewers: min wins per axis", () => {
+    expect(
+      negotiateSize([
+        { cols: 100, rows: 30 },
+        { cols: 80, rows: 50 },
+        { cols: 120, rows: 24 },
+      ]),
+    ).toEqual({ cols: 80, rows: 24 });
+  });
+});

package/ts/sizeNego.ts

@@ -0,0 +1,59 @@
+/**
+ * Multi-viewer PTY size negotiation — the tmux "smallest client wins" rule.
+ *
+ * Every writable web viewer reports its readable capacity (the cols×rows its
+ * pane can render at its chosen font size) via /api/presence. The host resizes
+ * the agent's PTY to the elementwise minimum across live viewers, so the
+ * narrowest screen (a phone) gets a grid it can actually read while wider
+ * viewers simply render fewer columns. When the last capacity-reporting viewer
+ * leaves, the negotiated size is withdrawn and the PTY falls back to the real
+ * terminal's size (the wrapper re-reads the tty once the winsize file is gone).
+ *
+ * Pure logic only — the serve layer owns presence bookkeeping, the winsize
+ * file, and SIGWINCH delivery.
+ */
+
+export interface SizeCap {
+  cols: number;
+  rows: number;
+}
+
+/** Reject junk caps (a viewer mid-layout can report 0×0 or absurd numbers). */
+const CAP_MIN_COLS = 20;
+const CAP_MIN_ROWS = 5;
+const CAP_MAX_COLS = 500;
+const CAP_MAX_ROWS = 200;
+
+/** Never negotiate below this — TUIs (claude, codex) break down when the grid
+ * gets absurdly narrow, so a tiny watch-sized viewer can't wedge the agent. */
+export const NEGO_FLOOR_COLS = 40;
+export const NEGO_FLOOR_ROWS = 10;
+
+/** Parse a presence-reported cap into a sane SizeCap, or null if unusable. */
+export function sanitizeCap(cap: unknown): SizeCap | null {
+  if (typeof cap !== "object" || cap === null) return null;
+  const c = Math.floor(Number((cap as SizeCap).cols) || 0);
+  const r = Math.floor(Number((cap as SizeCap).rows) || 0);
+  if (c < CAP_MIN_COLS || c > CAP_MAX_COLS) return null;
+  if (r < CAP_MIN_ROWS || r > CAP_MAX_ROWS) return null;
+  return { cols: c, rows: r };
+}
+
+/**
+ * Elementwise minimum over the live viewers' capacities, clamped to the floor.
+ * Returns null when no viewer reports a capacity — meaning "withdraw the
+ * negotiated size, let the real tty size rule again".
+ */
+export function negotiateSize(caps: ReadonlyArray<SizeCap>): SizeCap | null {
+  let cols = Infinity;
+  let rows = Infinity;
+  for (const cap of caps) {
+    if (cap.cols < cols) cols = cap.cols;
+    if (cap.rows < rows) rows = cap.rows;
+  }
+  if (!Number.isFinite(cols) || !Number.isFinite(rows)) return null;
+  return {
+    cols: Math.max(NEGO_FLOOR_COLS, cols),
+    rows: Math.max(NEGO_FLOOR_ROWS, rows),
+  };
+}

package/ts/ws.spec.ts

@@ -468,16 +468,14 @@ describe("collectWorkspaces / workspaceStatus (mocked provision)", () => {
   beforeEach(() => {
     root = realpathSync(mkdtempSync(path.join(os.tmpdir(), "ay-ws-api-")));
     prov.wsRoot = root;
-    prov.readStatus
-      .mockReset()
-      .mockResolvedValue({
-        branch: "main",
-        head: "abc123",
-        ahead: 1,
-        behind: 0,
-        dirty: true,
-        hasUpstream: true,
-      });
+    prov.readStatus.mockReset().mockResolvedValue({
+      branch: "main",
+      head: "abc123",
+      ahead: 1,
+      behind: 0,
+      dirty: true,
+      hasUpstream: true,
+    });
     homeBackup = process.env.AGENT_YES_HOME;
     process.env.AGENT_YES_HOME = path.join(root, ".ay-home");
   });

package/dist/SUPPORTED_CLIS-CQ6e94ln.js

@@ -1,9 +0,0 @@
-import "./ts-DnqRreF4.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-d5c6_vgS.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import "./messageLog-CxrKJj77.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DQSgURGW.js";
-
-export { SUPPORTED_CLIS };