agent-yes 1.106.0 → 1.108.0

package/dist/SUPPORTED_CLIS-B_gPkhav.js

@@ -0,0 +1,8 @@
+import "./ts-D_sIq4Yv.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-osmGP6ly.js";
+import "./pidStore-DBjlqzo8.js";
+import "./globalPidIndex-yVd3mbsV.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BzuJvKuH.js";
+
+export { SUPPORTED_CLIS };

package/dist/{SUPPORTED_CLIS-O3atAbo5.js → SUPPORTED_CLIS-BzuJvKuH.js}

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

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-CRaHzP0C.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-osmGP6ly.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -482,7 +482,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 {
 	const rawArg = process.argv[2];
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DO3qf62r.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-4tanf24s.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp();
 		process.exit(0);
@@ -515,7 +515,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-BkWXFAho.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-B_gPkhav.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-CFnUatY1.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-D_sIq4Yv.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-CRaHzP0C.js";
+import "./versionChecker-osmGP6ly.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
 

package/dist/{serve-BHk9nQm-.js → serve-D4puI0b2.js}

@@ -1,11 +1,11 @@
-import "./ts-CFnUatY1.js";
+import "./ts-D_sIq4Yv.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-CRaHzP0C.js";
+import "./versionChecker-osmGP6ly.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-O3atAbo5.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BzuJvKuH.js";
 import "./remotes-C3xPRtfg.js";
-import { c as readNotes, f as snapshotStatus, l as renderRawLog, m as writeToIpc, o as listRecords, r as controlCodeFromName, u as resolveOne } from "./subcommands-BImrR-R6.js";
+import { c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, m as snapshotStatus, r as controlCodeFromName, u as readNotes } from "./subcommands-BLPtg1xN.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -552,4 +552,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-BHk9nQm-.js.map
+//# sourceMappingURL=serve-D4puI0b2.js.map

package/dist/subcommands-4tanf24s.js

@@ -0,0 +1,6 @@
+import "./logger-B9h0djqx.js";
+import "./globalPidIndex-yVd3mbsV.js";
+import "./remotes-C3xPRtfg.js";
+import { a as finalizedLines, c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, h as stopTipForCli, i as cursorAbs, l as matchKeyword, m as snapshotStatus, n as cmdHelp, o as isPidAlive, p as runSubcommand, r as controlCodeFromName, s as isSubcommand, t as GRACEFUL_EXIT_COMMANDS, u as readNotes } from "./subcommands-BLPtg1xN.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-BImrR-R6.js → subcommands-BLPtg1xN.js}

@@ -163,7 +163,7 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-BHk9nQm-.js");
+				const { cmdServe } = await import("./serve-D4puI0b2.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
@@ -361,7 +361,7 @@ async function runRemoteLs(remote, opts) {
 	}
 	return 0;
 }
-async function runRemoteRead(remote, mode, follow, n, reconnectTimeoutMs = 12e4) {
+async function runRemoteRead(remote, mode, follow, n, reconnectTimeoutMs = 12e4, _plain = false) {
 	const keyword = remote.keyword ?? "";
 	if (!keyword) {
 		process.stderr.write("remote tail/cat/head requires a keyword (e.g. token@host:port:keyword)\n");
@@ -369,7 +369,8 @@ async function runRemoteRead(remote, mode, follow, n, reconnectTimeoutMs = 12e4)
 	}
 	if (mode === "tail" && follow) {
 		const ac = new AbortController();
-		process.on("SIGINT", () => ac.abort());
+		const disposeSignals = installStreamSignals(() => ac.abort());
+		ac.signal.addEventListener("abort", disposeSignals, { once: true });
 		const deadline = Date.now() + reconnectTimeoutMs;
 		let delay = 1e3;
 		let attempt = 0;
@@ -718,6 +719,10 @@ async function cmdRead(rest, { mode }) {
 	}).option("n", {
 		type: "number",
 		description: "Number of lines (default: 96 for tail/head)"
+	}).option("plain", {
+		type: "boolean",
+		default: false,
+		description: "Line-buffered plain text for pipes/scripts (no ANSI redraws or spinner). Auto-enabled when stdout is not a TTY."
 	}).option("all", {
 		type: "boolean",
 		default: false,
@@ -734,6 +739,8 @@ async function cmdRead(rest, { mode }) {
 		default: 120,
 		description: "Seconds before giving up reconnecting remote SSE (default: 120)"
 	}).help(false).version(false).exitProcess(false).parseAsync();
+	ensureEpipeExit();
+	const plain = Boolean(argv.plain) || !process.stdout.isTTY;
 	const opts = {
 		all: argv.all,
 		active: false,
@@ -747,7 +754,7 @@ async function cmdRead(rest, { mode }) {
 		const nFlag2 = argv.n;
 		const n2 = nFlag2 !== void 0 && Number.isFinite(nFlag2) && nFlag2 > 0 ? Math.floor(nFlag2) : mode === "cat" ? 0 : 96;
 		const reconnectTimeoutMs = (argv["reconnect-timeout"] ?? 120) * 1e3;
-		if (remote) return runRemoteRead(remote, mode, argv.follow, n2, reconnectTimeoutMs);
+		if (remote) return runRemoteRead(remote, mode, argv.follow, n2, reconnectTimeoutMs, plain);
 	}
 	const follow = argv.follow;
 	const nFlag = argv.n;
@@ -772,34 +779,170 @@ async function cmdRead(rest, { mode }) {
 	process.stderr.write(header + "\n");
 	process.stdout.write(rendered);
 	if (!rendered.endsWith("\n")) process.stdout.write("\n");
-	if (follow) {
-		process.stderr.write(`following... (Ctrl-C to stop)\n`);
-		let offset = buf.length;
-		const { watch } = await import("fs");
-		const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
-		const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
-		await new Promise((resolve) => {
-			const watcher = watch(logPath, async () => {
-				const full = await readFile(logPath);
-				if (full.length <= offset) return;
-				const chunk = full.slice(offset);
-				offset = full.length;
-				const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
-				if (text.trim()) process.stdout.write(text.trimStart());
-			});
-			process.on("SIGINT", () => {
-				watcher.close();
-				resolve();
-			});
-		});
-		return 0;
-	}
+	if (follow) return plain ? followPlainLocal(logPath, buf) : followRawLocal(logPath, buf);
 	process.stderr.write(`
   ay ls                                 # list all agents
   ay tail -f ${record.pid}              # follow live output\n  ay send ${record.pid} "next: ..."      # send a prompt\n  ay send ${record.pid} "" --code=ctrl-c # interrupt\n`);
 	return 0;
 }
 /**
+* Exit cleanly when stdout's downstream closes (EPIPE). Node ignores SIGPIPE and
+* surfaces a broken pipe as a stream 'error'; with no listener it throws, and in
+* follow mode the watch loop would otherwise hang. Idempotent — one listener for
+* the life of the process, tagged on stdout so repeated calls (and module
+* reloads in tests) don't pile up listeners.
+*/
+function ensureEpipeExit() {
+	const TAG = "__ayEpipeExit";
+	if (process.stdout[TAG]) return;
+	process.stdout[TAG] = true;
+	process.stdout.on("error", (e) => {
+		if (e?.code === "EPIPE") process.exit(0);
+	});
+}
+/**
+* Install signal handlers for a streaming follower so it terminates promptly
+* under automation, not just on an interactive Ctrl-C. SIGINT/SIGTERM/SIGHUP all
+* run `stop` (so `timeout … ay tail -f` and `kill` both work); a closed stdout
+* (EPIPE) exits cleanly via ensureEpipeExit. Returns a disposer that removes the
+* signal listeners.
+*/
+function installStreamSignals(stop) {
+	ensureEpipeExit();
+	const onSig = () => stop();
+	process.on("SIGINT", onSig);
+	process.on("SIGTERM", onSig);
+	process.on("SIGHUP", onSig);
+	return () => {
+		process.off("SIGINT", onSig);
+		process.off("SIGTERM", onSig);
+		process.off("SIGHUP", onSig);
+	};
+}
+/**
+* Coalescing file watcher: re-reads `logPath` on every change, hands each newly
+* appended byte range to `onChunk`, and never overlaps reads (a change that
+* arrives mid-read is serviced once the current read finishes). `startOffset`
+* is where the already-emitted prefix ends. Resolves when `stop` is signalled.
+*/
+async function watchAppend(logPath, startOffset, onChunk, onStop) {
+	const { watch } = await import("fs");
+	let offset = startOffset;
+	let reading = false;
+	let pending = false;
+	await new Promise((resolve) => {
+		let done = false;
+		const finish = () => {
+			if (done) return;
+			done = true;
+			try {
+				watcher.close();
+			} catch {}
+			dispose();
+			onStop();
+			resolve();
+		};
+		const dispose = installStreamSignals(finish);
+		const pump = async () => {
+			if (reading) {
+				pending = true;
+				return;
+			}
+			reading = true;
+			do {
+				pending = false;
+				let full;
+				try {
+					full = await readFile(logPath);
+				} catch {
+					break;
+				}
+				if (full.length > offset) {
+					const chunk = full.slice(offset);
+					offset = full.length;
+					await onChunk(chunk);
+				}
+			} while (pending && !done);
+			reading = false;
+		};
+		const watcher = watch(logPath, () => void pump());
+		pump();
+	});
+}
+/**
+* Default (interactive) follow: append each new byte range with ANSI/control
+* sequences stripped. Mirrors the historical behaviour, plus prompt signal /
+* pipe-close handling.
+*/
+async function followRawLocal(logPath, buf) {
+	process.stderr.write(`following... (Ctrl-C to stop)\n`);
+	const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+	const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+	await watchAppend(logPath, buf.length, (chunk) => {
+		const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
+		if (text.trim()) process.stdout.write(text.trimStart());
+	}, () => {});
+	return 0;
+}
+/** Absolute index (scrollback + viewport row) of the row the cursor sits on. */
+function cursorAbs(term) {
+	return term.buffer.active.baseY + term.buffer.active.cursorY;
+}
+/**
+* The lines in [fromAbs, cursorRow) — rows the cursor has moved PAST, i.e.
+* finalized text. A row still being rewritten in place (spinner, progress bar,
+* TUI repaint) is the cursor's own row and is excluded until the cursor leaves
+* it, which is what keeps redraw churn out of the plain stream.
+*/
+function finalizedLines(term, fromAbs) {
+	const a = term.buffer.active;
+	const cur = a.baseY + a.cursorY;
+	const out = [];
+	for (let i = Math.max(0, fromAbs); i < cur; i++) {
+		const l = a.getLine(i);
+		out.push(l ? l.translateToString(false).trimEnd() : "");
+	}
+	return out;
+}
+/**
+* Plain (pipe/script) follow: feed the live PTY stream through @xterm/headless
+* and emit each line only once it's finalized — i.e. once the cursor has moved
+* off it. In-place redraws (spinners, progress bars that rewrite the current
+* line, full-screen TUI repaints) churn the cursor's row and never emit until
+* settled, so the output is clean, newline-terminated, line-buffered text a
+* script can read. On stop, flush the line the cursor is still sitting on.
+*/
+async function followPlainLocal(logPath, buf) {
+	process.stderr.write(`following... (plain; Ctrl-C / SIGTERM to stop)\n`);
+	const { Terminal } = await import("@xterm/headless");
+	const term = new Terminal({
+		cols: 200,
+		rows: 50,
+		scrollback: 5e4,
+		allowProposedApi: true
+	});
+	const feed = (b) => new Promise((r) => term.write(b, () => r()));
+	const lineAt = (i) => {
+		const l = term.buffer.active.getLine(i);
+		return l ? l.translateToString(false).trimEnd() : "";
+	};
+	await feed(buf);
+	let emitted = cursorAbs(term);
+	const flushCommitted = () => {
+		for (const line of finalizedLines(term, emitted)) process.stdout.write(line + "\n");
+		emitted = cursorAbs(term);
+	};
+	await watchAppend(logPath, buf.length, async (chunk) => {
+		await feed(chunk);
+		flushCommitted();
+	}, () => {
+		flushCommitted();
+		const last = lineAt(cursorAbs(term));
+		if (last) process.stdout.write(last + "\n");
+	});
+	return 0;
+}
+/**
 * Feed the raw PTY bytes through @xterm/headless and emit plain text.
 * Same approach as koho's renderTerminalBuffer + agent-yes's XtermProxy.
 */
@@ -1451,5 +1594,5 @@ async function cmdStatus(rest) {
 }
 
 //#endregion
-export { isSubcommand as a, readNotes as c, runSubcommand as d, snapshotStatus as f, isPidAlive as i, renderRawLog as l, writeToIpc as m, cmdHelp as n, listRecords as o, stopTipForCli as p, controlCodeFromName as r, matchKeyword as s, GRACEFUL_EXIT_COMMANDS as t, resolveOne as u };
-//# sourceMappingURL=subcommands-BImrR-R6.js.map
+export { finalizedLines as a, listRecords as c, renderRawLog as d, resolveOne as f, writeToIpc as g, stopTipForCli as h, cursorAbs as i, matchKeyword as l, snapshotStatus as m, cmdHelp as n, isPidAlive as o, runSubcommand as p, controlCodeFromName as r, isSubcommand as s, GRACEFUL_EXIT_COMMANDS as t, readNotes as u };
+//# sourceMappingURL=subcommands-BLPtg1xN.js.map

package/dist/{ts-CFnUatY1.js → ts-D_sIq4Yv.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-CRaHzP0C.js";
+import { r as getInstalledPackage } from "./versionChecker-osmGP6ly.js";
 import { n as agentYesHome, t as PidStore } from "./pidStore-DBjlqzo8.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CJxsoGdb.js";
 import { i as readGlobalPids } from "./globalPidIndex-yVd3mbsV.js";
@@ -1714,4 +1714,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-CFnUatY1.js.map
+//# sourceMappingURL=ts-D_sIq4Yv.js.map

package/dist/{versionChecker-CRaHzP0C.js → versionChecker-osmGP6ly.js}

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

package/lab/ui/index.html

@@ -1181,7 +1181,11 @@
       // that agent as soon as it shows up in the list, then forgets itself. With
       // no ?pid, fall back to the agent this device last had selected — so a
       // refresh lands you back on the same agent instead of the placeholder.
+      // autoPidExplicit distinguishes the two: an explicit link opens the agent
+      // even on mobile (it's a deliberate "take me here"), whereas a merely
+      // restored selection only re-highlights the row on a phone — see loadList.
       let autoPid = new URLSearchParams(location.search).get("pid");
+      let autoPidExplicit = !!autoPid;
       if (autoPid) {
         history.replaceState(null, document.title, location.pathname + location.hash);
       } else {
@@ -1202,7 +1206,17 @@
         if (autoPid && entries.some((x) => String(x.pid) === String(autoPid))) {
           const pid = autoPid;
           autoPid = null;
-          select(pid);
+          // On a phone, a restored selection re-highlights the row but stays on
+          // the list — opening it would flip straight into the full-screen
+          // terminal (show-detail) and hide the list. An explicit ?pid= link is
+          // a deliberate jump, so it still opens. Desktop shows both panes, so
+          // there's nothing to scope — always open.
+          if (autoPidExplicit || window.innerWidth > 720) {
+            select(pid);
+          } else {
+            sel = pid;
+            renderList();
+          }
         }
       }
 

package/package.json

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

package/ts/subcommands.spec.ts

@@ -458,6 +458,45 @@ describe("subcommands.cmdRead renders raw log via xterm-headless", () => {
   });
 });
 
+// The plain (pipe/script) follow mode emits a line only once the cursor has
+// moved off it, so in-place redraws (spinners, progress bars, TUI repaints) stay
+// out of the stream. finalizedLines() is that rule; drive it with a real
+// @xterm/headless terminal so the assertions reflect actual PTY semantics.
+describe("subcommands.finalizedLines (plain follow line discipline)", () => {
+  async function newTerm() {
+    const { Terminal } = await import("@xterm/headless");
+    return new Terminal({ cols: 80, rows: 10, scrollback: 1000, allowProposedApi: true });
+  }
+  const feed = (term: any, s: string) =>
+    new Promise<void>((r) => term.write(new TextEncoder().encode(s), () => r()));
+
+  it("emits newline-finalized lines and suppresses in-place redraws", async () => {
+    const { finalizedLines, cursorAbs } = await loadModule();
+    const term = await newTerm();
+
+    await feed(term, "line A\r\nline B\r\n");
+    // Cursor is now on the empty row 2; rows 0–1 are finalized.
+    expect(finalizedLines(term as any, 0)).toEqual(["line A", "line B"]);
+
+    // A spinner rewrites the current row in place (CR, no newline) — not finalized.
+    let mark = cursorAbs(term as any);
+    await feed(term, "\x1b[33mWorking |\x1b[0m");
+    expect(finalizedLines(term as any, mark)).toEqual([]);
+    await feed(term, "\rWorking /"); // redraw same row
+    expect(finalizedLines(term as any, mark)).toEqual([]);
+
+    // Once the line is overwritten with real content AND terminated, it commits.
+    await feed(term, "\rdownload complete\r\n");
+    expect(finalizedLines(term as any, mark)).toEqual(["download complete"]);
+
+    // Advancing the high-water mark, nothing new is finalized until more arrives.
+    mark = cursorAbs(term as any);
+    expect(finalizedLines(term as any, mark)).toEqual([]);
+    await feed(term, "next line\r\n");
+    expect(finalizedLines(term as any, mark)).toEqual(["next line"]);
+  });
+});
+
 describe("subcommands.cmdSend writes bytes to FIFO", () => {
   // Skip on non-unix because FIFO creation requires mkfifo
   const itUnix = process.platform === "linux" || process.platform === "darwin";

package/ts/subcommands.ts

@@ -524,6 +524,7 @@ async function runRemoteRead(
   follow: boolean,
   n: number,
   reconnectTimeoutMs = 120_000,
+  _plain = false,
 ): Promise<number> {
   const keyword = remote.keyword ?? "";
   if (!keyword) {
@@ -535,7 +536,12 @@ async function runRemoteRead(
 
   if (mode === "tail" && follow) {
     const ac = new AbortController();
-    process.on("SIGINT", () => ac.abort());
+    // SIGINT/SIGTERM/SIGHUP and a closed pipe all abort the stream, so
+    // `timeout … ay tail -f` and `kill` terminate promptly (was SIGINT-only,
+    // which let `timeout` run the full --reconnect-timeout window). The server
+    // already sends rendered, newline-delimited text, so the wire is plain.
+    const disposeSignals = installStreamSignals(() => ac.abort());
+    ac.signal.addEventListener("abort", disposeSignals, { once: true });
     const deadline = Date.now() + reconnectTimeoutMs;
     let delay = 1_000;
     let attempt = 0;
@@ -988,6 +994,13 @@ async function cmdRead(rest: string[], { mode }: ReadOpts): Promise<number> {
       description: "Follow log output (Ctrl-C to stop)",
     })
     .option("n", { type: "number", description: "Number of lines (default: 96 for tail/head)" })
+    .option("plain", {
+      type: "boolean",
+      default: false,
+      description:
+        "Line-buffered plain text for pipes/scripts (no ANSI redraws or spinner). " +
+        "Auto-enabled when stdout is not a TTY.",
+    })
     .option("all", { type: "boolean", default: false, description: "Include exited agents" })
     .option("latest", {
       type: "boolean",
@@ -1005,6 +1018,12 @@ async function cmdRead(rest: string[], { mode }: ReadOpts): Promise<number> {
     .exitProcess(false);
 
   const argv = await y.parseAsync();
+  // A closed downstream pipe (e.g. `… | head -3`) makes stdout writes fail with
+  // EPIPE. Treat it as a clean exit — the reader is gone, our job is done.
+  ensureEpipeExit();
+  // Pipes/scripts get line-buffered plain text by default; an explicit --plain
+  // forces it even on a TTY. See followPlainLocal / runRemoteRead.
+  const plain = Boolean(argv.plain) || !process.stdout.isTTY;
   const opts: CommonOpts = {
     all: argv.all,
     active: false,
@@ -1023,7 +1042,7 @@ async function cmdRead(rest: string[], { mode }: ReadOpts): Promise<number> {
           ? 0
           : 96;
     const reconnectTimeoutMs = ((argv["reconnect-timeout"] as number) ?? 120) * 1000;
-    if (remote) return runRemoteRead(remote, mode, argv.follow, n2, reconnectTimeoutMs);
+    if (remote) return runRemoteRead(remote, mode, argv.follow, n2, reconnectTimeoutMs, plain);
   }
   const follow = argv.follow;
   const nFlag = argv.n;
@@ -1062,28 +1081,7 @@ async function cmdRead(rest: string[], { mode }: ReadOpts): Promise<number> {
   if (!rendered.endsWith("\n")) process.stdout.write("\n");
 
   if (follow) {
-    process.stderr.write(`following... (Ctrl-C to stop)\n`);
-    let offset = buf.length;
-    const { watch } = await import("fs");
-    // oxlint-disable-next-line no-control-regex -- intentional: strip ANSI/control
-    const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
-    // oxlint-disable-next-line no-control-regex -- intentional: strip control chars
-    const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
-    await new Promise<void>((resolve) => {
-      const watcher = watch(logPath, async () => {
-        const full = await readFile(logPath);
-        if (full.length <= offset) return;
-        const chunk = full.slice(offset);
-        offset = full.length;
-        const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
-        if (text.trim()) process.stdout.write(text.trimStart());
-      });
-      process.on("SIGINT", () => {
-        watcher.close();
-        resolve();
-      });
-    });
-    return 0;
+    return plain ? followPlainLocal(logPath, buf) : followRawLocal(logPath, buf);
   }
 
   process.stderr.write(
@@ -1096,6 +1094,206 @@ async function cmdRead(rest: string[], { mode }: ReadOpts): Promise<number> {
   return 0;
 }
 
+/**
+ * Exit cleanly when stdout's downstream closes (EPIPE). Node ignores SIGPIPE and
+ * surfaces a broken pipe as a stream 'error'; with no listener it throws, and in
+ * follow mode the watch loop would otherwise hang. Idempotent — one listener for
+ * the life of the process, tagged on stdout so repeated calls (and module
+ * reloads in tests) don't pile up listeners.
+ */
+function ensureEpipeExit(): void {
+  const TAG = "__ayEpipeExit";
+  if ((process.stdout as unknown as Record<string, boolean>)[TAG]) return;
+  (process.stdout as unknown as Record<string, boolean>)[TAG] = true;
+  process.stdout.on("error", (e: NodeJS.ErrnoException) => {
+    if (e?.code === "EPIPE") process.exit(0);
+  });
+}
+
+/**
+ * Install signal handlers for a streaming follower so it terminates promptly
+ * under automation, not just on an interactive Ctrl-C. SIGINT/SIGTERM/SIGHUP all
+ * run `stop` (so `timeout … ay tail -f` and `kill` both work); a closed stdout
+ * (EPIPE) exits cleanly via ensureEpipeExit. Returns a disposer that removes the
+ * signal listeners.
+ */
+function installStreamSignals(stop: () => void): () => void {
+  ensureEpipeExit();
+  const onSig = () => stop();
+  process.on("SIGINT", onSig);
+  process.on("SIGTERM", onSig);
+  process.on("SIGHUP", onSig);
+  return () => {
+    process.off("SIGINT", onSig);
+    process.off("SIGTERM", onSig);
+    process.off("SIGHUP", onSig);
+  };
+}
+
+/**
+ * Coalescing file watcher: re-reads `logPath` on every change, hands each newly
+ * appended byte range to `onChunk`, and never overlaps reads (a change that
+ * arrives mid-read is serviced once the current read finishes). `startOffset`
+ * is where the already-emitted prefix ends. Resolves when `stop` is signalled.
+ */
+async function watchAppend(
+  logPath: string,
+  startOffset: number,
+  onChunk: (chunk: Uint8Array) => Promise<void> | void,
+  onStop: () => void,
+): Promise<void> {
+  const { watch } = await import("fs");
+  let offset = startOffset;
+  let reading = false;
+  let pending = false;
+  await new Promise<void>((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      try {
+        watcher.close();
+      } catch {}
+      dispose();
+      onStop();
+      resolve();
+    };
+    const dispose = installStreamSignals(finish);
+    const pump = async () => {
+      if (reading) {
+        pending = true;
+        return;
+      }
+      reading = true;
+      do {
+        pending = false;
+        let full: Uint8Array;
+        try {
+          full = await readFile(logPath);
+        } catch {
+          break;
+        }
+        if (full.length > offset) {
+          const chunk = full.slice(offset);
+          offset = full.length;
+          await onChunk(chunk);
+        }
+      } while (pending && !done);
+      reading = false;
+    };
+    const watcher = watch(logPath, () => void pump());
+    // The file may have grown between our initial read and the watch starting.
+    void pump();
+  });
+}
+
+/**
+ * Default (interactive) follow: append each new byte range with ANSI/control
+ * sequences stripped. Mirrors the historical behaviour, plus prompt signal /
+ * pipe-close handling.
+ */
+async function followRawLocal(logPath: string, buf: Uint8Array): Promise<number> {
+  process.stderr.write(`following... (Ctrl-C to stop)\n`);
+  // oxlint-disable-next-line no-control-regex -- intentional: strip ANSI/control
+  const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+  // oxlint-disable-next-line no-control-regex -- intentional: strip control chars
+  const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+  await watchAppend(
+    logPath,
+    buf.length,
+    (chunk) => {
+      const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
+      if (text.trim()) process.stdout.write(text.trimStart());
+    },
+    () => {},
+  );
+  return 0;
+}
+
+/**
+ * Minimal view of an @xterm/headless buffer — just what the line-finalization
+ * logic needs, so it can be unit-tested against a real Terminal or a stub.
+ */
+export interface PlainTermView {
+  buffer: {
+    active: {
+      baseY: number;
+      cursorY: number;
+      getLine(i: number): { translateToString(trim: boolean): string } | undefined;
+    };
+  };
+}
+
+/** Absolute index (scrollback + viewport row) of the row the cursor sits on. */
+export function cursorAbs(term: PlainTermView): number {
+  return term.buffer.active.baseY + term.buffer.active.cursorY;
+}
+
+/**
+ * The lines in [fromAbs, cursorRow) — rows the cursor has moved PAST, i.e.
+ * finalized text. A row still being rewritten in place (spinner, progress bar,
+ * TUI repaint) is the cursor's own row and is excluded until the cursor leaves
+ * it, which is what keeps redraw churn out of the plain stream.
+ */
+export function finalizedLines(term: PlainTermView, fromAbs: number): string[] {
+  const a = term.buffer.active;
+  const cur = a.baseY + a.cursorY;
+  const out: string[] = [];
+  for (let i = Math.max(0, fromAbs); i < cur; i++) {
+    const l = a.getLine(i);
+    out.push(l ? l.translateToString(false).trimEnd() : "");
+  }
+  return out;
+}
+
+/**
+ * Plain (pipe/script) follow: feed the live PTY stream through @xterm/headless
+ * and emit each line only once it's finalized — i.e. once the cursor has moved
+ * off it. In-place redraws (spinners, progress bars that rewrite the current
+ * line, full-screen TUI repaints) churn the cursor's row and never emit until
+ * settled, so the output is clean, newline-terminated, line-buffered text a
+ * script can read. On stop, flush the line the cursor is still sitting on.
+ */
+async function followPlainLocal(logPath: string, buf: Uint8Array): Promise<number> {
+  process.stderr.write(`following... (plain; Ctrl-C / SIGTERM to stop)\n`);
+  const { Terminal } = await import("@xterm/headless");
+  const term = new Terminal({ cols: 200, rows: 50, scrollback: 50000, allowProposedApi: true });
+  const feed = (b: Uint8Array) => new Promise<void>((r) => term.write(b, () => r()));
+  const lineAt = (i: number) => {
+    const l = term.buffer.active.getLine(i);
+    return l ? l.translateToString(false).trimEnd() : "";
+  };
+
+  // Seed with the existing log so we start streaming from the live frontier —
+  // the recent context was already printed by the static tail above.
+  await feed(buf);
+  let emitted = cursorAbs(term);
+
+  // `emitted` only advances, so a redraw that moves the cursor back up doesn't
+  // re-emit lines it then rewrites.
+  const flushCommitted = () => {
+    for (const line of finalizedLines(term, emitted)) process.stdout.write(line + "\n");
+    emitted = cursorAbs(term);
+  };
+
+  await watchAppend(
+    logPath,
+    buf.length,
+    async (chunk) => {
+      await feed(chunk);
+      flushCommitted();
+    },
+    () => {
+      // Final flush: include the cursor's own row if it has content, so the last
+      // partial line isn't lost when we're killed mid-stream.
+      flushCommitted();
+      const last = lineAt(cursorAbs(term));
+      if (last) process.stdout.write(last + "\n");
+    },
+  );
+  return 0;
+}
+
 /**
  * Feed the raw PTY bytes through @xterm/headless and emit plain text.
  * Same approach as koho's renderTerminalBuffer + agent-yes's XtermProxy.

package/dist/SUPPORTED_CLIS-BkWXFAho.js

@@ -1,8 +0,0 @@
-import "./ts-CFnUatY1.js";
-import "./logger-B9h0djqx.js";
-import "./versionChecker-CRaHzP0C.js";
-import "./pidStore-DBjlqzo8.js";
-import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-O3atAbo5.js";
-
-export { SUPPORTED_CLIS };

package/dist/subcommands-DO3qf62r.js

@@ -1,6 +0,0 @@
-import "./logger-B9h0djqx.js";
-import "./globalPidIndex-yVd3mbsV.js";
-import "./remotes-C3xPRtfg.js";
-import { a as isSubcommand, c as readNotes, d as runSubcommand, f as snapshotStatus, i as isPidAlive, l as renderRawLog, m as writeToIpc, n as cmdHelp, o as listRecords, p as stopTipForCli, r as controlCodeFromName, s as matchKeyword, t as GRACEFUL_EXIT_COMMANDS, u as resolveOne } from "./subcommands-BImrR-R6.js";
-
-export { cmdHelp, isSubcommand, runSubcommand };