agent-yes 1.140.1 → 1.141.0

package/dist/{SUPPORTED_CLIS-Cjay1Iru.js → SUPPORTED_CLIS-CnBoRIDN.js}

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

package/dist/SUPPORTED_CLIS-bW-3DoHX.js

@@ -0,0 +1,8 @@
+import "./ts-CMMwNq--.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-DMpCuaZe.js";
+import "./pidStore-fqXqTKkh.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CnBoRIDN.js";
+
+export { SUPPORTED_CLIS };

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-zdFbz1ST.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-CZ6UM9LY.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-DMpCuaZe.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -480,7 +480,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-CvO1YYns.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-3BaA-AmB.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp(managerCommands);
 		process.exit(0);
@@ -513,7 +513,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-dlEtFEAn.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-bW-3DoHX.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-CKCsYKjz.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CMMwNq--.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CZ6UM9LY.js";
+import "./versionChecker-DMpCuaZe.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
 

package/dist/{schedule-DEcxVffO.js → schedule-PVnlPldE.js}

@@ -1,9 +1,9 @@
-import "./ts-CKCsYKjz.js";
+import "./ts-CMMwNq--.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CZ6UM9LY.js";
+import "./versionChecker-DMpCuaZe.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Cjay1Iru.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CnBoRIDN.js";
 import { n as resolveSpawnCwd } from "./workspaceConfig-BCOqRBEW.js";
 import { createHash } from "node:crypto";
 
@@ -141,4 +141,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-DEcxVffO.js.map
+//# sourceMappingURL=schedule-PVnlPldE.js.map

package/dist/{serve-BAZlVy52.js → serve-D8UEMOas.js}

@@ -1,13 +1,13 @@
-import "./ts-CKCsYKjz.js";
+import "./ts-CMMwNq--.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-CZ6UM9LY.js";
+import { r as getInstalledPackage } from "./versionChecker-DMpCuaZe.js";
 import "./pidStore-fqXqTKkh.js";
 import { a as updateGlobalPidStatus } from "./globalPidIndex-DlmmJlO8.js";
 import { t as pgidForWrapper } from "./reaper-C-eWAxIj.js";
 import "./configShared-C1C04bbq.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Cjay1Iru.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CnBoRIDN.js";
 import "./remotes-PKKjfTI1.js";
-import { S as writeToIpc, _ as resolveOne, b as snapshotStatus, c as extractTaskCounts, f as listRecords, h as renderRawLog, i as controlCodeFromName, m as readNotes, o as deriveLiveStatus } from "./subcommands-D4BFGRle.js";
+import { C as writeToIpc, c as extractTaskCounts, g as renderRawLog, h as readNotes, i as controlCodeFromName, o as deriveLiveStatus, p as listRecords, v as resolveOne, x as snapshotStatus } from "./subcommands-dbx7EoK-.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -1175,4 +1175,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-BAZlVy52.js.map
+//# sourceMappingURL=serve-D8UEMOas.js.map

package/dist/{setup-C9csSnJG.js → setup-BPAdHGDG.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-BAZlVy52.js");
+	const { cmdServe } = await import("./serve-D8UEMOas.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-C9csSnJG.js.map
+//# sourceMappingURL=setup-BPAdHGDG.js.map

package/dist/subcommands-3BaA-AmB.js

@@ -0,0 +1,7 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import "./configShared-C1C04bbq.js";
+import "./remotes-PKKjfTI1.js";
+import { C as writeToIpc, S as stopTipForCli, _ as renderRawLogLines, a as cursorAbs, b as runSubcommand, c as extractTaskCounts, d as isPidAlive, f as isSubcommand, g as renderRawLog, h as readNotes, i as controlCodeFromName, l as finalizedLines, m as matchKeyword, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as listRecords, r as cmdHelp, s as extractNeedsInput, t as GRACEFUL_EXIT_COMMANDS, u as isAgentStuck, v as resolveOne, x as snapshotStatus, y as resolveReadWindow } from "./subcommands-dbx7EoK-.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-D4BFGRle.js → subcommands-dbx7EoK-.js}

@@ -182,6 +182,19 @@ function classifyNeedsInput(lines, cfg) {
 	const end = Math.min(lines.length, last + 6);
 	return { question: lines.slice(start, end).map((l) => l.trim()).filter((l) => l && !isChromeLine(l)).join(" • ").slice(0, 400) };
 }
+/**
+* True when the rendered screen still shows a "busy" marker (config `working`,
+* e.g. claude's `esc to interrupt`). Paired with a long-quiet log this is the
+* `stuck` signal: a live spinner writes to the log every frame, so a busy marker
+* on screen WITHOUT recent output means the agent wedged mid-stream (a silent
+* API stream stall) rather than finishing. Pure + synchronous like the rest of
+* this module so it's trivially unit-testable.
+*/
+function isWorkingScreen(lines, working) {
+	if (!working?.length) return false;
+	const text = lines.join("\n");
+	return working.some((re) => reTest(re, text));
+}
 
 //#endregion
 //#region ts/lsWatch.ts
@@ -351,6 +364,7 @@ async function compactNotes() {
 	await writeFile(notesPath(), lines ? lines + "\n" : "");
 }
 const READ_WINDOW_MS = 6e4;
+const IPC_WRITE_TIMEOUT_MS = 1e4;
 const READS_KEY_SEP = "\0";
 function readsPath() {
 	const dir = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
@@ -497,6 +511,10 @@ const SUBCOMMANDS = new Set([
 ]);
 const MANAGER_SUBCOMMANDS = new Set(["setup"]);
 const IDLE_THRESHOLD_MS = 60 * 1e3;
+const STUCK_THRESHOLD_MS = (() => {
+	const n = Number(process.env.AGENT_YES_STUCK_MS);
+	return Number.isFinite(n) && n > 0 ? n : 300 * 1e3;
+})();
 /**
 * Whether `name` is a subcommand. `managerCommands` (default true, for the
 * generic `ay`/`agent-yes` entry) additionally admits manager-only commands
@@ -533,15 +551,15 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-BAZlVy52.js");
+				const { cmdServe } = await import("./serve-D8UEMOas.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-C9csSnJG.js");
+				const { cmdSetup } = await import("./setup-BPAdHGDG.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-DEcxVffO.js");
+				const { cmdSchedule } = await import("./schedule-PVnlPldE.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -976,6 +994,10 @@ async function deriveLiveState(r) {
 			state: "needs_input",
 			question: ni.question
 		};
+		if (base === "idle" && await isAgentStuck(r)) return {
+			state: "stuck",
+			question: null
+		};
 	}
 	return {
 		state: base,
@@ -999,7 +1021,7 @@ async function cmdLs(rest) {
 		alias: "w",
 		type: "boolean",
 		default: false,
-		description: "Stream agent state transitions (needs_input | idle | active | stopped) as NDJSON across all matched agents — one event stream for a whole fan-out, instead of N per-pid `ay status --watch`es. Runs until Ctrl-C."
+		description: "Stream agent state transitions (needs_input | idle | active | stuck | stopped) as NDJSON across all matched agents — one event stream for a whole fan-out, instead of N per-pid `ay status --watch`es. Runs until Ctrl-C."
 	}).option("interval", {
 		type: "number",
 		default: 2,
@@ -1645,9 +1667,12 @@ function cliDefaults() {
 * and renders it through xterm, then runs the CLI's `needsInput`/`working`
 * patterns. Returns null when no menu is detected (or the CLI defines none).
 */
-async function extractNeedsInput(logPath, cli) {
-	const cfg = (await cliDefaults())[cli];
-	if (!cfg?.needsInput?.length) return null;
+/**
+* Render the last `n` lines of a raw PTY log (reads only the final 32KB). Returns
+* null on any read/render error or an empty log. Shared by the needs_input and
+* stuck classifiers so they don't each re-implement the tail read.
+*/
+async function renderLogTailLines(logPath, n = 40) {
 	const TAIL_BYTES = 32 * 1024;
 	let buf;
 	try {
@@ -1670,17 +1695,41 @@ async function extractNeedsInput(logPath, cli) {
 		return null;
 	}
 	try {
-		return classifyNeedsInput((await renderRawLog(buf, {
+		return (await renderRawLog(buf, {
 			mode: "tail",
-			n: 40
-		})).split("\n"), {
-			needsInput: cfg.needsInput,
-			working: cfg.working
-		});
+			n
+		})).split("\n");
 	} catch {
 		return null;
 	}
 }
+async function extractNeedsInput(logPath, cli) {
+	const cfg = (await cliDefaults())[cli];
+	if (!cfg?.needsInput?.length) return null;
+	const lines = await renderLogTailLines(logPath, 40);
+	if (!lines) return null;
+	return classifyNeedsInput(lines, {
+		needsInput: cfg.needsInput,
+		working: cfg.working
+	});
+}
+/**
+* Whether an alive agent is wedged: its log has been silent for at least
+* STUCK_THRESHOLD_MS yet its screen still shows a `working` busy marker (a live
+* spinner keeps writing, so busy + long-silent = a mid-stream stall). Pass the
+* already-stat'd log mtime to skip a redundant stat. Returns false when the CLI
+* has no `working` markers configured (nothing to key off).
+*/
+async function isAgentStuck(record, logMtimeMs) {
+	if (!record.log_file) return false;
+	const cfg = (await cliDefaults())[record.cli];
+	if (!cfg?.working?.length) return false;
+	const mtime = logMtimeMs ?? await stat(record.log_file).then((s) => s.mtimeMs).catch(() => null);
+	if (mtime === null || Date.now() - mtime < STUCK_THRESHOLD_MS) return false;
+	const lines = await renderLogTailLines(record.log_file, 40);
+	if (!lines) return false;
+	return isWorkingScreen(lines, cfg.working);
+}
 function extractActivityFromLines(lines) {
 	const isChrome = (l) => {
 		const s = l.trim();
@@ -1847,10 +1896,26 @@ async function writeToIpc(ipcPath, payload) {
 			});
 		});
 	} else {
-		const { openSync, writeFileSync, closeSync, constants } = await import("fs");
+		const { openSync, writeSync, closeSync, constants } = await import("fs");
 		const fd = openSync(ipcPath, constants.O_WRONLY | constants.O_NONBLOCK);
 		try {
-			writeFileSync(fd, payload);
+			const buf = Buffer.from(payload, "utf8");
+			const deadline = Date.now() + IPC_WRITE_TIMEOUT_MS;
+			let off = 0;
+			while (off < buf.length) {
+				let wrote = 0;
+				try {
+					wrote = writeSync(fd, buf, off, buf.length - off);
+				} catch (e) {
+					const code = e?.code;
+					if (code !== "EAGAIN" && code !== "EWOULDBLOCK") throw e;
+				}
+				off += wrote;
+				if (off < buf.length) {
+					if (Date.now() >= deadline) throw new Error(`writeToIpc: ${ipcPath} reader not draining — wrote ${off}/${buf.length} bytes in ${IPC_WRITE_TIMEOUT_MS}ms`);
+					await new Promise((r) => setTimeout(r, wrote > 0 ? 1 : 15));
+				}
+			}
 		} finally {
 			closeSync(fd);
 		}
@@ -2172,7 +2237,7 @@ async function snapshotStatus(record) {
 		if (ni) {
 			state = "needs_input";
 			question = ni.question;
-		}
+		} else if (state === "idle" && await isAgentStuck(record, logMtimeMs)) state = "stuck";
 	}
 	const note = (await readNotes()).get(record.pid) ?? null;
 	return {
@@ -2252,7 +2317,7 @@ async function cmdStatus(rest) {
 		const startedAt = Date.now();
 		for (;;) {
 			const snap = await snapshotStatus(record);
-			if (snap.state === "needs_input" || snap.state === "idle" || snap.state === "stopped") {
+			if (snap.state === "needs_input" || snap.state === "idle" || snap.state === "stuck" || snap.state === "stopped") {
 				emit(snap);
 				return 0;
 			}
@@ -2267,7 +2332,7 @@ async function cmdStatus(rest) {
 		const startedAt = Date.now();
 		for (;;) {
 			const snap = await snapshotStatus(record);
-			if (snap.state === "idle") {
+			if (snap.state === "idle" || snap.state === "stuck") {
 				emit(snap);
 				return 0;
 			}
@@ -2439,5 +2504,5 @@ async function cmdResultSet(rest) {
 }
 
 //#endregion
-export { writeToIpc as S, resolveOne as _, cursorAbs as a, snapshotStatus as b, extractTaskCounts as c, isSubcommand as d, listRecords as f, renderRawLogLines as g, renderRawLog as h, controlCodeFromName as i, finalizedLines as l, readNotes as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, matchKeyword as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isPidAlive as u, resolveReadWindow as v, stopTipForCli as x, runSubcommand as y };
-//# sourceMappingURL=subcommands-D4BFGRle.js.map
+export { writeToIpc as C, stopTipForCli as S, renderRawLogLines as _, cursorAbs as a, runSubcommand as b, extractTaskCounts as c, isPidAlive as d, isSubcommand as f, renderRawLog as g, readNotes as h, controlCodeFromName as i, finalizedLines as l, matchKeyword as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, listRecords as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isAgentStuck as u, resolveOne as v, snapshotStatus as x, resolveReadWindow as y };
+//# sourceMappingURL=subcommands-dbx7EoK-.js.map

package/dist/{ts-CKCsYKjz.js → ts-CMMwNq--.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-CZ6UM9LY.js";
+import { r as getInstalledPackage } from "./versionChecker-DMpCuaZe.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-V4qvXgAw.js";
 import { t as PidStore } from "./pidStore-fqXqTKkh.js";
@@ -1788,4 +1788,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-CKCsYKjz.js.map
+//# sourceMappingURL=ts-CMMwNq--.js.map

package/dist/{versionChecker-CZ6UM9LY.js → versionChecker-DMpCuaZe.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.140.1";
+var version = "1.141.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-CZ6UM9LY.js.map
+//# sourceMappingURL=versionChecker-DMpCuaZe.js.map

package/lab/ui/console-logic.js

@@ -440,7 +440,7 @@ export function selSegments(sel, myLast, vy, myRows, peerCols, myCols) {
     rB = myLast - sel.fb,
     cA = sel.ca,
     cB = sel.cb;
-  if (rA > rB) ([rA, rB] = [rB, rA]), ([cA, cB] = [cB, cA]); // rA = top row
+  if (rA > rB) (([rA, rB] = [rB, rA]), ([cA, cB] = [cB, cA])); // rA = top row
   const segs = [];
   const from = Math.max(rA, vy),
     to = Math.min(rB, vy + myRows - 1);

package/lab/ui/index.html

@@ -1489,7 +1489,10 @@
         />
         <div class="omni-results" id="omni-results"></div>
         <div class="omni-foot">
-          <span><b>↑↓</b> move &nbsp; <b>⏎</b> open &nbsp; <b>⌘⏎</b> spawn here &nbsp; <b>esc</b> close</span>
+          <span
+            ><b>↑↓</b> move &nbsp; <b>⏎</b> open &nbsp; <b>⌘⏎</b> spawn here &nbsp;
+            <b>esc</b> close</span
+          >
         </div>
       </div>
     </div>
@@ -2699,9 +2702,17 @@
           const sel = parseSel(p.sel);
           if (!sel) continue;
           const hue = hashHue(p.viewer);
-          const tag = esc(String(p.viewer).slice(0, 4)) + " " + (p.cols || "?") + "×" + (p.rows || "?");
+          const tag =
+            esc(String(p.viewer).slice(0, 4)) + " " + (p.cols || "?") + "×" + (p.rows || "?");
           let tagged = false;
-          for (const seg of selSegments(sel, myLast, vy, term.rows, p.cols || term.cols, term.cols)) {
+          for (const seg of selSegments(
+            sel,
+            myLast,
+            vy,
+            term.rows,
+            p.cols || term.cols,
+            term.cols,
+          )) {
             const vr = seg.row - vy; // our buffer row → our viewport row
             if (vr < 0 || vr > term.rows - 1) continue; // safety (selSegments already clips)
             const left = ox + seg.a * cw;
@@ -3740,7 +3751,9 @@
         const seq = ++omniTailSeq;
         const have = new Set(omniRows.filter((r) => r.kind === "agent").map((r) => r.entry._key));
         const ql = q.toLowerCase();
-        const cands = entries.filter((e) => !have.has(e._key) && e.status !== "exited").slice(0, 20);
+        const cands = entries
+          .filter((e) => !have.has(e._key) && e.status !== "exited")
+          .slice(0, 20);
         await Promise.all(
           cands.map(async (e) => {
             const src = srcFor(e);

package/package.json

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

package/ts/lsWatch.ts

@@ -10,7 +10,7 @@
  * `needsInput.ts`.
  */
 
-export type LiveState = "active" | "idle" | "stopped" | "needs_input";
+export type LiveState = "active" | "idle" | "stopped" | "needs_input" | "stuck";
 
 /** The observable state of one agent at a single tick. */
 export interface LsAgentState {

package/ts/needsInput.spec.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { classifyNeedsInput } from "./needsInput.ts";
+import { classifyNeedsInput, isWorkingScreen } from "./needsInput.ts";
 import { loadSharedCliDefaults } from "./configShared.ts";
 
 // Use the REAL shipped claude/codex patterns so the test guards the actual config.
@@ -11,6 +11,25 @@ test("claude config actually ships a needsInput pattern", () => {
   expect(claude.needsInput?.length).toBeGreaterThan(0);
 });
 
+test("claude config ships a working busy marker (the stuck detector keys off it)", () => {
+  expect(claude.working?.length).toBeGreaterThan(0);
+});
+
+test("isWorkingScreen: true when the shipped claude busy marker is on screen", () => {
+  const screen = ["⏺ Running the test suite…", "", "esc to interrupt · ← for agents"];
+  expect(isWorkingScreen(screen, claude.working)).toBe(true);
+});
+
+test("isWorkingScreen: false at a finished/idle prompt (no busy marker)", () => {
+  const screen = ["⏺ Done — all tests pass.", "", "❯", "", "? for shortcuts"];
+  expect(isWorkingScreen(screen, claude.working)).toBe(false);
+});
+
+test("isWorkingScreen: false when no working patterns are configured", () => {
+  expect(isWorkingScreen(["esc to interrupt"], undefined)).toBe(false);
+  expect(isWorkingScreen(["esc to interrupt"], [])).toBe(false);
+});
+
 test("detects a claude AskUserQuestion selection menu", () => {
   const screen = [
     "Which auth method should we use?",

package/ts/needsInput.ts

@@ -66,3 +66,17 @@ export function classifyNeedsInput(
     .filter((l) => l && !isChromeLine(l));
   return { question: block.join(" • ").slice(0, 400) };
 }
+
+/**
+ * True when the rendered screen still shows a "busy" marker (config `working`,
+ * e.g. claude's `esc to interrupt`). Paired with a long-quiet log this is the
+ * `stuck` signal: a live spinner writes to the log every frame, so a busy marker
+ * on screen WITHOUT recent output means the agent wedged mid-stream (a silent
+ * API stream stall) rather than finishing. Pure + synchronous like the rest of
+ * this module so it's trivially unit-testable.
+ */
+export function isWorkingScreen(lines: string[], working?: RegExp[]): boolean {
+  if (!working?.length) return false;
+  const text = lines.join("\n");
+  return working.some((re) => reTest(re, text));
+}

package/ts/subcommands.spec.ts

@@ -719,6 +719,54 @@ describe("subcommands.cmdSend writes bytes to FIFO", () => {
   });
 });
 
+describe("subcommands.writeToIpc reliable delivery", () => {
+  const itUnix = process.platform === "linux" || process.platform === "darwin";
+
+  it.skipIf(!itUnix)(
+    "delivers a payload larger than the FIFO buffer to a slow reader",
+    async () => {
+      const { writeToIpc } = await loadModule();
+      const { spawnSync } = await import("child_process");
+      const fs = await import("fs");
+      const tmp = await mkdtemp(path.join(tmpdir(), "ay-ipc-"));
+      try {
+        const fifo = path.join(tmp, "big.fifo");
+        if (spawnSync("mkfifo", [fifo]).status !== 0) return;
+        // Reader present (so open() doesn't ENXIO) but draining slowly, in small
+        // chunks on a timer — this backs the ~8KB kernel buffer up and makes the
+        // old single non-blocking writeFileSync EAGAIN/truncate.
+        const rfd = fs.openSync(fifo, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        const chunks: Buffer[] = [];
+        const drain = setInterval(() => {
+          const b = Buffer.alloc(1000);
+          try {
+            const n = fs.readSync(rfd, b, 0, b.length, null);
+            if (n > 0) chunks.push(Buffer.from(b.subarray(0, n)));
+          } catch {
+            /* EAGAIN when momentarily empty */
+          }
+        }, 5);
+        try {
+          // 50KB >> the FIFO buffer: forces many partial writes + EAGAIN retries.
+          const payload = "abcdefghij".repeat(5000);
+          await writeToIpc(fifo, payload);
+          // Let the drainer flush whatever is still buffered.
+          const deadline = Date.now() + 3000;
+          while (Buffer.concat(chunks).length < payload.length && Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 10));
+          }
+          expect(Buffer.concat(chunks).toString("utf8")).toBe(payload);
+        } finally {
+          clearInterval(drain);
+          fs.closeSync(rfd);
+        }
+      } finally {
+        await rm(tmp, { recursive: true, force: true }).catch(() => null);
+      }
+    },
+  );
+});
+
 describe("subcommands.cmdSend safety guards", () => {
   it("maps AGENT_YES_PID→wrapper_pid and blocks an agent from sending to itself", async () => {
     const { runSubcommand } = await loadModule();
@@ -1523,3 +1571,74 @@ describe("subcommands.deriveLiveStatus", () => {
     }
   });
 });
+
+describe("subcommands.isAgentStuck / stuck state", () => {
+  const rec = (over: any) => ({
+    pid: process.pid,
+    cli: "claude",
+    prompt: null,
+    cwd: "/tmp",
+    log_file: null,
+    fifo_file: null,
+    status: "active",
+    exit_code: null,
+    exit_reason: null,
+    started_at: 0,
+    ...over,
+  });
+  // A log whose rendered tail shows claude's shipped `working` busy marker.
+  const BUSY = "⏺ Cogitating…\r\nesc to interrupt · ← for agents\r\n";
+  const tenMinAgo = () => new Date(Date.now() - 10 * 60 * 1000);
+
+  it("isAgentStuck: true when a busy marker is on screen and the log is long-silent", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "ay-stuck-"));
+    try {
+      const log = path.join(dir, "a.log");
+      await writeFile(log, BUSY);
+      await utimes(log, tenMinAgo(), tenMinAgo());
+      const mod = await loadModule();
+      expect(await mod.isAgentStuck(rec({ log_file: log }))).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+
+  it("isAgentStuck: false when the busy log was written recently (still working)", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "ay-stuck-"));
+    try {
+      const log = path.join(dir, "a.log");
+      await writeFile(log, BUSY); // fresh mtime — under the stuck threshold
+      const mod = await loadModule();
+      expect(await mod.isAgentStuck(rec({ log_file: log }))).toBe(false);
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+
+  it("isAgentStuck: false when long-silent but no busy marker on screen (genuinely idle)", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "ay-stuck-"));
+    try {
+      const log = path.join(dir, "a.log");
+      await writeFile(log, "⏺ Done — all green.\r\n❯\r\n");
+      await utimes(log, tenMinAgo(), tenMinAgo());
+      const mod = await loadModule();
+      expect(await mod.isAgentStuck(rec({ log_file: log }))).toBe(false);
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+
+  it("snapshotStatus: reports 'stuck' for a long-silent busy agent (not 'idle')", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "ay-stuck-"));
+    try {
+      const log = path.join(dir, "a.log");
+      await writeFile(log, BUSY);
+      await utimes(log, tenMinAgo(), tenMinAgo());
+      const mod = await loadModule();
+      const snap = await mod.snapshotStatus(rec({ log_file: log }));
+      expect(snap.state).toBe("stuck");
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+});

package/dist/SUPPORTED_CLIS-dlEtFEAn.js

@@ -1,8 +0,0 @@
-import "./ts-CKCsYKjz.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CZ6UM9LY.js";
-import "./pidStore-fqXqTKkh.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Cjay1Iru.js";
-
-export { SUPPORTED_CLIS };

package/dist/subcommands-CvO1YYns.js

@@ -1,7 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import "./configShared-C1C04bbq.js";
-import "./remotes-PKKjfTI1.js";
-import { S as writeToIpc, _ as resolveOne, a as cursorAbs, b as snapshotStatus, c as extractTaskCounts, d as isSubcommand, f as listRecords, g as renderRawLogLines, h as renderRawLog, i as controlCodeFromName, l as finalizedLines, m as readNotes, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as matchKeyword, r as cmdHelp, s as extractNeedsInput, t as GRACEFUL_EXIT_COMMANDS, u as isPidAlive, v as resolveReadWindow, x as stopTipForCli, y as runSubcommand } from "./subcommands-D4BFGRle.js";
-
-export { cmdHelp, isSubcommand, runSubcommand };