agent-yes 1.196.2 → 1.197.0

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.]`
+  );
+}

package/ts/index.ts

@@ -21,9 +21,14 @@ import { sendEnter, sendMessage } from "./core/messaging.ts";
 import {
   AUTO_RETRY_GIVE_UP_MS,
   AUTO_RETRY_MIN_IDLE_MS,
+  AUTO_RETRY_REASON_FALLBACK,
   autoRetryBackoffMs,
+  buildAutoRetryMessage,
+  classifyAutoRetryReason,
+  formatDurationSecs,
   shouldFireRetry,
 } from "./autoRetry.ts";
+import { recordInbox } from "./messageLog.ts";
 import {
   initializeLogPaths,
   setupDebugLogging,
@@ -794,6 +799,9 @@ export default async function agentYes({
   let retryStartedAt: number | null = null;
   let retryNextAt: number | null = null;
   let autoRetryScreen = "";
+  // Paraphrased reason captured when the error banner was matched — folded
+  // into the typed retry message so the agent knows why it is being nudged.
+  let retryReason: string | null = null;
   const heartbeatInterval = setInterval(async () => {
     try {
       const rendered = removeControlCharacters(xtermProxy.tail(12));
@@ -822,15 +830,36 @@ export default async function agentYes({
             retryNextAt = now + 500; // busy / not at prompt / still active — re-check shortly
           } else {
             retryStreak += 1;
-            logger.warn(`[${cli}-yes] auto-retry: typing 'retry' (attempt ${retryStreak})`);
-            // Write "retry" + Enter atomically (mirrors rs do_send_retry); using
+            const nextBackoffMs = autoRetryBackoffMs(retryStreak);
+            const reason = retryReason ?? AUTO_RETRY_REASON_FALLBACK;
+            const sinceFirstSecs = retryStartedAt === null ? 0 : (now - retryStartedAt) / 1000;
+            const line = buildAutoRetryMessage(
+              retryStreak,
+              reason,
+              sinceFirstSecs,
+              nextBackoffMs / 1000,
+            );
+            logger.warn(
+              `[${cli}-yes] auto-retry: typing retry nudge (attempt ${retryStreak}, reason: ${reason})`,
+            );
+            // Write the nudge + Enter atomically (mirrors rs do_send_retry); using
             // sendMessage would split text/Enter across the fast heartbeat ticks.
-            ctx.messageContext.shell.write("retry\r");
+            ctx.messageContext.shell.write(line + "\r");
             ctx.idleWaiter.ping();
+            // Structured trace for `ay msgs` / the console (mirrors the Rust
+            // runtime's record_auto_retry_inbox) — best-effort, never blocks.
+            void recordInbox({
+              at: now,
+              from: null,
+              to: { pid: process.pid, cli, cwd: workingDir },
+              kind: "auto-retry",
+              body: `${reason} (attempt ${retryStreak}, next backoff ${formatDurationSecs(nextBackoffMs / 1000)})`,
+              wrapped: false,
+            });
             // Self-schedule the next retry with escalated backoff. (Leaving nextAt
             // null and re-arming from the stdout pipeline would tight-loop while the
             // error banner stays on screen.) Reset on recovery cancels this.
-            retryNextAt = now + autoRetryBackoffMs(retryStreak);
+            retryNextAt = now + nextBackoffMs;
           }
         }
       }
@@ -1185,6 +1214,10 @@ export default async function agentYes({
               const errVisible = conf.autoRetry.some((rx: RegExp) => rx.test(rendered));
               const readyVisible = conf.ready?.some((rx: RegExp) => rx.test(rendered)) ?? false;
               if (errVisible && readyVisible) {
+                // Remember WHY (paraphrased — see classifyAutoRetryReason) so
+                // the typed message can explain itself. Refresh on every match:
+                // the banner may change across attempts (e.g. overload → 5xx).
+                retryReason = classifyAutoRetryReason(rendered);
                 if (retryNextAt === null) {
                   if (retryStartedAt === null) retryStartedAt = Date.now();
                   const delayMs = autoRetryBackoffMs(retryStreak);

package/ts/messageLog.ts

@@ -39,8 +39,9 @@ export interface MessageRecord {
   to: MailParty;
   /** What kind of stdin write this was. Omitted for a normal `ay send` text
    * message; "key" for raw keystrokes (`ay key`), "select" for a menu pick
-   * (`ay select`). For key/select the `body` holds the key names / choice. */
-  kind?: "key" | "select";
+   * (`ay select`), "auto-retry" for the wrapper's own recoverable-error nudge
+   * (from is null; `body` holds the paraphrased reason + backoff state). */
+  kind?: "key" | "select" | "auto-retry";
   /** The message body (without the `[ay-msg …]` wrapper), or — for a key/select
    * record — the keystroke names / chosen option. */
   body: string;

package/ts/serve.ts

@@ -26,6 +26,7 @@ import {
   type CommonOpts,
 } from "./subcommands.ts";
 import { TYPING_BADGE } from "./badges.ts";
+import { isTerminalReply } from "./terminalReply.ts";
 import { ensureNodeRuntime, liveEnv } from "./nodeRuntime.ts";
 import { type MailParty, recordInbox } from "./messageLog.ts";
 import { updateGlobalPidStatus } from "./globalPidIndex.ts";
@@ -1565,11 +1566,9 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // resolveLastStdinAt below and the /api/send handler that stamps these.
   const meaningfulStdinAt = new Map<number, number>();
   const anyDaemonWriteAt = new Map<number, number>();
-  // A payload that is PURELY a terminal auto-reply (Cursor Position Report, Device
-  // Attributes, Device Status Report) — protocol chatter a TUI emits on redraw/resize,
-  // not a keystroke. Anchored so a chunk that also carries real input never matches;
-  // real typing (incl. arrow keys like `ESC[A`) never looks like one of these.
-  const isTerminalReply = (s: string) => /^\x1b\[(\d+;\d+R|\?[\d;]*c|>[\d;]*c|\d*n)$/.test(s);
+  // isTerminalReply (ts/terminalReply.ts) spots payloads that are purely such
+  // auto-replies — incl. the DECXCPR `ESC[?r;cR` form and bursts of several
+  // replies concatenated in one chunk — so they never count as meaningful.
   // Stamp both maps after a daemon FIFO write, keyed off the FIFO's post-write mtime
   // (so `anyDaemonWriteAt` is exactly our write's mtime — an external write bumps it
   // strictly higher, which is how resolveLastStdinAt tells them apart with no clock skew).

package/ts/subcommands.ts

@@ -211,7 +211,7 @@ export interface MessageEdge {
   by: number;
   target: number;
   at: number;
-  kind?: "key" | "select";
+  kind?: "key" | "select" | "auto-retry";
 }
 
 /**
@@ -3279,10 +3279,14 @@ async function cmdMsgs(rest: string[]): Promise<number> {
 
   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"}`;
+    // auto-retry nudges are written by the agent's own wrapper (from is null
+    // there too) — label them as agent-yes, not a human send.
+    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 tag = rec.kind ? `[${rec.kind}] ` : "";

package/ts/terminalReply.spec.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { isTerminalReply } from "./terminalReply.ts";
+
+describe("isTerminalReply", () => {
+  it("matches single auto-replies (CPR, DECXCPR, DA1, DA2, DSR)", () => {
+    expect(isTerminalReply("\x1b[5;10R")).toBe(true); // CPR (ESC[6n answer)
+    expect(isTerminalReply("\x1b[?1;1R")).toBe(true); // DECXCPR (ESC[?6n answer)
+    expect(isTerminalReply("\x1b[?1;1;1R")).toBe(true); // DECXCPR with page
+    expect(isTerminalReply("\x1b[?1;2c")).toBe(true); // DA1
+    expect(isTerminalReply("\x1b[>0;276;0c")).toBe(true); // DA2
+    expect(isTerminalReply("\x1b[0n")).toBe(true); // DSR status OK
+  });
+
+  it("matches a burst of replies concatenated in one chunk", () => {
+    // A viewer attach replays a tail full of queries; xterm answers them all
+    // in one onData chunk.
+    expect(isTerminalReply("\x1b[?1;1R\x1b[?1;1R\x1b[?1;1R")).toBe(true);
+    expect(isTerminalReply("\x1b[1;1R\x1b[?1;2c\x1b[0n")).toBe(true);
+  });
+
+  it("never matches real typing", () => {
+    expect(isTerminalReply("hello")).toBe(false);
+    expect(isTerminalReply("\r")).toBe(false);
+    expect(isTerminalReply("\x1b[A")).toBe(false); // arrow key
+    expect(isTerminalReply("\x1b[1;5C")).toBe(false); // ctrl+arrow (no R/c/n final)
+    expect(isTerminalReply("\x1b")).toBe(false);
+    expect(isTerminalReply("")).toBe(false);
+    expect(isTerminalReply("\x1b[R")).toBe(false); // malformed — not a reply xterm emits
+  });
+
+  it("never matches a chunk that mixes a reply with real input", () => {
+    expect(isTerminalReply("\x1b[?1;1Ry")).toBe(false);
+    expect(isTerminalReply("y\x1b[?1;1R")).toBe(false);
+    expect(isTerminalReply("\x1b[1;1R\r")).toBe(false);
+  });
+});

package/ts/terminalReply.ts

@@ -0,0 +1,17 @@
+/**
+ * Is this /api/send payload PURELY terminal auto-reply chatter — the responses
+ * a viewer's xterm generates to the agent TUI's protocol queries (Cursor
+ * Position Report incl. the DECXCPR `?`-prefixed form, Device Attributes,
+ * Device Status Report) — rather than a keystroke?
+ *
+ * Used by the serve daemon to keep such writes out of `last_stdin_at`, so a
+ * redraw/resize (or a TUI polling `ESC[?6n` every render) can't pin the
+ * console's stdin-flash + stdin age at "just typed".
+ *
+ * Anchored over ONE-OR-MORE replies: a burst of queries (e.g. tail replay on
+ * viewer attach) is answered in a single onData chunk, so several replies
+ * arrive concatenated in one payload. Real typing — including arrow keys like
+ * `ESC[A` — never matches any alternative.
+ */
+export const isTerminalReply = (s: string): boolean =>
+  /^(?:\x1b\[(?:\??\d+(?:;\d+)*R|\?[\d;]*c|>[\d;]*c|\d*n))+$/.test(s);

package/dist/SUPPORTED_CLIS-BBTAJQVG.js

@@ -1,8 +0,0 @@
-import "./ts-ml_9eD1Y.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-ufJXjxRK.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BuiThZSF.js";
-
-export { SUPPORTED_CLIS };