agent-yes 1.162.0 → 1.165.0

package/lab/ui/index.html

@@ -891,6 +891,11 @@
         color: var(--green);
         border-color: #2a3a2a;
       }
+      /* The pending question when an agent needs_input — blue accent to match the
+         needs_input dot, reading as "your turn / here's what it's asking". */
+      .detail.ask {
+        color: var(--accent);
+      }
       .detail {
         color: var(--muted);
         font-size: 12.5px;
@@ -3187,13 +3192,19 @@
         );
       }
 
-      // A small git chip (±changed ↑ahead ↓behind) for a row, amber when the tree
-      // is dirty. Empty for clean/in-sync repos and non-git cwds — no noise.
+      // A small git chip (±changed ⑂pins ⊙sub-dirty ↑ahead ↓behind) for a row,
+      // amber when the tree has real file changes. Submodule pin-drift shows as a
+      // muted "⑂" that never turns the chip amber, so it can't bury real edits.
+      // Empty for clean/in-sync repos and non-git cwds — no noise.
       function gitChipHtml(e) {
         const label = gitLabel(e);
         if (!label) return "";
         const g = e.git || {};
-        const tip = `git: ${g.changed || 0} changed · ${g.ahead || 0} ahead · ${g.behind || 0} behind`;
+        const tip =
+          `git: ${g.changed || 0} changed file${(g.changed || 0) === 1 ? "" : "s"}` +
+          (g.pins ? ` · ${g.pins} submodule pin-bump${g.pins === 1 ? "" : "s"}` : "") +
+          (g.subDirty ? ` · ${g.subDirty} submodule dirty` : "") +
+          ` · ${g.ahead || 0} ahead · ${g.behind || 0} behind`;
         return `<span class="git${g.dirty ? " dirty" : ""}" title="${esc(tip)}">${esc(label)}</span>`;
       }
 
@@ -3285,7 +3296,13 @@
           ${gitChipHtml(e)}
           <span class="age">${age(e)}</span></div>
         ${e.title ? `<div class="rowtitle" title="${esc(e.title)}">${esc(e.title)}</div>` : ""}
-        ${e.prompt ? `<div class="detail" title="${esc(e.prompt)}">${esc(e.prompt)}</div>` : ""}
+        ${
+          e.status === "needs_input" && e.question
+            ? `<div class="detail ask" title="${esc(e.question)}">⌨ ${esc(e.question)}</div>`
+            : e.prompt
+              ? `<div class="detail" title="${esc(e.prompt)}">${esc(e.prompt)}</div>`
+              : ""
+        }
         <div class="rowtags">${tags}</div>
       </div>`;
             })
@@ -3918,7 +3935,7 @@
               return `<div class="omni-row omni-spawn${sc}" data-i="${i}">
                 <span class="dot active"></span>
                 <div class="omni-main">
-                  <div class="omni-title">⑂ Fork <b>${esc(r.srcBranch)}</b> &amp; run <span style="opacity:.55">(carries uncommitted work)</span></div>
+                  <div class="omni-title">⑂ Fork <b>${esc(r.srcBranch)}</b> &amp; run <span style="opacity:.55">(clean — committed work only)</span></div>
                   <div class="omni-sub">${esc(r.fromCwd)} &nbsp;→&nbsp; new branch <b>${esc(r.branch)}</b> &nbsp;·&nbsp; ⏎ to edit &amp; launch</div>
                 </div></div>`;
             }
@@ -4050,14 +4067,12 @@
           return;
         }
         if (row && row.kind === "fork") {
-          // Editable at launch (auto-slug is the default); carries the source's WIP.
+          // Editable at launch (auto-slug is the default). The fork is clean —
+          // committed work only, the source's uncommitted changes stay put.
           // Fork from the source PINNED on the row (row.fromCwd), not a freshly
           // re-resolved anchor — the anchor can drift as the list refreshes, but the
           // branch we fork from must be the one the row was built for.
-          const branch = prompt(
-            "Fork to a new branch (carries your uncommitted work):",
-            row.branch,
-          );
+          const branch = prompt("Fork to a new branch (clean — committed work only):", row.branch);
           if (!branch || !branch.trim()) return; // cancelled — leave the omnibox open
           closeOmni(false);
           await spawnAndSelect(

package/package.json

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

package/ts/needsInput.spec.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { classifyNeedsInput, isWorkingScreen } from "./needsInput.ts";
+import { classifyNeedsInput, isWorkingScreen, parseMenu } from "./needsInput.ts";
 import { loadSharedCliDefaults } from "./configShared.ts";
 
 // Use the REAL shipped claude/codex patterns so the test guards the actual config.
@@ -72,3 +72,44 @@ test("detects a codex selection menu (› cursor)", () => {
 test("no patterns configured → always null", () => {
   expect(classifyNeedsInput(["❯ 1. anything"], { needsInput: [], working: [] })).toBeNull();
 });
+
+test("parseMenu: cursor on option 1, all options collected (for ay select)", () => {
+  const screen = [
+    "Which auth method should we use?",
+    "",
+    "❯ 1. Session tokens",
+    "  2. JWT",
+    "  3. OAuth",
+    "",
+    "? for shortcuts",
+  ];
+  const menu = parseMenu(screen, claude);
+  expect(menu).not.toBeNull();
+  expect(menu!.cursor).toBe(1);
+  expect(menu!.options).toEqual([1, 2, 3]);
+});
+
+test("parseMenu: reads a pre-highlighted non-first default (cursor delta, not blind N-1)", () => {
+  const screen = ["Proceed?", "  1. Yes", "❯ 2. No, ask again", "  3. Cancel"];
+  const menu = parseMenu(screen, claude);
+  expect(menu!.cursor).toBe(2);
+  expect(menu!.options).toEqual([1, 2, 3]);
+});
+
+test("parseMenu: codex › cursor", () => {
+  const menu = parseMenu(["Pick a branch", "  1. main", "› 2. develop"], codex);
+  expect(menu!.cursor).toBe(2);
+  expect(menu!.options).toEqual([1, 2]);
+});
+
+test("parseMenu: null when not on a menu (idle prompt / working)", () => {
+  expect(parseMenu(['❯ Try "fix the bug"', "? for shortcuts"], claude)).toBeNull();
+  expect(parseMenu(["❯ 1. Session tokens", "✻ Working… (esc to interrupt)"], claude)).toBeNull();
+});
+
+test("parseMenu: a 'N.M' version in an option label isn't mistaken for another option", () => {
+  const screen = ["Cleanup?", "❯ 1. Delete 3.5GB of cache", "  2. Keep"];
+  const menu = parseMenu(screen, claude);
+  expect(menu!.cursor).toBe(1);
+  expect(menu!.options).toEqual([1, 2]);
+});

package/ts/needsInput.ts

@@ -67,6 +67,60 @@ export function classifyNeedsInput(
   return { question: block.join(" • ").slice(0, 400) };
 }
 
+export interface MenuState {
+  /** The 1-based option number the menu cursor (❯/›/>) currently sits on. */
+  cursor: number;
+  /** Every visible option number, ascending — for range-checking a requested N. */
+  options: number[];
+  /** Same compact menu rendering as {@link classifyNeedsInput}. */
+  question: string;
+}
+
+// An option row: an optional cursor glyph / bullet, then "N. " (the trailing
+// space rejects version-like "3.5GB" that isn't a menu option).
+const OPTION_LINE = /^[\s❯›>▶◉○●·*\-]*?(\d+)\.\s/;
+
+/**
+ * Parse the selection menu a `needs_input` agent is parked on into a cursor
+ * position + the available option numbers, so a caller can compute how far the
+ * cursor must move (Down/Up) to reach a target option. Returns null when the
+ * screen isn't a menu (delegates that judgement to {@link classifyNeedsInput},
+ * so `working` still wins) or no numbered cursor line is found. Pure — the
+ * `ay select` action reuses the exact detection `ay ls` renders with.
+ */
+export function parseMenu(
+  lines: string[],
+  cfg: { needsInput?: RegExp[]; working?: RegExp[] },
+): MenuState | null {
+  const ni = classifyNeedsInput(lines, cfg);
+  if (!ni) return null;
+  const patterns = cfg.needsInput ?? [];
+  // The cursor line is the last one carrying a needsInput match (matches how
+  // classifyNeedsInput anchors its question window).
+  let cursorLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (patterns.some((re) => reTest(re, lines[i]!))) cursorLine = i;
+  }
+  if (cursorLine < 0) return null;
+  const cm = /(\d+)\./.exec(lines[cursorLine]!);
+  if (!cm) return null;
+  const cursor = parseInt(cm[1]!, 10);
+  // Gather option numbers from the rows around the cursor (a menu is contiguous).
+  const start = Math.max(0, cursorLine - 12);
+  const end = Math.min(lines.length, cursorLine + 12);
+  const options: number[] = [];
+  for (let i = start; i < end; i++) {
+    const m = OPTION_LINE.exec(lines[i]!);
+    if (m) {
+      const v = parseInt(m[1]!, 10);
+      if (!options.includes(v)) options.push(v);
+    }
+  }
+  if (!options.includes(cursor)) options.push(cursor);
+  options.sort((a, b) => a - b);
+  return { cursor, options, question: ni.question };
+}
+
 /**
  * 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

package/ts/serve.ts

@@ -9,6 +9,7 @@ import yargs from "yargs";
 import {
   controlCodeFromName,
   deriveLiveStatus,
+  extractNeedsInput,
   extractTaskCounts,
   listRecords,
   readNotes,
@@ -172,12 +173,15 @@ function loginShellEnv(): Record<string, string> | null {
     // Delimiters fence off the env dump from any banner/prompt noise the rc files
     // print to stdout; `env -0` is NUL-separated so values with newlines survive.
     const delim = "_AY_SHELL_ENV_DELIM_";
-    const res = Bun.spawnSync([shell, "-ilc", `printf %s "${delim}"; env -0; printf %s "${delim}"`], {
-      stdin: "ignore",
-      stderr: "ignore",
-      timeout: 5_000,
-      env: process.env as Record<string, string>,
-    });
+    const res = Bun.spawnSync(
+      [shell, "-ilc", `printf %s "${delim}"; env -0; printf %s "${delim}"`],
+      {
+        stdin: "ignore",
+        stderr: "ignore",
+        timeout: 5_000,
+        env: process.env as Record<string, string>,
+      },
+    );
     const out = res.stdout?.toString() ?? "";
     const start = out.indexOf(delim);
     const end = out.lastIndexOf(delim);
@@ -930,8 +934,37 @@ export async function cmdServe(rest: string[]): Promise<number> {
     }
   };
 
+  // Per-agent "waiting on you" detection: the agent is parked on an interactive
+  // menu it did NOT auto-resolve (config `needsInput` patterns). Same source and
+  // classifier as `ay ls` / `ay status`, so the console's dot matches the CLI's
+  // needs_input. Cached per (size, mtime) exactly like logTitle/logTasks — each
+  // miss renders a log window through xterm, so the 1s list tick stays cheap on
+  // an idle fleet. Returns the pending question text (surfaced in the UI), or
+  // null when the agent isn't blocked.
+  const niCache = new Map<string, { size: number; mtimeMs: number; question: string | null }>();
+  const logNeedsInput = async (
+    logFile: string | null | undefined,
+    cli: string,
+  ): Promise<string | null> => {
+    if (!logFile) return null;
+    try {
+      const { size, mtimeMs } = await stat(logFile);
+      const hit = niCache.get(logFile);
+      if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.question;
+      const ni = await extractNeedsInput(logFile, cli);
+      const question = ni?.question ?? null;
+      niCache.set(logFile, { size, mtimeMs, question });
+      return question;
+    } catch {
+      return null;
+    }
+  };
+
   // Per-repo git snapshot for the list (branch + dirty/changed + ahead/behind, from
-  // one `git status --porcelain --branch`). WATCHER-INVALIDATED, not polled: a read
+  // one `git status --porcelain=v2 --branch`). v2 (not v1) so the submodule field
+  // lets us split real file changes from submodule pin-drift, which would otherwise
+  // inflate `changed` — in a superproject with many submodules the constant gitlink
+  // drift buries the real edits. WATCHER-INVALIDATED, not polled: a read
   // returns the cached snapshot instantly and NEVER spawns `git status` on the
   // request path. A per-repo-root fs watcher recomputes (debounced) only when the
   // repo actually changes, so an idle fleet costs ~0 git processes. The old design
@@ -942,7 +975,9 @@ export async function cmdServe(rest: string[]): Promise<number> {
   interface GitInfo {
     branch: string | null;
     dirty: boolean;
-    changed: number;
+    changed: number; // real file changes (excludes submodule pin-bumps & internal dirt)
+    pins: number; // submodule gitlinks pointing at new commit(s) — pin-bump/drift
+    subDirty: number; // submodule has internal changes but its recorded pin is unchanged
     ahead: number;
     behind: number;
   }
@@ -964,16 +999,55 @@ export async function cmdServe(rest: string[]): Promise<number> {
     }
   };
   const parseGitStatus = (out: string): GitInfo => {
-    const lines = out.split("\n");
-    // Branch header, e.g. "## main...origin/main [ahead 1, behind 2]", "## main"
-    // (no upstream), "## HEAD (no branch)", or "## No commits yet on x".
-    const h = /^## (.+)$/.exec(lines[0] ?? "")?.[1] ?? "";
-    const unborn = /^No commits yet on (.+)$/.exec(h);
-    const branch = unborn ? unborn[1]! : /^(.+?)(?:\.\.\.|\s|$)/.exec(h)?.[1] || null;
-    const ahead = Number(/\bahead (\d+)/.exec(h)?.[1] ?? 0);
-    const behind = Number(/\bbehind (\d+)/.exec(h)?.[1] ?? 0);
-    const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
-    return { branch, dirty: changed > 0, changed, ahead, behind };
+    // porcelain=v2 --branch: "# branch.*" headers then one line per changed entry.
+    let branch: string | null = null;
+    let ahead = 0;
+    let behind = 0;
+    let changed = 0; // real file changes
+    let pins = 0; // submodule pin-bumps (gitlink → new commit)
+    let subDirty = 0; // submodule internal dirt, recorded pin unchanged
+    for (const line of out.split("\n")) {
+      if (line.length === 0) continue;
+      if (line[0] === "#") {
+        // "# branch.head <name|(detached)>" and "# branch.ab +A -B" (ab absent
+        // when there's no upstream). branch.head carries the name even on an
+        // unborn branch, so no special-casing needed.
+        const head = /^# branch\.head (.+)$/.exec(line);
+        if (head) {
+          branch = head[1] === "(detached)" ? null : head[1]!;
+          continue;
+        }
+        const ab = /^# branch\.ab \+(\d+) -(\d+)/.exec(line);
+        if (ab) {
+          ahead = Number(ab[1]);
+          behind = Number(ab[2]);
+        }
+        continue;
+      }
+      // Changed-entry lines. Untracked ("?") and unmerged ("u") are always real
+      // work; ignored ("!") never appears (we don't pass --ignored). For ordinary
+      // ("1") / renamed ("2") entries the 3rd space-delimited token is the
+      // submodule field <sub>: "N..." for a normal path, or "S<c><m><u>" for a
+      // submodule where c=C means its gitlink moved to new commit(s) (pin-bump),
+      // and m/u flag internal dirty/untracked with the recorded pin unchanged.
+      // Paths (which may contain spaces) come after token 2, so counting by token
+      // index is robust without -z.
+      const type = line[0];
+      if (type === "?") {
+        changed++;
+      } else if (type === "u") {
+        changed++;
+      } else if (type === "1" || type === "2") {
+        const sub = line.split(" ")[2] ?? "N...";
+        if (sub[0] === "S") {
+          if (sub[1] === "C") pins++;
+          else subDirty++;
+        } else {
+          changed++;
+        }
+      }
+    }
+    return { branch, dirty: changed > 0, changed, pins, subDirty, ahead, behind };
   };
   // cwd -> repo root ("" = resolved, not a repo). Resolved once per cwd via a cheap
   // `git rev-parse --show-toplevel` (no tree scan) and cached, so many agents in the
@@ -999,7 +1073,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
       if (rw.busy) return void recompute(root, rw); // re-arm if one is in flight
       rw.busy = true;
       try {
-        const out = await runGit(["status", "--porcelain", "--branch"], root);
+        const out = await runGit(["status", "--porcelain=v2", "--branch"], root);
         if (out != null) rw.val = parseGitStatus(out);
       } finally {
         rw.busy = false;
@@ -1051,12 +1125,23 @@ export async function cmdServe(rest: string[]): Promise<number> {
     // the LIVE status here — same liveness+log-mtime basis as `ay ls` — so the
     // console's dot (and the browser tab glyph) flips to idle in step with `ay ls`.
     const status = await deriveLiveStatus(r);
+    // "Waiting on you": alive, quiet, but parked on an unanswered menu. Checked
+    // only for live agents, and skipped when unresponsive (the Rust wedge signal
+    // wins) — mirroring deriveLiveState's precedence in `ay ls` so the console's
+    // dot and the CLI agree.
+    const question =
+      status !== "exited" && !r.unresponsive ? await logNeedsInput(r.log_file, r.cli) : null;
     return {
       ...r,
-      // The Rust supervisor's unresponsive flag is an authoritative wedge signal —
-      // surface it as `stuck` so the console's dot matches `ay ls`. (A dead agent
-      // is never unresponsive — Rust clears the flag on exit.)
-      status: status !== "exited" && r.unresponsive ? "stuck" : status,
+      // Precedence: exited stays exited; the Rust supervisor's unresponsive flag is
+      // an authoritative wedge signal (`stuck`); then a blocked menu (`needs_input`);
+      // else the base live status — so the console's dot matches `ay ls`. (A dead
+      // agent is never unresponsive — Rust clears the flag on exit.)
+      status:
+        status === "exited" ? status : r.unresponsive ? "stuck" : question ? "needs_input" : status,
+      // The pending menu/question text when needs_input, for the console to show
+      // WHAT the agent is waiting on. Null otherwise.
+      question,
       title: await logTitle(r.log_file),
       git: status === "exited" ? null : await gitStatus(r.cwd),
       // Task progress from the rendered todo block (null when none detected → no
@@ -1642,9 +1727,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
         return new Response("fork requires a non-empty fromCwd and branch", { status: 400 });
       const from = typeof body.from === "string" ? body.from.trim() : "";
       if (fork) {
-        // Fork the anchor agent's branch (carrying its WIP) into a new sibling
-        // worktree via codehost/provision (git worktree off HEAD, no clone), then
-        // spawn the agent there.
+        // Fork the anchor agent's branch into a new sibling worktree via
+        // codehost/provision (git worktree off HEAD, no clone), then spawn the
+        // agent there. The fork is clean — committed work only; the source's
+        // uncommitted changes stay put (codehost forkWorktree defaults wip:false,
+        // and we don't opt in).
         let prov: {
           forkWorktree: (o: { fromCwd: string; branch: string; wsRoot?: string }) => Promise<{
             ok: boolean;
@@ -1800,7 +1887,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
           const child = Bun.spawn([shell, "-c", script, "ay-spawn", ...agentArgv], {
             cwd,
             detached: true,
-            env: { ...agentEnv, AGENT_YES_CWD: cwd, AGENT_YES_CLI: cli, AGENT_YES_AGENT_ID: agentId },
+            env: {
+              ...agentEnv,
+              AGENT_YES_CWD: cwd,
+              AGENT_YES_CLI: cli,
+              AGENT_YES_AGENT_ID: agentId,
+            },
             stdin: "ignore",
             stdout: "ignore",
             stderr: Bun.file(errPath),

package/ts/subcommands.spec.ts

@@ -43,6 +43,18 @@ describe("subcommands.controlCodeFromName", () => {
     expect(controlCodeFromName("")).toBe("");
   });
 
+  it("maps navigation keys to their ANSI sequences (for ay key / ay select)", async () => {
+    const { controlCodeFromName } = await loadModule();
+    expect(controlCodeFromName("up")).toBe("\x1b[A");
+    expect(controlCodeFromName("down")).toBe("\x1b[B");
+    expect(controlCodeFromName("right")).toBe("\x1b[C");
+    expect(controlCodeFromName("left")).toBe("\x1b[D");
+    expect(controlCodeFromName("space")).toBe(" ");
+    expect(controlCodeFromName("backspace")).toBe("\x7f");
+    expect(controlCodeFromName("pageup")).toBe("\x1b[5~");
+    expect(controlCodeFromName("pagedown")).toBe("\x1b[6~");
+  });
+
   it("supports raw:0xNN escape", async () => {
     const { controlCodeFromName } = await loadModule();
     expect(controlCodeFromName("raw:0x03")).toBe("\x03");
@@ -51,7 +63,27 @@ describe("subcommands.controlCodeFromName", () => {
 
   it("throws on unknown code names", async () => {
     const { controlCodeFromName } = await loadModule();
-    expect(() => controlCodeFromName("nope")).toThrow(/unknown --code/);
+    expect(() => controlCodeFromName("nope")).toThrow(/unknown key\/code/);
+  });
+});
+
+describe("subcommands.menuSelectKeys (ay select cursor arithmetic)", () => {
+  it("sends Downs + Enter to reach an option below the cursor", async () => {
+    const { menuSelectKeys } = await loadModule();
+    expect(menuSelectKeys(1, 3)).toEqual(["down", "down", "enter"]);
+  });
+  it("sends Ups + Enter to reach an option above the cursor", async () => {
+    const { menuSelectKeys } = await loadModule();
+    expect(menuSelectKeys(3, 1)).toEqual(["up", "up", "enter"]);
+  });
+  it("sends only Enter when the cursor already sits on the target", async () => {
+    const { menuSelectKeys } = await loadModule();
+    expect(menuSelectKeys(2, 2)).toEqual(["enter"]);
+  });
+  it("encodes to the exact ANSI byte stream via controlCodeFromName", async () => {
+    const { menuSelectKeys, controlCodeFromName } = await loadModule();
+    const bytes = menuSelectKeys(2, 4).map((k) => controlCodeFromName(k));
+    expect(bytes.join("")).toBe("\x1b[B\x1b[B\r"); // down, down, enter
   });
 });