agent-yes 1.196.3 → 1.197.0

package/dist/{share-29YbzpbU.js → share-BfIU8t_h.js}

@@ -1,4 +1,4 @@
-import { a as computeTranscriptHash, c as open$1, d as randomHex, f as seal, i as MAX_CHUNK, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, r as MARKER, s as deriveDirKeys, t as CONFIRM_TIMEOUT_MS, u as parseSecret } from "./e2e-BeKjLhmO.js";
+import { a as computeTranscriptHash, c as open$1, d as randomHex, f as seal, i as MAX_CHUNK, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, r as MARKER, s as deriveDirKeys, t as CONFIRM_TIMEOUT_MS, u as parseSecret } from "./e2e-jb0Hp43q.js";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -534,4 +534,4 @@ async function startShare(opts) {
 
 //#endregion
 export { shareLinkFromRoomUrl as n, startShare as r, loadOrCreateShareRoom as t };
-//# sourceMappingURL=share-29YbzpbU.js.map
+//# sourceMappingURL=share-BfIU8t_h.js.map

package/dist/{share-nvqy64A2.js → share-Ciw1mWVN.js}

@@ -1,4 +1,4 @@
-import "./e2e-BeKjLhmO.js";
-import { n as shareLinkFromRoomUrl, r as startShare, t as loadOrCreateShareRoom } from "./share-29YbzpbU.js";
+import "./e2e-jb0Hp43q.js";
+import { n as shareLinkFromRoomUrl, r as startShare, t as loadOrCreateShareRoom } from "./share-BfIU8t_h.js";
 
 export { loadOrCreateShareRoom, shareLinkFromRoomUrl, startShare };

package/dist/{spawnGate-CWbdnJ5K.js → spawnGate-BkjeS4tg.js}

@@ -1,5 +1,5 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
-import { i as waitForSpawnCapacity, n as spawnGateEnabled, r as spawnRejectionReason, t as memAvailableMb } from "./spawnGate-DRWa_Fzj.js";
+import { i as waitForSpawnCapacity, n as spawnGateEnabled, r as spawnRejectionReason, t as memAvailableMb } from "./spawnGate-CXjEz6Pf.js";
 
 export { waitForSpawnCapacity };

package/dist/{spawnGate-DRWa_Fzj.js → spawnGate-CXjEz6Pf.js}

@@ -1,5 +1,5 @@
 import { i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
-import { n as getMinFreeMb, o as getSpawnWaitMs, t as getMaxAgents } from "./workspaceConfig-_GtAZtsi.js";
+import { n as getMinFreeMb, o as getSpawnWaitMs, t as getMaxAgents } from "./workspaceConfig-CjaRvTjf.js";
 import { readFile } from "fs/promises";
 
 //#region ts/spawnGate.ts
@@ -104,4 +104,4 @@ async function waitForSpawnCapacity(opts) {
 
 //#endregion
 export { waitForSpawnCapacity as i, spawnGateEnabled as n, spawnRejectionReason as r, memAvailableMb as t };
-//# sourceMappingURL=spawnGate-DRWa_Fzj.js.map
+//# sourceMappingURL=spawnGate-CXjEz6Pf.js.map

package/dist/{subcommands-CMX-dej0.js → subcommands-B7UxIJRw.js}

@@ -2,9 +2,10 @@ import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
-import { t as loadSharedCliDefaults } from "./configShared-0MnIQ652.js";
-import { n as isWebrtcSpec } from "./webrtcLink-BG0Xc4-W.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-oSmwSYaV.js";
+import { a as recordOutbox, i as recordMessage, n as readMailbox, t as partyMatches } from "./messageLog-CxrKJj77.js";
+import { t as loadSharedCliDefaults } from "./configShared-aKTg-sa5.js";
+import { n as isWebrtcSpec } from "./webrtcLink-B7REGtK2.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-Cim0dBU7.js";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
@@ -161,94 +162,6 @@ function parseTaskCounts(lines) {
 	return best;
 }
 
-//#endregion
-//#region ts/messageLog.ts
-/**
-* Durable inter-agent message log.
-*
-* Every `ay send` that carries a real body is recorded twice — from the two
-* ends' points of view — as append-only JSONL colocated with each agent's
-* project dir (the same `<cwd>/.agent-yes/` convention the session logs use):
-*
-*   - the SENDER's   `<from.cwd>/.agent-yes/outbox.jsonl`
-*   - the RECIPIENT's `<to.cwd>/.agent-yes/inbox.jsonl`
-*
-* A single cwd may host several agents, so records carry the stable `agent_id`
-* (falling back to `pid`) of each end; `ay msgs` filters a mailbox down to one
-* agent by that key. Reading needs no lock (last line wins isn't relevant — a
-* message log keeps every entry); writing is best-effort and never blocks or
-* fails a send.
-*/
-/** Keep at most this many lines per mailbox; older entries are compacted away. */
-const MAILBOX_MAX_LINES = 2e3;
-/** Path to a cwd's mailbox file (`<cwd>/.agent-yes/{inbox,outbox}.jsonl`). */
-function mailboxPath(cwd, box) {
-	return path.join(cwd, ".agent-yes", `${box}.jsonl`);
-}
-/** Whether a mail party is the agent identified by (agentId, pid). Prefers the
-* stable agent_id (survives restart); falls back to pid for legacy records. */
-function partyMatches(party, agentId, pid) {
-	if (!party) return false;
-	if (agentId && party.agent_id && party.agent_id === agentId) return true;
-	if (typeof pid === "number" && party.pid === pid) return true;
-	return false;
-}
-async function appendCapped(filePath, record) {
-	await mkdir(path.dirname(filePath), { recursive: true });
-	await appendFile(filePath, JSON.stringify(record) + "\n");
-	const lines = (await readFile(filePath, "utf-8").catch(() => "")).split("\n").filter((l) => l.trim());
-	if (lines.length > MAILBOX_MAX_LINES) await writeFile(filePath, lines.slice(lines.length - MAILBOX_MAX_LINES).join("\n") + "\n");
-}
-/**
-* Record the SENDER's view in its outbox. Best-effort — a filesystem error is
-* logged and swallowed so persistence never breaks a send. The outbox lives
-* under `from.cwd`; a human sender (from === null) writes under `process.cwd()`.
-*/
-async function recordOutbox(record) {
-	const outCwd = record.from?.cwd ?? process.cwd();
-	try {
-		await appendCapped(mailboxPath(outCwd, "outbox"), record);
-	} catch (err) {
-		logger.debug(`[messageLog] outbox append failed: ${err}`);
-	}
-}
-/** Record the RECIPIENT's view in its inbox (under `to.cwd`). Best-effort. */
-async function recordInbox(record) {
-	try {
-		await appendCapped(mailboxPath(record.to.cwd, "inbox"), record);
-	} catch (err) {
-		logger.debug(`[messageLog] inbox append failed: ${err}`);
-	}
-}
-/**
-* Record a same-host message in both mailboxes — the sender's outbox and the
-* recipient's inbox both live on this machine. For a message that crossed the
-* wire, each end calls `recordOutbox`/`recordInbox` on its own host instead.
-*/
-async function recordMessage(record) {
-	await recordOutbox(record);
-	await recordInbox(record);
-}
-/** Read and parse a cwd's mailbox, oldest first. Missing/corrupt lines skipped. */
-async function readMailbox(cwd, box) {
-	let raw;
-	try {
-		raw = await readFile(mailboxPath(cwd, box), "utf-8");
-	} catch {
-		return [];
-	}
-	const out = [];
-	for (const line of raw.split("\n")) {
-		const t = line.trim();
-		if (!t) continue;
-		try {
-			const rec = JSON.parse(t);
-			if (rec && typeof rec.at === "number" && rec.to) out.push(rec);
-		} catch {}
-	}
-	return out;
-}
-
 //#endregion
 //#region ts/badges.ts
 const BADGE_DEFS = [
@@ -1271,27 +1184,27 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-BOrkFR6H.js");
+				const { cmdServe } = await import("./serve-C3E8uicL.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-CFbckIlf.js");
+				const { cmdSetup } = await import("./setup-C4SKqGy1.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-SisMmURQ.js");
+				const { cmdSchedule } = await import("./schedule-CjBcOy-b.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-CW-yxSgW.js");
+				const { cmdRemote } = await import("./remotes-CXqYR0p8.js");
 				return cmdRemote(rest);
 			}
 			case "expose": {
-				const { cmdExpose } = await import("./expose-B3AGhVhM.js");
+				const { cmdExpose } = await import("./expose-k9l6ZJDA.js");
 				return cmdExpose(rest);
 			}
 			case "reap":
-				await (await import("./reaper-jfSmog15.js")).sweep();
+				await (await import("./reaper-CJSu8UVZ.js")).sweep();
 				return 0;
 			case "help": return cmdHelp(managerCommands);
 			default: return null;
@@ -1703,7 +1616,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-BmuVKcrx.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-CvIEfWX8.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -3222,7 +3135,8 @@ async function cmdMsgs(rest) {
 	}
 	for (const { dir, rec } of shown) {
 		const when = new Date(rec.at).toLocaleTimeString();
-		const peer = dir === "out" ? `→ ${rec.to.cli} #${rec.to.pid}` : `← ${rec.from ? `${rec.from.cli} #${rec.from.pid}` : "human"}`;
+		const fromLabel = rec.from ? `${rec.from.cli} #${rec.from.pid}` : rec.kind === "auto-retry" ? "agent-yes" : "human";
+		const peer = dir === "out" ? `→ ${rec.to.cli} #${rec.to.pid}` : `← ${fromLabel}`;
 		const via = rec.remote ? ` (via ${rec.remote})` : "";
 		const flag = rec.confirmed === false ? " (unconfirmed)" : "";
 		const line = (rec.kind ? `[${rec.kind}] ` : "") + truncate(rec.body.replace(/\s+/g, " "), 100);
@@ -4297,7 +4211,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-DgxP6GAn.js");
+		const { ensureDaemon } = await import("./notifyDaemon-CRf_27kE.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4371,7 +4285,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-DgxP6GAn.js");
+	const daemon = await import("./notifyDaemon-CRf_27kE.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4397,5 +4311,5 @@ async function cmdNotifyd(rest) {
 }
 
 //#endregion
-export { notifyDir 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, liveWatchers as J, hostId as K, snapshotStatus as L, resolveOne as M, resolveReadWindow as N, recentReadEdges as O, resolveResumeArgs as P, daemonLockOwnerPath as Q, stdinActivityPath as R, listRecords as S, readNotes as T, writeToIpc as U, waitForLogQuiet as V, appendEvent as W, shouldStealLock as X, readInbox as Y, daemonLockDir as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, TYPING_BADGE 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, listInboxParents as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, recordInbox as tt, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, stopTipForCli as z };
-//# sourceMappingURL=subcommands-CMX-dej0.js.map
+export { notifyDir 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, liveWatchers as J, hostId as K, snapshotStatus as L, resolveOne as M, resolveReadWindow as N, recentReadEdges as O, resolveResumeArgs as P, daemonLockOwnerPath as Q, stdinActivityPath as R, listRecords as S, readNotes as T, writeToIpc as U, waitForLogQuiet as V, appendEvent as W, shouldStealLock as X, readInbox as Y, daemonLockDir as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, TYPING_BADGE 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, listInboxParents as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, stopTipForCli as z };
+//# sourceMappingURL=subcommands-B7UxIJRw.js.map

package/dist/{subcommands-DSbYPDt5.js → subcommands-DzWBZ6HE.js}

@@ -1,9 +1,10 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
-import "./configShared-0MnIQ652.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-CMX-dej0.js";
-import "./e2e-BeKjLhmO.js";
-import "./webrtcLink-BG0Xc4-W.js";
-import "./remotes-oSmwSYaV.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-B7UxIJRw.js";
+import "./e2e-jb0Hp43q.js";
+import "./webrtcLink-B7REGtK2.js";
+import "./remotes-Cim0dBU7.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-BKTZ5gIf.js → tray-BSFi35Qg.js}

@@ -187,4 +187,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-BKTZ5gIf.js.map
+//# sourceMappingURL=tray-BSFi35Qg.js.map

package/dist/{ts-Bqa5HjY3.js → ts-B64pNQlI.js}

@@ -1,10 +1,11 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-ZIgviJ62.js";
+import { r as getInstalledPackage } from "./versionChecker-DKiSuTSp.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";
 import { i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
-import { n as register, r as sweep } from "./reaper-CWF2_ATd.js";
+import { r as recordInbox } from "./messageLog-CxrKJj77.js";
+import { n as register, r as sweep } from "./reaper-BUHCyxdF.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -572,6 +573,64 @@ function autoRetryBackoffMs(streak) {
 function shouldFireRetry(working, ready, idleMs, minIdleMs) {
 	return !working && ready && idleMs >= minIdleMs;
 }
+/** Fallback reason when no autoRetry match was captured before firing. */
+const AUTO_RETRY_REASON_FALLBACK = "a transient server-side error";
+/**
+* All reason strings `classifyAutoRetryReason` can produce — used by the
+* self-trigger guard spec to prove every possible typed message is inert
+* against every CLI's screen-scrape patterns. Mirrors Rust's RETRY_REASONS.
+*/
+const AUTO_RETRY_REASONS = [
+	"the model backend reported it is temporarily busy",
+	"the response stream stalled mid-way",
+	"the connection dropped mid-response",
+	"a usage cap was reached (it may need time to reset)",
+	"requests are being throttled by the server",
+	AUTO_RETRY_REASON_FALLBACK
+];
+/**
+* Paraphrase the matched recoverable-error banner into a short reason.
+*
+* Deliberately NEVER echoes the raw banner wording ("API Error", "Overloaded",
+* "rate limit", …): the built message is typed into the PTY and stays visible
+* in the transcript, where raw wording would re-match the autoRetry patterns —
+* keeping the error state true forever, which blocks the streak reset on
+* recovery. Mirrors Rust's classify_retry_reason.
+*/
+function classifyAutoRetryReason(screen) {
+	const s = screen.toLowerCase();
+	if (s.includes("overload")) return AUTO_RETRY_REASONS[0];
+	if (s.includes("stalled")) return AUTO_RETRY_REASONS[1];
+	if (s.includes("connection closed")) return AUTO_RETRY_REASONS[2];
+	if (s.includes("usage limit") || s.includes("session limit")) return AUTO_RETRY_REASONS[3];
+	if (s.includes("rate") && s.includes("limit")) return AUTO_RETRY_REASONS[4];
+	return AUTO_RETRY_REASON_FALLBACK;
+}
+/** Human-readable duration: "45s", "3m20s", "1h04m", "8h". Mirrors Rust's fmt_dur_secs. */
+function formatDurationSecs(total) {
+	const t = Math.max(0, Math.floor(total));
+	if (t < 60) return `${t}s`;
+	if (t < 3600) {
+		const m = Math.floor(t / 60);
+		const s = t % 60;
+		return s === 0 ? `${m}m` : `${m}m${String(s).padStart(2, "0")}s`;
+	}
+	const h = Math.floor(t / 3600);
+	const m = Math.floor(t % 3600 / 60);
+	return m === 0 ? `${h}h` : `${h}h${String(m).padStart(2, "0")}m`;
+}
+/**
+* The single line typed into the agent's prompt instead of a bare "retry":
+* says WHO is nudging (agent-yes, automated), WHY (paraphrased reason), and
+* the backoff state (attempt #, elapsed, next delay, give-up horizon), plus an
+* explicit "ignore if nothing failed" clause so an agent that already
+* recovered — or is mid-question — doesn't burn a turn asking what "retry"
+* refers to. Must stay one line (it is submitted with a single "\r").
+* Mirrors Rust's build_retry_message in rs/src/context.rs.
+*/
+function buildAutoRetryMessage(attempt, reason, sinceFirstSecs, nextBackoffSecs) {
+	return `retry [auto-retry #${attempt} by agent-yes: ${reason}; first seen ${formatDurationSecs(sinceFirstSecs)} ago; if this attempt fails too, the next nudge comes in ${formatDurationSecs(nextBackoffSecs)} (giving up after ${formatDurationSecs(AUTO_RETRY_GIVE_UP_MS / 1e3)}). This is an automated recovery nudge - if no request actually failed, ignore it and simply continue your previous task.]`;
+}
 
 //#endregion
 //#region ts/core/logging.ts
@@ -1084,7 +1143,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-ugPYTPOd.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-whqkqq9P.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1517,6 +1576,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 	let retryStartedAt = null;
 	let retryNextAt = null;
 	let autoRetryScreen = "";
+	let retryReason = null;
 	const heartbeatInterval = setInterval(async () => {
 		try {
 			const rendered = removeControlCharacters(xtermProxy.tail(12));
@@ -1530,10 +1590,26 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 				} else if (now >= retryNextAt) if (!shouldFireRetry(conf.working?.some((rx) => rx.test(autoRetryScreen)) ?? false, conf.ready?.some((rx) => rx.test(autoRetryScreen)) ?? false, ctx.idleWaiter.idleTimeMs(), AUTO_RETRY_MIN_IDLE_MS)) retryNextAt = now + 500;
 				else {
 					retryStreak += 1;
-					logger.warn(`[${cli}-yes] auto-retry: typing 'retry' (attempt ${retryStreak})`);
-					ctx.messageContext.shell.write("retry\r");
+					const nextBackoffMs = autoRetryBackoffMs(retryStreak);
+					const reason = retryReason ?? AUTO_RETRY_REASON_FALLBACK;
+					const sinceFirstSecs = retryStartedAt === null ? 0 : (now - retryStartedAt) / 1e3;
+					const line = buildAutoRetryMessage(retryStreak, reason, sinceFirstSecs, nextBackoffMs / 1e3);
+					logger.warn(`[${cli}-yes] auto-retry: typing retry nudge (attempt ${retryStreak}, reason: ${reason})`);
+					ctx.messageContext.shell.write(line + "\r");
 					ctx.idleWaiter.ping();
-					retryNextAt = now + autoRetryBackoffMs(retryStreak);
+					recordInbox({
+						at: now,
+						from: null,
+						to: {
+							pid: process.pid,
+							cli,
+							cwd: workingDir
+						},
+						kind: "auto-retry",
+						body: `${reason} (attempt ${retryStreak}, next backoff ${formatDurationSecs(nextBackoffMs / 1e3)})`,
+						wrapped: false
+					});
+					retryNextAt = now + nextBackoffMs;
 				}
 			}
 			if (rendered === lastHeartbeatRendered) return;
@@ -1738,6 +1814,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 				const errVisible = conf.autoRetry.some((rx) => rx.test(rendered));
 				const readyVisible = conf.ready?.some((rx) => rx.test(rendered)) ?? false;
 				if (errVisible && readyVisible) {
+					retryReason = classifyAutoRetryReason(rendered);
 					if (retryNextAt === null) {
 						if (retryStartedAt === null) retryStartedAt = Date.now();
 						const delayMs = autoRetryBackoffMs(retryStreak);
@@ -1824,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-Bqa5HjY3.js.map
+//# sourceMappingURL=ts-B64pNQlI.js.map

package/dist/{versionChecker-ZIgviJ62.js → versionChecker-DKiSuTSp.js}

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

package/dist/{webrtcLink-BG0Xc4-W.js → webrtcLink-B7REGtK2.js}

@@ -1,4 +1,4 @@
-import { u as parseSecret } from "./e2e-BeKjLhmO.js";
+import { u as parseSecret } from "./e2e-jb0Hp43q.js";
 
 //#region ts/webrtcLink.ts
 const SIGNAL_SUBPROTOCOL = "ay-signal-1";
@@ -42,4 +42,4 @@ function isWebrtcSpec(spec) {
 
 //#endregion
 export { isWebrtcSpec as n, parseWebrtcLink as r, SIGNAL_SUBPROTOCOL as t };
-//# sourceMappingURL=webrtcLink-BG0Xc4-W.js.map
+//# sourceMappingURL=webrtcLink-B7REGtK2.js.map

package/dist/{webrtcRemote-BmuVKcrx.js → webrtcRemote-CvIEfWX8.js}

@@ -1,5 +1,5 @@
-import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-BeKjLhmO.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-BG0Xc4-W.js";
+import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-jb0Hp43q.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-B7REGtK2.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/webrtcRemote.ts
@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-BmuVKcrx.js.map
+//# sourceMappingURL=webrtcRemote-CvIEfWX8.js.map

package/dist/{workspaceConfig-_GtAZtsi.js → workspaceConfig-CjaRvTjf.js}

@@ -193,4 +193,4 @@ function resolveSpawnCwd(input) {
 
 //#endregion
 export { getSpawnHook as a, hasProvisionHook as c, resolveSpawnCwd as d, setWorkspaceRoot as f, getProvisionRoot as i, hasSpawnHook as l, getMinFreeMb as n, getSpawnWaitMs as o, getProvisionHook as r, getWorkspaceRoot as s, getMaxAgents as t, isProvisionAllowed as u };
-//# sourceMappingURL=workspaceConfig-_GtAZtsi.js.map
+//# sourceMappingURL=workspaceConfig-CjaRvTjf.js.map

package/package.json

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

package/ts/autoRetry.spec.ts

@@ -1,5 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { AUTO_RETRY_MAX_DELAY_SECS, autoRetryBackoffMs, shouldFireRetry } from "./autoRetry.ts";
+import {
+  AUTO_RETRY_MAX_DELAY_SECS,
+  AUTO_RETRY_REASON_FALLBACK,
+  AUTO_RETRY_REASONS,
+  autoRetryBackoffMs,
+  buildAutoRetryMessage,
+  classifyAutoRetryReason,
+  formatDurationSecs,
+  shouldFireRetry,
+} from "./autoRetry.ts";
+import { loadSharedCliDefaults } from "./configShared.ts";
 
 describe("autoRetryBackoffMs", () => {
   it("doubles 8,16,32,…,256 then caps", () => {
@@ -32,3 +42,82 @@ describe("shouldFireRetry", () => {
     expect(shouldFireRetry(false, true, 10_000, 5_000)).toBe(true);
   });
 });
+
+describe("classifyAutoRetryReason", () => {
+  it("maps real banners to inert paraphrases", () => {
+    expect(classifyAutoRetryReason("● API Error: 529 Overloaded")).toBe(AUTO_RETRY_REASONS[0]);
+    expect(classifyAutoRetryReason("API Error: Response stalled mid-stream.")).toBe(
+      AUTO_RETRY_REASONS[1],
+    );
+    expect(classifyAutoRetryReason("API Error: Connection closed mid-response.")).toBe(
+      AUTO_RETRY_REASONS[2],
+    );
+    expect(classifyAutoRetryReason("Claude usage limit reached")).toBe(AUTO_RETRY_REASONS[3]);
+    expect(classifyAutoRetryReason("You are being rate-limited")).toBe(AUTO_RETRY_REASONS[4]);
+    expect(classifyAutoRetryReason("API Error: 503 Service Unavailable")).toBe(
+      AUTO_RETRY_REASON_FALLBACK,
+    );
+  });
+});
+
+describe("formatDurationSecs", () => {
+  it("renders s / m / h forms", () => {
+    expect(formatDurationSecs(0)).toBe("0s");
+    expect(formatDurationSecs(45)).toBe("45s");
+    expect(formatDurationSecs(60)).toBe("1m");
+    expect(formatDurationSecs(200)).toBe("3m20s");
+    expect(formatDurationSecs(3600)).toBe("1h");
+    expect(formatDurationSecs(3900)).toBe("1h05m");
+    expect(formatDurationSecs(8 * 3600)).toBe("8h");
+  });
+});
+
+describe("buildAutoRetryMessage", () => {
+  it("is one line and carries attempt/reason/backoff context + ignore clause", () => {
+    const msg = buildAutoRetryMessage(3, AUTO_RETRY_REASONS[0], 45, 64);
+    expect(msg).not.toContain("\n");
+    expect(msg.startsWith("retry [")).toBe(true);
+    expect(msg).toContain("#3");
+    expect(msg).toContain("45s ago");
+    expect(msg).toContain("in 1m04s");
+    expect(msg).toContain("giving up after 8h");
+    expect(msg).toContain("ignore it");
+  });
+
+  // Self-trigger guard: the message is typed into the PTY and stays visible in
+  // the transcript, so if it ever matched a CLI's own screen-scrape patterns
+  // it would re-arm the retry loop (autoRetry), block the streak reset, kill
+  // the session (fatal), or fake a state (working/enter/needsInput). Mirrors
+  // rs/src/config.rs test_auto_retry_message_is_inert_against_all_cli_patterns.
+  it("never matches any CLI's screen-scrape patterns", async () => {
+    const clis = await loadSharedCliDefaults();
+    expect(Object.keys(clis).length).toBeGreaterThan(0);
+    for (const [cliName, conf] of Object.entries(clis)) {
+      for (const reason of AUTO_RETRY_REASONS) {
+        const cases: [number, number, number][] = [
+          [1, 0, 8],
+          [5, 500, 128],
+          [12, 30_000, 256],
+        ];
+        for (const [attempt, since, next] of cases) {
+          const msg = buildAutoRetryMessage(attempt, reason, since, next);
+          const groups: [string, RegExp[] | undefined][] = [
+            ["autoRetry", conf.autoRetry],
+            ["fatal", conf.fatal],
+            ["enter", conf.enter],
+            ["working", conf.working],
+            ["needsInput", conf.needsInput],
+          ];
+          for (const [kind, patterns] of groups) {
+            for (const rx of patterns ?? []) {
+              expect(
+                rx.test(msg),
+                `retry message must not match ${cliName}.${kind} /${rx}/: ${msg}`,
+              ).toBe(false);
+            }
+          }
+        }
+      }
+    }
+  });
+});

package/ts/autoRetry.ts

@@ -37,3 +37,79 @@ export function shouldFireRetry(
 ): boolean {
   return !working && ready && idleMs >= minIdleMs;
 }
+
+/** Fallback reason when no autoRetry match was captured before firing. */
+export const AUTO_RETRY_REASON_FALLBACK = "a transient server-side error";
+
+/**
+ * All reason strings `classifyAutoRetryReason` can produce — used by the
+ * self-trigger guard spec to prove every possible typed message is inert
+ * against every CLI's screen-scrape patterns. Mirrors Rust's RETRY_REASONS.
+ */
+export const AUTO_RETRY_REASONS = [
+  "the model backend reported it is temporarily busy",
+  "the response stream stalled mid-way",
+  "the connection dropped mid-response",
+  "a usage cap was reached (it may need time to reset)",
+  "requests are being throttled by the server",
+  AUTO_RETRY_REASON_FALLBACK,
+] as const;
+
+/**
+ * Paraphrase the matched recoverable-error banner into a short reason.
+ *
+ * Deliberately NEVER echoes the raw banner wording ("API Error", "Overloaded",
+ * "rate limit", …): the built message is typed into the PTY and stays visible
+ * in the transcript, where raw wording would re-match the autoRetry patterns —
+ * keeping the error state true forever, which blocks the streak reset on
+ * recovery. Mirrors Rust's classify_retry_reason.
+ */
+export function classifyAutoRetryReason(screen: string): string {
+  const s = screen.toLowerCase();
+  if (s.includes("overload")) return AUTO_RETRY_REASONS[0];
+  if (s.includes("stalled")) return AUTO_RETRY_REASONS[1];
+  if (s.includes("connection closed")) return AUTO_RETRY_REASONS[2];
+  if (s.includes("usage limit") || s.includes("session limit")) return AUTO_RETRY_REASONS[3];
+  if (s.includes("rate") && s.includes("limit")) return AUTO_RETRY_REASONS[4];
+  return AUTO_RETRY_REASON_FALLBACK;
+}
+
+/** Human-readable duration: "45s", "3m20s", "1h04m", "8h". Mirrors Rust's fmt_dur_secs. */
+export function formatDurationSecs(total: number): string {
+  const t = Math.max(0, Math.floor(total));
+  if (t < 60) return `${t}s`;
+  if (t < 3600) {
+    const m = Math.floor(t / 60);
+    const s = t % 60;
+    return s === 0 ? `${m}m` : `${m}m${String(s).padStart(2, "0")}s`;
+  }
+  const h = Math.floor(t / 3600);
+  const m = Math.floor((t % 3600) / 60);
+  return m === 0 ? `${h}h` : `${h}h${String(m).padStart(2, "0")}m`;
+}
+
+/**
+ * The single line typed into the agent's prompt instead of a bare "retry":
+ * says WHO is nudging (agent-yes, automated), WHY (paraphrased reason), and
+ * the backoff state (attempt #, elapsed, next delay, give-up horizon), plus an
+ * explicit "ignore if nothing failed" clause so an agent that already
+ * recovered — or is mid-question — doesn't burn a turn asking what "retry"
+ * refers to. Must stay one line (it is submitted with a single "\r").
+ * Mirrors Rust's build_retry_message in rs/src/context.rs.
+ */
+export function buildAutoRetryMessage(
+  attempt: number,
+  reason: string,
+  sinceFirstSecs: number,
+  nextBackoffSecs: number,
+): string {
+  const since = formatDurationSecs(sinceFirstSecs);
+  const next = formatDurationSecs(nextBackoffSecs);
+  const giveUp = formatDurationSecs(AUTO_RETRY_GIVE_UP_MS / 1000);
+  return (
+    `retry [auto-retry #${attempt} by agent-yes: ${reason}; first seen ${since} ago; ` +
+    `if this attempt fails too, the next nudge comes in ${next} (giving up after ${giveUp}). ` +
+    `This is an automated recovery nudge - if no request actually failed, ignore it and ` +
+    `simply continue your previous task.]`
+  );
+}