agent-yes 1.284.1 → 1.285.0

package/ts/cmdPs.ts

@@ -21,6 +21,7 @@ import yargs from "yargs";
 import { buildAgentForest, flattenForest } from "./agentTree.ts";
 import {
   humanBytes,
+  type ProcRow,
   sampleTrees,
   snapshotProcs,
   systemStats,
@@ -85,8 +86,62 @@ export interface PsRow {
   status: string;
   cwd: string;
   repo: string;
+  /** This agent's OWN cost, exclusive of any nested agent (see sampleTrees). */
   stats: TreeStats;
   self: boolean;
+  /** `├─ `/`└─ ` rails from the agent forest. Empty outside --tree. */
+  prefix?: string;
+  /** Depth in the agent forest; 0 for roots. */
+  depth?: number;
+  /**
+   * This agent's cost PLUS every descendant agent's. Set only in --tree mode,
+   * and only for rows that actually have descendants — a leaf's subtree IS its
+   * own row, so repeating the numbers would be noise.
+   */
+  subtree?: TreeStats | null;
+  /**
+   * The OS processes this agent owns (wrapper, the CLI itself, its shells and
+   * pty hosts). Populated in --tree so the agent's number can be read as a sum
+   * of things you can actually point at.
+   */
+  procRows?: ProcRow[];
+}
+
+/**
+ * Roll each row up with its descendants, using the forest `depth` column: a
+ * row's descendants are the following rows with a strictly greater depth, up to
+ * the next row at or above its own level.
+ *
+ * Needed because sampleTrees attributes DEEPEST-FIRST and exclusively — a
+ * parent's own numbers deliberately omit its subagents, so without this a
+ * fan-out parent looks cheap while its real cost sits in rows below it.
+ *
+ * Returns null for a row with no descendants.
+ */
+export function subtreeTotals(rows: Pick<PsRow, "depth" | "stats">[]): (TreeStats | null)[] {
+  return rows.map((r, i) => {
+    const depth = r.depth ?? 0;
+    // Guard the row's OWN stats the same way its descendants' are guarded
+    // below: the sampler can miss an agent that exited mid-window, and one
+    // absent entry must not take down the whole table.
+    const own = r.stats;
+    if (!own) return null;
+    let rss = own.rss;
+    let cpuPercent = own.cpuPercent;
+    let procs = own.procs;
+    let found = false;
+    for (let j = i + 1; j < rows.length; j++) {
+      const d = rows[j]?.depth ?? 0;
+      if (d <= depth) break; // left this row's subtree
+      const st = rows[j]?.stats;
+      if (!st) continue;
+      found = true;
+      rss += st.rss;
+      cpuPercent += st.cpuPercent;
+      procs += st.procs;
+    }
+    return found ? { pid: own.pid, rss, cpuPercent, procs } : null;
+  });
 }
 
 function pad(s: string, n: number): string {
@@ -96,15 +151,27 @@ function padStart(s: string, n: number): string {
   return s.length >= n ? s : " ".repeat(n - s.length) + s;
 }
 
-export function renderTable(rows: PsRow[], unattributed: TreeStats | null): string {
+export function renderTable(
+  rows: PsRow[],
+  unattributed: TreeStats | null,
+  opts: { tree?: boolean } = {},
+): string {
+  const tree = opts.tree === true;
   const cells = rows.map((r) => ({
-    pid: String(r.pid),
+    // In tree mode the rails live on the PID cell, so the hierarchy reads down
+    // the left edge exactly like `ay ls`.
+    pid: (tree ? (r.prefix ?? "") : "") + String(r.pid),
     cli: r.cli,
     status: r.status,
     cpu: r.stats.cpuPercent.toFixed(1),
     rss: humanBytes(r.stats.rss),
     procs: String(r.stats.procs),
     repo: r.repo,
+    cwd: shortenPath(r.cwd),
+    // Σ columns: this agent plus its descendants. Blank for leaves.
+    scpu: r.subtree ? r.subtree.cpuPercent.toFixed(1) : "",
+    srss: r.subtree ? humanBytes(r.subtree.rss) : "",
+    sprocs: r.subtree ? String(r.subtree.procs) : "",
     self: r.self,
   }));
   // The unmanaged row participates in the width pass — "unmanaged" is wider than
@@ -118,6 +185,10 @@ export function renderTable(rows: PsRow[], unattributed: TreeStats | null): stri
       rss: humanBytes(unattributed.rss),
       procs: String(unattributed.procs),
       repo: "-",
+      cwd: "-",
+      scpu: "",
+      srss: "",
+      sprocs: "",
       self: false,
     });
   }
@@ -129,6 +200,9 @@ export function renderTable(rows: PsRow[], unattributed: TreeStats | null): stri
     rss: Math.max(5, ...cells.map((c) => c.rss.length)),
     procs: Math.max(5, ...cells.map((c) => c.procs.length)),
     repo: Math.max(4, ...cells.map((c) => c.repo.length)),
+    scpu: Math.max(5, ...cells.map((c) => c.scpu.length)),
+    srss: Math.max(5, ...cells.map((c) => c.srss.length)),
+    sprocs: Math.max(6, ...cells.map((c) => c.sprocs.length)),
   };
   const line = (
     pid: string,
@@ -138,18 +212,63 @@ export function renderTable(rows: PsRow[], unattributed: TreeStats | null): stri
     rss: string,
     procs: string,
     repo: string,
+    cwd: string,
+    scpu = "",
+    srss = "",
+    sprocs = "",
     tail = "",
   ) =>
     `${pad(pid, w.pid)}  ${pad(cli, w.cli)}  ${pad(status, w.status)}  ` +
     `${padStart(cpu, w.cpu)}  ${padStart(rss, w.rss)}  ${padStart(procs, w.procs)}  ` +
-    `${pad(repo, w.repo)}${tail}`;
+    // The Σ block only exists in tree mode, where a parent's own numbers exclude
+    // its subagents and are therefore misleading on their own.
+    (tree
+      ? `${padStart(scpu, w.scpu)}  ${padStart(srss, w.srss)}  ${padStart(sprocs, w.sprocs)}  `
+      : "") +
+    // REPO stays as the at-a-glance identity; CWD follows with the full path
+    // (home collapsed to ~) because sibling worktrees of one repo share a REPO
+    // label and are otherwise indistinguishable here. NOT width-padded: it is
+    // the last column, and paths run long enough (120 chars on a real fleet)
+    // that padding to the widest would trail ~100 blanks on every other row.
+    `${pad(repo, w.repo)}  ${cwd}${tail}`;
 
-  const out: string[] = [line("PID", "CLI", "STATUS", "CPU%", "RSS", "PROCS", "REPO")];
-  for (const c of cells) {
+  const out: string[] = [
+    line("PID", "CLI", "STATUS", "CPU%", "RSS", "PROCS", "REPO", "CWD", "ΣCPU%", "ΣRSS", "ΣPROCS"),
+  ];
+  cells.forEach((c, i) => {
     out.push(
-      line(c.pid, c.cli, c.status, c.cpu, c.rss, c.procs, c.repo, c.self ? "  ← this session" : ""),
+      line(
+        c.pid,
+        c.cli,
+        c.status,
+        c.cpu,
+        c.rss,
+        c.procs,
+        c.repo,
+        c.cwd,
+        c.scpu,
+        c.srss,
+        c.sprocs,
+        c.self ? "  ← this session" : "",
+      ),
     );
-  }
+    // The agent's own processes, one indent deeper than its rails. Rendered as
+    // a continuation of the row above rather than as table rows: they are a
+    // DIFFERENT kind of thing (an OS process, not an agent), and giving them
+    // the agent columns would invite reading a shell as a fifth agent.
+    const kids = rows[i]?.procRows;
+    if (!tree || !kids?.length) return;
+    const indent = " ".repeat((rows[i]?.prefix ?? "").length + 2);
+    const pw = Math.max(...kids.map((k) => String(k.pid).length));
+    const cw = Math.max(...kids.map((k) => k.comm.length));
+    for (const k of kids) {
+      out.push(
+        `${indent}· ${padStart(String(k.pid), pw)}  ${pad(k.comm, cw)}  ` +
+          `${padStart(k.cpuPercent.toFixed(1), 5)}  ${padStart(humanBytes(k.rss), 7)}` +
+          (k.state === "Z" ? "  zombie" : ""),
+      );
+    }
+  });
   return out.join("\n");
 }
 
@@ -176,7 +295,8 @@ export async function cmdPs(rest: string[]): Promise<number> {
     .option("tree", {
       type: "boolean",
       default: false,
-      description: "Keep ay ls's parent>child forest order instead of sorting",
+      description:
+        "Forest order with ├─ rails, plus Σ columns rolling each agent up with its subagents",
     })
     .option("interval", {
       type: "number",
@@ -187,6 +307,7 @@ export async function cmdPs(rest: string[]): Promise<number> {
     .option("help", { alias: "h", type: "boolean", default: false, description: "Show this help" })
     .example("ay ps", "biggest agents first, with box vitals")
     .example("ay ps --sort cpu", "who is actually burning CPU right now")
+    .example("ay ps --tree", "parent>child forest; Σ columns include each agent's subagents")
     .example("ay ps --json", "machine-readable rollup")
     .help(false)
     .version(false)
@@ -216,9 +337,10 @@ export async function cmdPs(rest: string[]): Promise<number> {
   // first-come, so sampling in that order would let a parent absorb a nested
   // agent's whole subtree and render the child as a bogus 0-proc row. Reverse to
   // claim deepest-first, then display in forest order.
-  const ordered = flattenForest(buildAgentForest(records)).map((r) => r.record);
+  const flat = flattenForest(buildAgentForest(records));
+  const ordered = flat.map((r) => r.record);
   const windowMs = Math.max(100, (Number.isFinite(argv.interval) ? argv.interval : 1) * 1000);
-  const { trees, unattributed } = await sampleTrees(
+  const { trees, unattributed, members } = await sampleTrees(
     [...ordered].reverse().map((r) => r.pid),
     { windowMs },
   );
@@ -227,7 +349,7 @@ export async function cmdPs(rest: string[]): Promise<number> {
     await Promise.all(ordered.map(async (r) => [r.pid, (await deriveLiveState(r)).state] as const)),
   );
   const selfPid = process.pid;
-  const rows: PsRow[] = ordered.map((r) => ({
+  const rows: PsRow[] = ordered.map((r, i) => ({
     pid: r.pid,
     cli: r.cli,
     status: states.get(r.pid) ?? r.status,
@@ -237,8 +359,22 @@ export async function cmdPs(rest: string[]): Promise<number> {
     // Mark the tree we are standing in — anything that later grows a kill
     // affordance must not let you shoot the session issuing the command.
     self: trees.get(r.pid) !== undefined && isSelfTree(r.pid, selfPid),
+    prefix: flat[i]?.prefix ?? "",
+    depth: flat[i]?.depth ?? 0,
   }));
 
+  // Only meaningful in forest order — sorting by rss would scatter descendants
+  // away from their parent and make a rollup describe the wrong span of rows.
+  if (argv.tree) {
+    const totals = subtreeTotals(rows);
+    rows.forEach((r, i) => {
+      r.subtree = totals[i] ?? null;
+      // Heaviest first: the reason to expand an agent is to find what inside it
+      // is costing something, and that is almost never the wrapper.
+      r.procRows = [...(members?.get(r.pid) ?? [])].sort((x, y) => y.rss - x.rss);
+    });
+  }
+
   if (!argv.tree) {
     const key = String(argv.sort);
     rows.sort((a, b) => {
@@ -281,7 +417,7 @@ export async function cmdPs(rest: string[]): Promise<number> {
 
   const header = formatSystemLine(sys);
   if (header) process.stdout.write(` ${header}\n\n`);
-  process.stdout.write(renderTable(rows, unattributed) + "\n");
+  process.stdout.write(renderTable(rows, unattributed, { tree: argv.tree === true }) + "\n");
   return 0;
 }
 

package/ts/procStats.spec.ts

@@ -53,6 +53,7 @@ describe("parseProcStat", () => {
     expect(s).toEqual({
       pid: 42,
       ppid: 7,
+      comm: "claude", // statLine's default
       rss: 10 * 4096,
       cpuSeconds: 2, // (150 + 50) ticks / 100 USER_HZ
       state: "S",
@@ -97,12 +98,37 @@ describe("parsePsTime", () => {
   });
 });
 
+describe("comm extraction", () => {
+  it("takes the comm from a stat line even when it holds spaces and parens", () => {
+    // The killer case: a comm containing ')' is why the field parse anchors on
+    // the LAST ')' — and the comm itself must span the FIRST '(' to that same
+    // anchor, or a name like "Web Content (1)" gets truncated.
+    const s = parseProcStat(9, statLine({ pid: 9, ppid: 1, comm: "Web Content (1)" }));
+    expect(s?.comm).toBe("Web Content (1)");
+    expect(s?.ppid).toBe(1); // fields after the comm still line up
+  });
+
+  it("keeps a plain comm intact", () => {
+    expect(parseProcStat(9, statLine({ pid: 9, ppid: 1, comm: "bash" }))?.comm).toBe("bash");
+  });
+});
+
 describe("parsePsTable", () => {
+  it("rejoins a comm that contains spaces, since it is the LAST column", () => {
+    const procs = parsePsTable("  10  1  2048  00:10 S /usr/bin/Google Chrome Helper\n");
+    expect(procs.get(10)?.comm).toBe("/usr/bin/Google Chrome Helper");
+    // The columns before it must be unaffected by those spaces.
+    expect(procs.get(10)?.rss).toBe(2048 * 1024);
+    expect(procs.get(10)?.state).toBe("S");
+  });
+
   it("normalizes ps KiB into bytes so both backends agree", () => {
     const procs = parsePsTable("  10  1  2048  00:10 S\n  11 10   512  00:00 Z\n");
     expect(procs.get(10)).toEqual({
       pid: 10,
       ppid: 1,
+      // This fixture predates the comm column; an absent one must read as "".
+      comm: "",
       rss: 2048 * 1024,
       cpuSeconds: 10,
       state: "S",
@@ -129,7 +155,7 @@ describe("descendantsOf", () => {
       ] as [number, number][]
     ).map(([pid, ppid]) => [
       pid,
-      { pid, ppid, rss: 0, cpuSeconds: 0, state: "S", startToken: `t${pid}` },
+      { pid, ppid, comm: "node", rss: 0, cpuSeconds: 0, state: "S", startToken: `t${pid}` },
     ]),
   );
   const kids = buildChildIndex(procs);
@@ -144,8 +170,8 @@ describe("descendantsOf", () => {
 
   it("terminates on a parent cycle instead of blowing the stack", () => {
     const cyclic = new Map<number, ProcSample>([
-      [1, { pid: 1, ppid: 2, rss: 0, cpuSeconds: 0, state: "S", startToken: "t1" }],
-      [2, { pid: 2, ppid: 1, rss: 0, cpuSeconds: 0, state: "S", startToken: "t2" }],
+      [1, { pid: 1, ppid: 2, comm: "node", rss: 0, cpuSeconds: 0, state: "S", startToken: "t1" }],
+      [2, { pid: 2, ppid: 1, comm: "node", rss: 0, cpuSeconds: 0, state: "S", startToken: "t2" }],
     ]);
     expect(descendantsOf(1, buildChildIndex(cyclic)).size).toBe(2);
   });
@@ -319,9 +345,9 @@ describe("parseMeminfo", () => {
 describe("systemStats", () => {
   it("reads load/mem and counts zombies from the snapshot", async () => {
     const procs = new Map<number, ProcSample>([
-      [1, { pid: 1, ppid: 0, rss: 0, cpuSeconds: 0, state: "S", startToken: "t1" }],
-      [2, { pid: 2, ppid: 1, rss: 0, cpuSeconds: 0, state: "Z", startToken: "t2" }],
-      [3, { pid: 3, ppid: 1, rss: 0, cpuSeconds: 0, state: "Z", startToken: "t3" }],
+      [1, { pid: 1, ppid: 0, comm: "node", rss: 0, cpuSeconds: 0, state: "S", startToken: "t1" }],
+      [2, { pid: 2, ppid: 1, comm: "node", rss: 0, cpuSeconds: 0, state: "Z", startToken: "t2" }],
+      [3, { pid: 3, ppid: 1, comm: "node", rss: 0, cpuSeconds: 0, state: "Z", startToken: "t3" }],
     ]);
     const sys = await systemStats(procs, {
       readSys: async (name) =>

package/ts/procStats.ts

@@ -34,6 +34,8 @@ const execFileAsync = promisify(execFile);
 export interface ProcSample {
   pid: number;
   ppid: number;
+  /** Executable name (`bash`, `node`). May be a full path from the ps fallback. */
+  comm: string;
   /** Resident set size in bytes. */
   rss: number;
   /** Cumulative CPU (user+sys) in seconds since process start. */
@@ -113,6 +115,10 @@ export function parseProcStat(
 ): ProcSample | null {
   const close = stat.lastIndexOf(")");
   if (close < 0) return null;
+  // comm is field 2, wrapped in parens and free to contain spaces AND parens —
+  // hence first '(' to LAST ')', the same anchor the field parse below uses.
+  const open = stat.indexOf("(");
+  const comm = open >= 0 && open < close ? stat.slice(open + 1, close) : "";
   const f = stat
     .slice(close + 1)
     .trim()
@@ -128,6 +134,7 @@ export function parseProcStat(
   return {
     pid,
     ppid,
+    comm,
     rss: Number.isFinite(rssPages) ? rssPages * pageSizeBytes : 0,
     cpuSeconds: (utime + stime) / USER_HZ,
     state,
@@ -144,7 +151,7 @@ export interface ProcReaders {
   readStat?: (pid: number) => Promise<string | null>;
   /** Whole-file read of /proc/loadavg, /proc/meminfo, … or null. */
   readSys?: (name: string) => Promise<string | null>;
-  /** `ps -eo pid=,ppid=,rss=,time=,state=` output, for the non-Linux fallback. */
+  /** `ps -eo pid=,ppid=,rss=,time=,state=,comm=` output, for the non-Linux fallback. */
   readPsTable?: () => Promise<string | null>;
 }
 
@@ -183,7 +190,7 @@ export async function defaultReadSys(name: string): Promise<string | null> {
 
 export async function defaultReadPsTable(): Promise<string | null> {
   try {
-    const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,rss=,time=,state="], {
+    const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,rss=,time=,state=,comm="], {
       encoding: "utf8",
       timeout: 3000,
       maxBuffer: 16 * 1024 * 1024,
@@ -208,13 +215,20 @@ export function parsePsTime(raw: string): number {
   return seconds;
 }
 
-/** Parse the `ps -eo pid=,ppid=,rss=,time=,state=` fallback table. */
+/**
+ * Parse the `ps -eo pid=,ppid=,rss=,time=,state=,comm=` fallback table.
+ *
+ * comm is requested LAST on purpose: it can contain spaces (`Google Chrome
+ * Helper`), so anywhere else it would shift every column after it. Being last,
+ * everything from field 6 on is simply rejoined.
+ */
 export function parsePsTable(out: string): Map<number, ProcSample> {
   const procs = new Map<number, ProcSample>();
   for (const line of out.split("\n")) {
     const m = line.trim().split(/\s+/);
     if (m.length < 5) continue;
     const [pidS, ppidS, rssS, timeS, state] = m;
+    const comm = m.slice(5).join(" ");
     const pid = Number(pidS);
     const ppid = Number(ppidS);
     const rssKib = Number(rssS);
@@ -222,6 +236,7 @@ export function parsePsTable(out: string): Map<number, ProcSample> {
     procs.set(pid, {
       pid,
       ppid,
+      comm,
       // ps reports RSS in KiB; /proc gives bytes. Normalize to bytes so both
       // backends feed identical numbers into the rollup.
       rss: Number.isFinite(rssKib) ? rssKib * 1024 : 0,
@@ -303,6 +318,52 @@ export interface TreeStats {
   procs: number;
 }
 
+/** One OS process inside an agent's tree, as rendered by `ay ps --tree`. */
+export interface ProcRow {
+  pid: number;
+  ppid: number;
+  /** Executable basename — the full path from `ps -o comm=` is noise in a table. */
+  comm: string;
+  rss: number;
+  /** Percent of ONE core over the sample window. */
+  cpuPercent: number;
+  state: string;
+}
+
+/**
+ * Per-process detail for one claimed member set, same window and pid-reuse
+ * rules as `rollup` (see there for why a newcomer or a reused pid contributes
+ * no CPU delta).
+ */
+function memberRows(
+  members: Set<number>,
+  first: Map<number, ProcSample>,
+  second: Map<number, ProcSample>,
+  elapsedSeconds: number,
+): ProcRow[] {
+  const out: ProcRow[] = [];
+  for (const pid of members) {
+    const now = second.get(pid);
+    if (!now) continue;
+    const before = first.get(pid);
+    const reused =
+      before !== undefined &&
+      before.startToken !== "" &&
+      now.startToken !== "" &&
+      before.startToken !== now.startToken;
+    const delta = before && !reused ? Math.max(0, now.cpuSeconds - before.cpuSeconds) : 0;
+    out.push({
+      pid,
+      ppid: now.ppid,
+      comm: (now.comm || "").split(/[\\/]+/).filter(Boolean).pop() ?? "",
+      rss: now.rss,
+      cpuPercent: elapsedSeconds > 0 ? (delta / elapsedSeconds) * 100 : 0,
+      state: now.state,
+    });
+  }
+  return out;
+}
+
 function rollup(
   root: number,
   members: Set<number>,
@@ -360,7 +421,12 @@ function rollup(
 export async function sampleTrees(
   roots: number[],
   opts: { windowMs?: number; deps?: ProcReaders } = {},
-): Promise<{ trees: Map<number, TreeStats>; unattributed: TreeStats }> {
+): Promise<{
+  trees: Map<number, TreeStats>;
+  unattributed: TreeStats;
+  /** root pid → the OS processes claimed by that root, for --tree. */
+  members: Map<number, ProcRow[]>;
+}> {
   const windowMs = Math.max(100, opts.windowMs ?? 1000);
   // Measure the ACTUAL elapsed time, not the requested window: a loaded box (the
   // exact case this command is for) can oversleep by hundreds of ms, and
@@ -385,10 +451,12 @@ export async function sampleTrees(
   const kids = buildChildIndex(second);
   const claimed = new Set<number>();
   const trees = new Map<number, TreeStats>();
+  const memberRowsByRoot = new Map<number, ProcRow[]>();
   for (const root of roots) {
     const members = descendantsOf(root, kids, claimed);
     for (const pid of members) claimed.add(pid);
     trees.set(root, rollup(root, members, first, second, elapsedSeconds));
+    memberRowsByRoot.set(root, memberRows(members, first, second, elapsedSeconds));
   }
 
   // Everything ay does NOT manage, as one row. This is the answer to "is there
@@ -396,7 +464,11 @@ export async function sampleTrees(
   // box from one quietly hoarding orphans.
   const rest = new Set<number>();
   for (const pid of second.keys()) if (!claimed.has(pid)) rest.add(pid);
-  return { trees, unattributed: rollup(0, rest, first, second, elapsedSeconds) };
+  return {
+    trees,
+    unattributed: rollup(0, rest, first, second, elapsedSeconds),
+    members: memberRowsByRoot,
+  };
 }
 
 /** Whole-box vitals for the header line. */

package/dist/trayApp-D5SzLS6p.js

@@ -1,5 +0,0 @@
-import "./versionChecker-D59qJF9N.js";
-import "./rustBinary-C9B5hRAU.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-Dylg_sbJ.js";
-
-export { cmdTray };