agent-yes 1.122.2 → 1.123.0

package/dist/subcommands-Tv6AwUkD.js

@@ -0,0 +1,7 @@
+import "./logger-B9h0djqx.js";
+import "./globalPidIndex-C7r2m6s7.js";
+import "./configShared-C5QaNPnz.js";
+import "./remotes-D8GvSbhf.js";
+import { _ as stopTipForCli, a as extractNeedsInput, c as isPidAlive, d as matchKeyword, f as readNotes, g as snapshotStatus, h as runSubcommand, i as cursorAbs, l as isSubcommand, m as resolveOne, n as cmdHelp, o as extractTaskCounts, p as renderRawLog, r as controlCodeFromName, s as finalizedLines, t as GRACEFUL_EXIT_COMMANDS, u as listRecords, v as writeToIpc } from "./subcommands-B13Kto-u.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-DjCIyakK.js → tray-BVnJLThD.js}

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

package/dist/{ts-CIf0uaR7.js → ts-DgukRoEI.js}

@@ -1,10 +1,10 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-DjxKi4qe.js";
+import { r as getInstalledPackage } from "./versionChecker-BqOr1YqC.js";
 import { t as agentYesHome } from "./agentYesHome-BvaUOzCV.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CJxsoGdb.js";
-import { t as PidStore } from "./pidStore-B5vBu8Px.js";
-import { i as readGlobalPids } from "./globalPidIndex-gZuTvTBs.js";
-import { n as sweep, t as register } from "./reaper-Dj8R7ltI.js";
+import { t as PidStore } from "./pidStore-CGKIhaJO.js";
+import { i as readGlobalPids } from "./globalPidIndex-C7r2m6s7.js";
+import { n as register, r as sweep } from "./reaper-BkjPN7mw.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -1060,7 +1060,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-z-IPzH5U.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-D6ycMApr.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1212,6 +1212,8 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 	} else logger.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
 	sweep().catch(() => {});
 	const ptyEnv = { ...env ?? process.env };
+	const inheritedAyPid = Number(ptyEnv.AGENT_YES_PID);
+	const parentPid = Number.isInteger(inheritedAyPid) && inheritedAyPid > 0 ? inheritedAyPid : void 0;
 	ptyEnv.AGENT_YES_PID = String(process.pid);
 	const ptyOptions = {
 		name: "xterm-color",
@@ -1241,7 +1243,8 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 			args: cliArgs,
 			prompt,
 			cwd: workingDir,
-			wrapperPid: process.pid
+			wrapperPid: process.pid,
+			parentPid
 		});
 	} catch (error) {
 		logger.warn(`[pidStore] Failed to register process ${shell.pid}:`, error);
@@ -1784,4 +1787,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-CIf0uaR7.js.map
+//# sourceMappingURL=ts-DgukRoEI.js.map

package/dist/{versionChecker-DjxKi4qe.js → versionChecker-BqOr1YqC.js}

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

package/dist/{workspaceConfig-XP2NEWmV.js → workspaceConfig-BJO4fzEn.js}

@@ -53,4 +53,4 @@ function resolveSpawnCwd(input) {
 
 //#endregion
 export { resolveSpawnCwd as n, setWorkspaceRoot as r, getWorkspaceRoot as t };
-//# sourceMappingURL=workspaceConfig-XP2NEWmV.js.map
+//# sourceMappingURL=workspaceConfig-BJO4fzEn.js.map

package/lab/ui/console-logic.js

@@ -14,9 +14,17 @@
 export const cliLabel = (e) => (e.cli && e.cli !== "claude" ? e.cli : "");
 
 // Parse owner/repo/branch from a cwd like .../ws/<owner>/<repo>/tree/<branch>.
+// A cwd inside a git submodule keeps trailing path after the worktree branch
+// (e.g. .../tree/share/lib/bot, where lib/bot is a submodule). The owner/repo/
+// branch still describe the superproject worktree — git itself resolves a
+// submodule cwd's identity to the superproject — so we surface the submodule's
+// leaf dir as `sub` to keep nested repos distinguishable. `sub` is "" when the
+// cwd is the worktree root.
 export function repoBranch(e) {
-  const m = /\/([^/]+)\/([^/]+)\/tree\/([^/]+)/.exec(e.cwd || "");
-  return m ? { owner: m[1], repo: m[2], branch: m[3] } : null;
+  const m = /\/([^/]+)\/([^/]+)\/tree\/([^/]+)(\/.*)?$/.exec(e.cwd || "");
+  if (!m) return null;
+  const sub = (m[4] || "").split("/").filter(Boolean).pop() || "";
+  return { owner: m[1], repo: m[2], branch: m[3], sub };
 }
 
 // Identity string for the left panel. cap=true → repo/branch each clipped to
@@ -25,7 +33,8 @@ export function ident(e, cap) {
   const rb = repoBranch(e);
   if (!rb) return "";
   const c = (s) => (cap && s.length > 3 ? s.slice(0, 3) : s);
-  return `${c(rb.repo)}/${c(rb.branch)}`;
+  const sub = rb.sub ? `→${rb.sub}` : "";
+  return `${c(rb.repo)}/${c(rb.branch)}${sub}`;
 }
 
 // ---- device-aware identity (multi-room) -----------------------------------
@@ -46,11 +55,18 @@ export function deviceParts(host) {
 // The five identity fields, in display order, for one agent.
 export function identFields(e) {
   const d = deviceParts(e._host);
-  const rb = repoBranch(e) || { owner: "", repo: "", branch: "" };
-  return { user: d.user, host: d.host, owner: rb.owner, repo: rb.repo, branch: rb.branch };
+  const rb = repoBranch(e) || { owner: "", repo: "", branch: "", sub: "" };
+  return {
+    user: d.user,
+    host: d.host,
+    owner: rb.owner,
+    repo: rb.repo,
+    branch: rb.branch,
+    sub: rb.sub,
+  };
 }
 
-const IDENT_ORDER = ["user", "host", "owner", "repo", "branch"];
+const IDENT_ORDER = ["user", "host", "owner", "repo", "branch", "sub"];
 
 // Precompute, over the whole shown list: which fields are uniform (identical for
 // every agent — so they can be omitted) and whether any device info exists at
@@ -69,11 +85,22 @@ export function identContext(entries) {
 // machine-parseable: e.g. all on one device → "@:age/mai", a mixed-device list →
 // "sno@tak:age/mai". A purely local list (no devices anywhere) falls back to the
 // legacy "own/rep/bra" with no device prefix.
-export function compactIdent(e, ctx, cap = 3) {
+//
+// `parent` is this row's tree parent entry (a subagent's superagent), when it
+// has one. A field that matches the parent's is ALSO blanked: the nesting
+// already conveys it, so a subagent in the same worktree as its parent shows
+// only what differs — often just the submodule leaf (e.g. "//→bot"), or nothing
+// at all (hidden by hasIdent) when it's the very same checkout.
+export function compactIdent(e, ctx, cap = 3, parent = null) {
   const m = identFields(e);
+  const p = parent ? identFields(parent) : null;
   const clip = (s) => (cap && s.length > cap ? s.slice(0, cap) : s);
-  const v = (f) => (ctx.uniform[f] ? "" : clip(m[f]));
-  const path = `${v("owner")}/${v("repo")}/${v("branch")}`;
+  const blank = (f) => ctx.uniform[f] || (p != null && p[f] === m[f]);
+  const v = (f) => (blank(f) ? "" : clip(m[f]));
+  // Submodule leaf is shown in full (the finest-grain distinguisher) and joined
+  // with → rather than / so it reads as "inside that worktree".
+  const sub = blank("sub") ? "" : m.sub;
+  const path = `${v("owner")}/${v("repo")}/${v("branch")}${sub ? `→${sub}` : ""}`;
   return ctx.anyDevice ? `${v("user")}@${v("host")}:${path}` : path;
 }
 
@@ -81,7 +108,8 @@ export function compactIdent(e, ctx, cap = 3) {
 // prefix only when this agent actually has device info.
 export function fullIdent(e) {
   const m = identFields(e);
-  const path = `${m.owner}/${m.repo}/${m.branch}`;
+  const sub = m.sub ? `→${m.sub}` : "";
+  const path = `${m.owner}/${m.repo}/${m.branch}${sub}`;
   return m.user || m.host ? `${m.user}@${m.host}:${path}` : path;
 }
 
@@ -108,6 +136,7 @@ export function tagsFor(e) {
   const rb = repoBranch(e);
   if (rb) {
     t.push(["repo", `${rb.owner}/${rb.repo}`], ["wt", rb.branch]);
+    if (rb.sub) t.push(["sub", rb.sub]); // submodule leaf, when cwd is nested
   }
   const cli = cliLabel(e);
   if (cli) t.push(["cli", cli]);
@@ -129,6 +158,15 @@ export function gitLabel(e) {
   return parts.join(" ");
 }
 
+// Task-progress badge ("2/5") from the agent's parsed todo block (e.tasks =
+// { done, total }, computed live in /api/ls). Empty string when no todo block was
+// confidently detected — the badge is omitted entirely, never shown as "0/0".
+export function taskLabel(e) {
+  const t = e.tasks;
+  if (!t || typeof t.total !== "number" || t.total <= 0) return "";
+  return `${t.done}/${t.total}`;
+}
+
 // Human age of an agent ("12s" / "5m" / "3h"). `now` is injectable so tests
 // don't depend on the wall clock; the browser calls age(e) and gets Date.now().
 export function age(e, now = Date.now()) {
@@ -175,6 +213,180 @@ export function matches(e, toks) {
   });
 }
 
+// Box-drawing rail prefix for a node given the "is-last-child?" flags of each
+// ancestor (root→node). depth 0 → "". Shared by the agent forest and the layered
+// room/peer tree so all rails line up: "│  ", "   " for ancestors, "├ "/"└ " here.
+function railPrefix(ancestorsLast) {
+  const depth = ancestorsLast.length;
+  let s = "";
+  for (let i = 0; i < depth - 1; i++) s += ancestorsLast[i] ? "   " : "│  ";
+  if (depth > 0) s += ancestorsLast[depth - 1] ? "└ " : "├ ";
+  return s;
+}
+
+// Stable ordered grouping: [[key, items[]], ...] in first-seen key order.
+function groupBy(arr, keyFn) {
+  const m = new Map();
+  for (const e of arr) {
+    const k = keyFn(e);
+    if (!m.has(k)) m.set(k, []);
+    m.get(k).push(e);
+  }
+  return [...m.entries()];
+}
+
+// Build the agent>subagent forest for ONE host's entries (pids are only unique
+// per machine, so the caller must pre-scope by host). Primary link is the explicit
+// spawn relationship (parent_pid === wrapper_pid). As a FALLBACK, an agent with no
+// such parent whose cwd sits INSIDE another agent's cwd of the SAME worktree
+// (owner/repo/branch) snaps under it — so a submodule/subdir agent nests under its
+// superproject agent even without a parent_pid link. Returns root nodes
+// { entry, children }; sibling/root order = input order. Cycles can't drop nodes:
+// anything not reached from a root is appended as its own root.
+function agentForestNodes(list) {
+  const byWrapper = new Map();
+  for (const e of list) if (e.wrapper_pid != null) byWrapper.set(e.wrapper_pid, e);
+  const nodeOf = new Map(list.map((e) => [e, { entry: e, children: [] }]));
+
+  const parentOf = new Map();
+  // 1) explicit spawn link.
+  for (const e of list) {
+    const p = e.parent_pid != null ? byWrapper.get(e.parent_pid) : null;
+    if (p && p !== e) parentOf.set(e, p);
+  }
+  // 2) cwd-containment fallback for the still-parentless. The closest ancestor
+  //    (longest containing cwd) wins; same-worktree guard keeps an unrelated
+  //    shared prefix (e.g. /Users/x/ws) from grouping strangers together.
+  for (const e of list) {
+    if (parentOf.has(e) || !e.cwd) continue;
+    const rb = repoBranch(e);
+    if (!rb) continue;
+    let best = null;
+    for (const c of list) {
+      if (c === e || !c.cwd || !e.cwd.startsWith(c.cwd + "/")) continue;
+      const crb = repoBranch(c);
+      if (!crb || crb.owner !== rb.owner || crb.repo !== rb.repo || crb.branch !== rb.branch)
+        continue;
+      if (!best || c.cwd.length > best.cwd.length) best = c;
+    }
+    if (best) parentOf.set(e, best);
+  }
+  // Attach, refusing any edge that would close a cycle (a pre-existing parent_pid
+  // cycle, or a pid/cwd mix) — such nodes stay roots.
+  const wouldCycle = (parent, child) => {
+    for (let cur = parent, i = 0; cur && i < list.length + 1; cur = parentOf.get(cur), i++)
+      if (cur === child) return true;
+    return false;
+  };
+  const roots = [];
+  for (const e of list) {
+    const p = parentOf.get(e);
+    if (p && p !== e && !wouldCycle(p, e)) nodeOf.get(p).children.push(nodeOf.get(e));
+    else roots.push(nodeOf.get(e));
+  }
+  // Cycle safety: collect nodes reachable from roots; append the rest as roots.
+  const seen = new Set();
+  const mark = (n) => {
+    if (seen.has(n)) return;
+    seen.add(n);
+    n.children.forEach(mark);
+  };
+  roots.forEach(mark);
+  for (const e of list) if (!seen.has(nodeOf.get(e))) roots.push(nodeOf.get(e));
+  return roots;
+}
+
+// Order entries as agent>subagent forests so a nested `ay` (one agent spawning
+// another) renders indented under its parent. SCOPED PER HOST. Returns a NEW
+// array in depth-first order; each entry is shallow-copied with `_branch` (a
+// box-drawing tree prefix like "│  └ ") and `_depth`. A fleet with no nesting
+// renders exactly as before (every row a root, empty `_branch`).
+export function forestOrder(entries) {
+  const out = [];
+  for (const [, list] of groupBy(entries, (e) => e._host || "")) {
+    const seen = new Set();
+    const walk = (node, ancestorsLast) => {
+      if (seen.has(node)) return; // break a pathological parent_pid cycle
+      seen.add(node);
+      out.push(
+        Object.assign({}, node.entry, {
+          _branch: railPrefix(ancestorsLast),
+          _depth: ancestorsLast.length,
+        }),
+      );
+      node.children.forEach((c, i) =>
+        walk(c, ancestorsLast.concat(i === node.children.length - 1)),
+      );
+    };
+    for (const r of agentForestNodes(list)) walk(r, []);
+  }
+  return out;
+}
+
+// Build the full console hierarchy — signalling-server > rooms > peers(hosts) >
+// agents > subagents — and flatten it into ordered render rows, VSCode-explorer
+// style: a container layer (room/peer) with a single node in its scope is HIDDEN
+// (its children float up a level); a layer with ≥2 siblings becomes a tree with
+// ├ └ │ rails. Agents always get their own row, with their subagent forest nested
+// beneath. The server layer is implicit (always one) so it never shows.
+//
+// Returns [{ kind:'room'|'peer'|'agent', label, entry, branch, depth }] in
+// display order. Headers (room/peer) are non-selectable; only 'agent' rows are.
+// A purely local fleet (one room, one unlabelled host) yields only agent rows —
+// identical to forestOrder — so the common case stays a plain agent tree.
+export function layeredRows(entries) {
+  const multiRoom = new Set(entries.map((e) => e._room || "")).size > 1;
+
+  // Container nodes carry a `kind`/`label` for headers; agent nodes carry an
+  // `entry`. A hidden layer simply isn't created — its agents/peers attach to the
+  // parent — which is what makes single-node layers vanish.
+  const roomNodes = [];
+  for (const [rid, re] of groupBy(entries, (e) => e._room || "")) {
+    const peerGroups = groupBy(re, (e) => e._host || "");
+    const multiPeer = peerGroups.length > 1;
+    const underRoom = [];
+    for (const [host, pe] of peerGroups) {
+      const agentNodes = agentForestNodes(pe).map(toAgentNode);
+      if (multiPeer && host)
+        underRoom.push({ kind: "peer", label: host, room: rid, host, children: agentNodes });
+      else underRoom.push(...agentNodes); // single/unlabelled peer hidden
+    }
+    if (multiRoom && rid) roomNodes.push({ kind: "room", label: rid, children: underRoom });
+    else roomNodes.push(...underRoom); // single room hidden
+  }
+
+  const rows = [];
+  const seen = new Set();
+  // parentAgent carries the nearest ancestor agent's entry down the walk so a
+  // subagent row knows its superagent — used to omit identity fields the tree
+  // nesting already conveys (see compactIdent). Room/peer headers are skipped.
+  const walk = (node, ancestorsLast, parentAgent) => {
+    if (seen.has(node)) return; // break a pathological parent_pid cycle
+    seen.add(node);
+    rows.push({
+      kind: node.kind,
+      label: node.label,
+      entry: node.entry,
+      room: node.room, // peer headers: (room,host) keys the connection-type cache
+      host: node.host,
+      parentEntry: node.kind === "agent" ? parentAgent : null,
+      branch: railPrefix(ancestorsLast),
+      depth: ancestorsLast.length,
+    });
+    const nextParent = node.kind === "agent" ? node.entry : parentAgent;
+    (node.children || []).forEach((c, i) =>
+      walk(c, ancestorsLast.concat(i === node.children.length - 1), nextParent),
+    );
+  };
+  for (const r of roomNodes) walk(r, [], null);
+  return rows;
+}
+
+// Wrap an agent forest node { entry, children } into a layered-tree node.
+function toAgentNode(n) {
+  return { kind: "agent", entry: n.entry, children: n.children.map(toAgentNode) };
+}
+
 // Next selection index when stepping the list by `dir` (+1 down / -1 up).
 // No current selection (i<0) lands on the first (down) or last (up) row;
 // otherwise clamps at the ends. Returns -1 for an empty list.

package/lab/ui/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" role="img" aria-label="agent-yes">
+  <rect width="512" height="512" rx="104" fill="#0d1117" />
+  <path d="M132 268 l78 80 l170-186" fill="none" stroke="#3fb950" stroke-width="56"
+        stroke-linecap="round" stroke-linejoin="round" />
+</svg>