agent-yes 1.288.0 → 1.289.0

package/default.config.yaml

@@ -334,6 +334,112 @@ clis:
       - --search
     noEOL: true
 
+  # codex-ds — the `codex` binary pointed at DeepSeek V4 Pro over OpenRouter
+  # instead of the built-in OpenAI models. Everything the provider needs rides
+  # in `defaultArgs` as `-c` overrides, so this works against a stock codex
+  # install with no `~/.codex/*.config.toml` of your own; the only external
+  # requirement is `OPENROUTER_API_KEY` in the environment (same shape as glm's
+  # ZAI_API_KEY). Get one at https://openrouter.ai/keys.
+  #
+  # Two codex-version constraints are baked into the override:
+  #   - `wire_api` must be "responses"; codex >= 0.147 removed the "chat"
+  #     wire protocol, and OpenRouter serves POST /api/v1/responses.
+  #   - the provider table is passed inline rather than as a named profile,
+  #     because codex >= 0.147 rejects a `[profiles.X]` table in config.toml
+  #     and wants it in a separate `<X>.config.toml`.
+  #
+  # All drive markers below are copied from the `codex` block — same binary,
+  # same TUI — because per-CLI config does not inherit.
+  codex-ds:
+    binary: codex
+    promptArg: first-arg
+    defaultArgs:
+      - -c
+      - model_providers.openrouter={name="OpenRouter",base_url="https://openrouter.ai/api/v1",env_key="OPENROUTER_API_KEY",wire_api="responses"}
+      - -c
+      - model_provider="openrouter"
+      - -c
+      - model="deepseek/deepseek-v4-pro-0813"
+      - --search
+    yesArgs:
+      - --dangerously-bypass-approvals-and-sandbox
+    install:
+      npm: "npm install -g @openai/codex@latest"
+    help: https://openrouter.ai/deepseek/deepseek-v4-pro
+    updateAvailable:
+      - "^✨⬆️ Update available!"
+    ready:
+      - ⏎ send
+      - "› "
+      - '\? for shortcuts'
+    working:
+      - esc to interrupt
+    needsInput:
+      - pattern: '[›>] ?\d+\.'
+        flags: m
+    enter:
+      - pattern: '[›>] ?1\. ?Yes'
+        flags: m
+      - pattern: '[›>] ?1\. ?Approve'
+        flags: m
+      - pattern: '[›>] ?1\. ?Allow'
+        flags: m
+    fatal:
+      - "Error: The cursor position could not be read within"
+    noEOL: true
+
+
+  # codex-ds-direct — same idea as codex-ds, but pointed straight at DeepSeek's
+  # own endpoint instead of going through OpenRouter. DeepSeek gained native
+  # Responses API support in the 2026-08-13 V4 Pro update
+  # (https://api-docs.deepseek.com/guides/responses_api/), so no translating
+  # proxy is needed on this path either — one less hop and no reseller margin.
+  # Requires `DEEPSEEK_API_KEY`; get one at https://platform.deepseek.com.
+  #
+  # Model id differs from the OpenRouter route: DeepSeek's own /models lists
+  # exactly `deepseek-v4-flash` and `deepseek-v4-pro` — there are no dated
+  # snapshot ids here, so this uses the plain `deepseek-v4-pro`.
+  #
+  # Drive markers are copied from the `codex` block, as with codex-ds.
+  codex-ds-direct:
+    binary: codex
+    promptArg: first-arg
+    defaultArgs:
+      - -c
+      - model_providers.deepseek={name="DeepSeek",base_url="https://api.deepseek.com",env_key="DEEPSEEK_API_KEY",wire_api="responses"}
+      - -c
+      - model_provider="deepseek"
+      - -c
+      - model="deepseek-v4-pro"
+      - --search
+    yesArgs:
+      - --dangerously-bypass-approvals-and-sandbox
+    install:
+      npm: "npm install -g @openai/codex@latest"
+    help: https://api-docs.deepseek.com/guides/responses_api/
+    updateAvailable:
+      - "^✨⬆️ Update available!"
+    ready:
+      - ⏎ send
+      - "› "
+      - '\? for shortcuts'
+    working:
+      - esc to interrupt
+    needsInput:
+      - pattern: '[›>] ?\d+\.'
+        flags: m
+    enter:
+      - pattern: '[›>] ?1\. ?Yes'
+        flags: m
+      - pattern: '[›>] ?1\. ?Approve'
+        flags: m
+      - pattern: '[›>] ?1\. ?Allow'
+        flags: m
+    fatal:
+      - "Error: The cursor position could not be read within"
+    noEOL: true
+
+
   qwen:
     install:
       npm: "npm install -g @qwen-code/qwen-code@latest"

package/dist/{SUPPORTED_CLIS-BHowMgMY.js → SUPPORTED_CLIS-BlgVWZrM.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-DJLp2_bv.js";
+import { t as CLIS_CONFIG } from "./ts-CSp4mJ7Z.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-BHowMgMY.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-BlgVWZrM.js.map

package/dist/{SUPPORTED_CLIS-ChhJyq4h.js → SUPPORTED_CLIS-C65PuIs6.js}

@@ -1,12 +1,12 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CkO7wYyV.js";
-import "./ts-DJLp2_bv.js";
+import "./versionChecker-CWCN4vwm.js";
+import "./ts-CSp4mJ7Z.js";
 import "./todoAutomation-CbVVS4re.js";
 import "./JsonlStore-BqF7AQ6E.js";
 import "./globalPidIndex-DoaKEUkO.js";
 import "./pidStore-B73xnAeT.js";
 import "./messageLog-DdjBNqgt.js";
 import "./todoStore-DF6vxHgV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BHowMgMY.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BlgVWZrM.js";
 
 export { SUPPORTED_CLIS };

package/dist/{agentShare-T3RskvDT.js → agentShare-Cm15-dfZ.js}

@@ -3,10 +3,10 @@ import "./globalPidIndex-DoaKEUkO.js";
 import "./messageLog-DdjBNqgt.js";
 import "./e2e-z1xpwSAg.js";
 import "./configShared-DKTgiz7K.js";
-import { z as resolveOne } from "./subcommands-BfiOyfz7.js";
+import { z as resolveOne } from "./subcommands-CWDqhKQe.js";
 import "./notifyStore-2SWKGwZI.js";
 import "./webrtcLink-DLaJfTcB.js";
-import "./remotes-b6reVXzo.js";
+import "./remotes-BjsglpjL.js";
 import { a as startShare } from "./share-DTlaFn6s.js";
 
 //#region ts/agentShare.ts
@@ -230,4 +230,4 @@ function transformEvent(rawEvent, agentId, forwarded) {
 
 //#endregion
 export { createScopedShare, listShares, revokeAllShares, revokeShare };
-//# sourceMappingURL=agentShare-T3RskvDT.js.map
+//# sourceMappingURL=agentShare-Cm15-dfZ.js.map

package/dist/{callback-CuohbCJA.js → callback-Bbplrsbv.js}

@@ -1,5 +1,5 @@
 import { t as agentYesHome } from "./agentYesHome-BNtn19J4.js";
-import { z as resolveOne } from "./subcommands-BfiOyfz7.js";
+import { z as resolveOne } from "./subcommands-CWDqhKQe.js";
 import { a as mintCapability, o as parseExpires } from "./callbackCore-Bl2gGcxg.js";
 import { randomBytes } from "node:crypto";
 import { chmodSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -72,7 +72,7 @@ async function resolveBase(flag) {
 	if (flag) return flag;
 	if (process.env.AGENT_YES_CALLBACK_BASE) return process.env.AGENT_YES_CALLBACK_BASE;
 	try {
-		const { resolveLocalServeUrl } = await import("./serve-DaDlOtss.js");
+		const { resolveLocalServeUrl } = await import("./serve-CMsvjqPU.js");
 		const url = await resolveLocalServeUrl();
 		if (url) return url;
 	} catch {}
@@ -187,4 +187,4 @@ async function cmdCallback(rest) {
 
 //#endregion
 export { loadOrCreateCallbackSecret as i, isCallbackRevoked as n, loadCallbackSecretReadOnly as r, cmdCallback as t };
-//# sourceMappingURL=callback-CuohbCJA.js.map
+//# sourceMappingURL=callback-Bbplrsbv.js.map

package/dist/{callback-DeaETuHt.js → callback-Dwnkeqpz.js}

@@ -3,11 +3,11 @@ import "./globalPidIndex-DoaKEUkO.js";
 import "./messageLog-DdjBNqgt.js";
 import "./e2e-z1xpwSAg.js";
 import "./configShared-DKTgiz7K.js";
-import "./subcommands-BfiOyfz7.js";
+import "./subcommands-CWDqhKQe.js";
 import "./notifyStore-2SWKGwZI.js";
 import "./webrtcLink-DLaJfTcB.js";
-import "./remotes-b6reVXzo.js";
+import "./remotes-BjsglpjL.js";
 import "./callbackCore-Bl2gGcxg.js";
-import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-CuohbCJA.js";
+import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-Bbplrsbv.js";
 
 export { cmdCallback };

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-zdFbz1ST.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { a as versionString, r as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-CkO7wYyV.js";
-import { l as getRustBinary } from "./rustBinary-BmXzqj5z.js";
+import { a as versionString, r as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-CWCN4vwm.js";
+import { l as getRustBinary } from "./rustBinary-B57oRftk.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
@@ -295,7 +295,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-DKTa3E6O.js");
+	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-CJBV06rg.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		await cmdHelp(managerCommands);
 		process.exit(0);
@@ -309,7 +309,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 		process.exit(code ?? 0);
 	}
 	{
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-ChhJyq4h.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C65PuIs6.js");
 		if (isUnknownManagerToken(rawArg, managerCommands, SUPPORTED_CLIS)) {
 			process.stderr.write(`ay: unknown subcommand or CLI '${rawArg}'.\n    See 'ay help' for subcommands. To run an agent, name a CLI:\n    'ay <cli> …' (e.g. 'ay claude …') or 'ay --cli <cli> …'.\n`);
 			process.exit(1);
@@ -317,7 +317,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	}
 }
 {
-	const { detectCwdPassthrough, SUPPRESS_CWD_WARN_ENV } = await import("./cwdPassthroughHint-C0tfZlgZ.js");
+	const { detectCwdPassthrough, SUPPRESS_CWD_WARN_ENV } = await import("./cwdPassthroughHint-CDEGVteh.js");
 	const dep = detectCwdPassthrough(process.argv);
 	if (dep) {
 		console.warn(dep.message);
@@ -328,16 +328,16 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-BhPVpP_r.js");
+	const { startTray } = await import("./tray-CIt9mCKZ.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-BhPVpP_r.js");
+	const { ensureTray } = await import("./tray-CIt9mCKZ.js");
 	ensureTray();
 }
 if (!config.showVersion && !config.appendPrompt && !config.tray) {
-	const { waitForSpawnCapacity } = await import("./spawnGate-FLwTAPW6.js");
+	const { waitForSpawnCapacity } = await import("./spawnGate-C8MSRt7X.js");
 	await waitForSpawnCapacity({
 		onWait: (reason, waitedMs) => {
 			if (config.verbose || waitedMs === 0) console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
@@ -346,7 +346,7 @@ if (!config.showVersion && !config.appendPrompt && !config.tray) {
 	});
 }
 if (!config.showVersion && !config.appendPrompt && !config.tray) {
-	const { warnIfCwdOccupied } = await import("./cwdConflictWarn-DIPD6HH5.js");
+	const { warnIfCwdOccupied } = await import("./cwdConflictWarn-BgXN56Jc.js");
 	await warnIfCwdOccupied(process.argv);
 }
 if (config.useRust) {
@@ -360,14 +360,14 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-ChhJyq4h.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C65PuIs6.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
 			console.log(`[rust] Args: ${rustArgs.join(" ")}`);
 		}
 		const attach = config.attach || process.env.AGENT_YES_ATTACH === "1";
-		const { shouldForkNested, buildSpawnTutorial, waitForRegistration, confirmAgentStarted, predictedLogPath } = await import("./forkNested-Dt5XP8ZH.js");
+		const { shouldForkNested, buildSpawnTutorial, waitForRegistration, confirmAgentStarted, predictedLogPath } = await import("./forkNested-CJ7lQQCe.js");
 		if (shouldForkNested({
 			isTTY: Boolean(process.stdout.isTTY),
 			ayPid: process.env.AGENT_YES_PID,

package/dist/cmdPs-BYBZQ0Vc.js

@@ -0,0 +1,331 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-DoaKEUkO.js";
+import "./messageLog-DdjBNqgt.js";
+import "./e2e-z1xpwSAg.js";
+import "./configShared-DKTgiz7K.js";
+import { $ as buildAgentForest, D as listRecords, et as flattenForest, u as deriveLiveState } from "./subcommands-CWDqhKQe.js";
+import "./notifyStore-2SWKGwZI.js";
+import "./webrtcLink-DLaJfTcB.js";
+import "./remotes-BjsglpjL.js";
+import { i as systemStats, n as sampleTrees, r as snapshotProcs, t as humanBytes } from "./procStats-CyD8h5nx.js";
+import yargs from "yargs";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+
+//#region ts/cmdPs.ts
+/**
+* `ay ps` — what each agent COSTS, rolled up per process tree.
+*
+* The split from `ay ls`: `ls` answers "what is running and what is it doing"
+* (prompt, git, badges, forest); `ps` answers "what is this box spending on
+* each agent, and is any of it safe to reclaim". Same rows, different question.
+*
+* `ps` used to be a plain alias for `ls`. It is now its own command, because the
+* number you actually want is not in any `ps`/`htop` output: one agent is a
+* whole subtree of wrapper + CLI + pty hosts + subagents, and only ay knows
+* which pids collapse into which session.
+*
+* Deliberately local-only. Resource numbers are per-machine and there is nothing
+* meaningful to sum across remotes; `ay ls` remains the fleet-wide view.
+*/
+/** Default CPU sampling window. Long enough to be meaningful, short enough to feel instant. */
+const DEFAULT_WINDOW_MS = 1e3;
+function shortenPath(p) {
+	const home = homedir();
+	return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+/** Trailing path segment that identifies a worktree — `/code/x/foo/tree/main` → `foo`. */
+function repoLabel(cwd) {
+	const parts = cwd.split(/[\\/]+/).filter(Boolean);
+	const treeAt = parts.lastIndexOf("tree");
+	if (treeAt > 0) return parts[treeAt - 1];
+	return parts[parts.length - 1] ?? shortenPath(cwd);
+}
+/** `15.23 12.52 9.86 (8 cpu, 1.9x)  mem 13.0/15Gi  swap 4.8/4.8Gi FULL  zombies 1440` */
+function formatSystemLine(sys) {
+	const bits = [];
+	if (sys.load) {
+		const [one, five, fifteen] = sys.load;
+		const ratio = one / Math.max(1, sys.ncpu);
+		bits.push(`load ${one.toFixed(2)} ${five.toFixed(2)} ${fifteen.toFixed(2)} (${sys.ncpu} cpu, ${ratio.toFixed(1)}x)`);
+	}
+	if (sys.memTotalBytes !== null) {
+		const used = sys.memAvailableBytes !== null ? sys.memTotalBytes - sys.memAvailableBytes : null;
+		bits.push(`mem ${humanBytes(used)}/${humanBytes(sys.memTotalBytes)}`);
+	}
+	if (sys.swapTotalBytes !== null && sys.swapTotalBytes > 0) {
+		const usedSwap = sys.swapFreeBytes !== null ? sys.swapTotalBytes - sys.swapFreeBytes : null;
+		const full = sys.swapFreeBytes !== null && sys.swapFreeBytes <= 0 ? " FULL" : "";
+		bits.push(`swap ${humanBytes(usedSwap)}/${humanBytes(sys.swapTotalBytes)}${full}`);
+	}
+	if (sys.zombies > 0) bits.push(`zombies ${sys.zombies}`);
+	return bits.join("   ");
+}
+/**
+* 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.
+*/
+function subtreeTotals(rows) {
+	return rows.map((r, i) => {
+		const depth = r.depth ?? 0;
+		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++) {
+			if ((rows[j]?.depth ?? 0) <= depth) break;
+			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, n) {
+	return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function padStart(s, n) {
+	return s.length >= n ? s : " ".repeat(n - s.length) + s;
+}
+function renderTable(rows, unattributed, opts = {}) {
+	const tree = opts.tree === true;
+	const showProcs = opts.procs === true;
+	const cells = rows.map((r) => ({
+		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),
+		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
+	}));
+	if (unattributed && unattributed.procs > 0) cells.push({
+		pid: "-",
+		cli: "unmanaged",
+		status: "-",
+		cpu: unattributed.cpuPercent.toFixed(1),
+		rss: humanBytes(unattributed.rss),
+		procs: String(unattributed.procs),
+		repo: "-",
+		cwd: "-",
+		scpu: "",
+		srss: "",
+		sprocs: "",
+		self: false
+	});
+	const w = {
+		pid: Math.max(3, ...cells.map((c) => c.pid.length)),
+		cli: Math.max(3, ...cells.map((c) => c.cli.length)),
+		status: Math.max(6, ...cells.map((c) => c.status.length)),
+		cpu: Math.max(5, ...cells.map((c) => c.cpu.length)),
+		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, cli, status, cpu, rss, procs, repo, cwd, 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)}  ` + (tree ? `${padStart(scpu, w.scpu)}  ${padStart(srss, w.srss)}  ${padStart(sprocs, w.sprocs)}  ` : "") + `${pad(repo, w.repo)}  ${cwd}${tail}`;
+	const out = [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.cwd, c.scpu, c.srss, c.sprocs, c.self ? "  ← this session" : ""));
+		const kids = rows[i]?.procRows;
+		if (!showProcs || !kids?.length) return;
+		const indent = " ".repeat((tree ? (rows[i]?.prefix ?? "").length : 0) + 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");
+}
+async function cmdPs(rest) {
+	const y = yargs(rest).usage("Usage: ay ps [keyword] [options]\n\nPer-agent resource usage, rolled up across each agent's whole process tree\n(wrapper + CLI + pty hosts + subagents). Local-only; use `ay ls` for the\nfleet view and per-agent prompts.").option("all", {
+		type: "boolean",
+		default: false,
+		description: "Include exited agents"
+	}).option("json", {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON"
+	}).option("sort", {
+		type: "string",
+		choices: [
+			"rss",
+			"cpu",
+			"procs",
+			"pid"
+		],
+		default: "rss",
+		description: "Sort rows by resource usage (default: rss, biggest first)"
+	}).option("tree", {
+		type: "boolean",
+		default: false,
+		description: "Forest order with ├─ rails, plus Σ columns rolling each agent up with its subagents"
+	}).option("procs", {
+		type: "boolean",
+		default: false,
+		description: "Expand each agent into the OS processes it owns (wrapper, CLI, shells)"
+	}).option("interval", {
+		type: "number",
+		default: DEFAULT_WINDOW_MS / 1e3,
+		description: "CPU sampling window in seconds — CPU% is a live delta, not a lifetime average"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents whose cwd starts with dir"
+	}).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 --procs", "expand each agent into its wrapper/CLI/shell processes").example("ay ps --json", "machine-readable rollup").help(false).version(false).exitProcess(false);
+	const argv = await y.parseAsync();
+	if (argv.help || argv.h) {
+		process.stdout.write(await y.getHelp() + "\n");
+		return 0;
+	}
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	const records = await listRecords(keyword, {
+		all: argv.all,
+		active: false,
+		json: false,
+		latest: false,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	});
+	if (records.length === 0) {
+		process.stderr.write(keyword ? `no agents matched "${keyword}"\n` : "no running agents\n");
+		return 0;
+	}
+	const flat = flattenForest(buildAgentForest(records));
+	const ordered = flat.map((r) => r.record);
+	const windowMs = Math.max(100, (Number.isFinite(argv.interval) ? argv.interval : 1) * 1e3);
+	const { trees, unattributed, members } = await sampleTrees([...ordered].reverse().map((r) => r.pid), { windowMs });
+	const states = new Map(await Promise.all(ordered.map(async (r) => [r.pid, (await deriveLiveState(r)).state])));
+	const selfPid = process.pid;
+	const rows = ordered.map((r, i) => ({
+		pid: r.pid,
+		cli: r.cli,
+		status: states.get(r.pid) ?? r.status,
+		cwd: r.cwd,
+		repo: repoLabel(r.cwd),
+		stats: trees.get(r.pid) ?? {
+			pid: r.pid,
+			rss: 0,
+			cpuPercent: 0,
+			procs: 0
+		},
+		self: trees.get(r.pid) !== void 0 && isSelfTree(r.pid, selfPid),
+		prefix: flat[i]?.prefix ?? "",
+		depth: flat[i]?.depth ?? 0
+	}));
+	if (argv.tree) {
+		const totals = subtreeTotals(rows);
+		rows.forEach((r, i) => {
+			r.subtree = totals[i] ?? null;
+		});
+	}
+	if (argv.procs) for (const r of rows) 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) => {
+			if (key === "cpu") return b.stats.cpuPercent - a.stats.cpuPercent;
+			if (key === "procs") return b.stats.procs - a.stats.procs;
+			if (key === "pid") return a.pid - b.pid;
+			return b.stats.rss - a.stats.rss;
+		});
+	}
+	const sys = await systemStats(await snapshotProcs());
+	if (argv.json) {
+		process.stdout.write(JSON.stringify({
+			system: sys,
+			agents: rows.map((r) => ({
+				pid: r.pid,
+				cli: r.cli,
+				status: r.status,
+				cwd: r.cwd,
+				rssBytes: r.stats.rss,
+				cpuPercent: Number(r.stats.cpuPercent.toFixed(2)),
+				procs: r.stats.procs,
+				self: r.self
+			})),
+			unattributed: {
+				rssBytes: unattributed.rss,
+				cpuPercent: Number(unattributed.cpuPercent.toFixed(2)),
+				procs: unattributed.procs
+			}
+		}, null, 2) + "\n");
+		return 0;
+	}
+	const header = formatSystemLine(sys);
+	if (header) process.stdout.write(` ${header}\n\n`);
+	process.stdout.write(renderTable(rows, unattributed, {
+		tree: argv.tree === true,
+		procs: argv.procs === true
+	}) + "\n");
+	return 0;
+}
+/**
+* Is `rootPid` the wrapper of the tree this very process lives in?
+*
+* Walks our own ancestry rather than the snapshot: cheap, and correct even when
+* the snapshot raced. Linux-only detail (reads /proc), returns false elsewhere —
+* mislabelling the self row is cosmetic.
+*/
+function isSelfTree(rootPid, selfPid, readPpid = readPpidSync, platform = process.platform) {
+	if (platform !== "linux") return false;
+	let pid = selfPid;
+	for (let hops = 0; hops < 64 && pid > 1; hops++) {
+		if (pid === rootPid) return true;
+		const ppid = readPpid(pid);
+		if (ppid === null) return false;
+		pid = ppid;
+	}
+	return false;
+}
+/**
+* ppid out of one `/proc/<pid>/stat` line.
+*
+* Split from the read so the parsing — the part that can actually be wrong — is
+* testable on hosts without /proc. Field 2 is `comm`, wrapped in parens and NOT
+* escaped: a process named `foo) bar (baz` is legal, so the fields after it can
+* only be found from the LAST `)`, never by splitting on whitespace.
+*/
+function parsePpidFromStat(stat) {
+	const close = stat.lastIndexOf(")");
+	if (close < 0) return null;
+	const ppid = Number(stat.slice(close + 1).trim().split(/\s+/)[1]);
+	return Number.isFinite(ppid) ? ppid : null;
+}
+function readPpidSync(pid) {
+	try {
+		return parsePpidFromStat(readFileSync(`/proc/${pid}/stat`, "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { cmdPs };
+//# sourceMappingURL=cmdPs-BYBZQ0Vc.js.map

package/dist/{cwdConflictWarn-DIPD6HH5.js → cwdConflictWarn-BgXN56Jc.js}

@@ -61,4 +61,4 @@ async function warnIfCwdOccupied(rawArgv) {
 
 //#endregion
 export { warnIfCwdOccupied };
-//# sourceMappingURL=cwdConflictWarn-DIPD6HH5.js.map
+//# sourceMappingURL=cwdConflictWarn-BgXN56Jc.js.map

package/dist/{cwdPassthroughHint-C0tfZlgZ.js → cwdPassthroughHint-CDEGVteh.js}

@@ -85,4 +85,4 @@ function detectCwdPassthrough(argv) {
 
 //#endregion
 export { SUPPRESS_CWD_WARN_ENV, detectCwdPassthrough };
-//# sourceMappingURL=cwdPassthroughHint-C0tfZlgZ.js.map
+//# sourceMappingURL=cwdPassthroughHint-CDEGVteh.js.map

package/dist/{expose-Ds9aUFsq.js → expose-BlddYYx9.js}

@@ -549,4 +549,4 @@ async function cmdExpose(args) {
 
 //#endregion
 export { cmdExpose, ensureExposure, listExposures, stopExposure };
-//# sourceMappingURL=expose-Ds9aUFsq.js.map
+//# sourceMappingURL=expose-BlddYYx9.js.map

package/dist/{forkNested-Dt5XP8ZH.js → forkNested-CJ7lQQCe.js}

@@ -141,4 +141,4 @@ async function confirmAgentStarted(pid, graceMs = 1500, aborted) {
 
 //#endregion
 export { buildSpawnTutorial, confirmAgentStarted, predictedLogPath, shouldForkNested, waitForRegistration };
-//# sourceMappingURL=forkNested-Dt5XP8ZH.js.map
+//# sourceMappingURL=forkNested-CJ7lQQCe.js.map

package/dist/{hist-DSYaJEd3.js → hist-DZxq7NMA.js}

@@ -439,4 +439,4 @@ async function cmdHist(rest) {
 
 //#endregion
 export { cmdHist };
-//# sourceMappingURL=hist-DSYaJEd3.js.map
+//# sourceMappingURL=hist-DZxq7NMA.js.map

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CkO7wYyV.js";
-import { a as hasTodoStore, i as answerAsk, l as AgentContext, n as agentYes, o as listAsks, r as config, s as listAsksForProject, t as CLIS_CONFIG } from "./ts-DJLp2_bv.js";
+import "./versionChecker-CWCN4vwm.js";
+import { a as hasTodoStore, i as answerAsk, l as AgentContext, n as agentYes, o as listAsks, r as config, s as listAsksForProject, t as CLIS_CONFIG } from "./ts-CSp4mJ7Z.js";
 import { a as renderTree, c as describeBlock, i as renderDigest, l as monitorHint, o as unblockedTasks, r as openBlockers, t as reconcileTodos, u as removeControlCharacters } from "./todoAutomation-CbVVS4re.js";
 import "./JsonlStore-BqF7AQ6E.js";
 import "./globalPidIndex-DoaKEUkO.js";

package/dist/{initMsg-CeF4QNOM.js → initMsg-DoltWTZj.js}

@@ -1,3 +1,3 @@
-import { n as replyTargetOf, r as shortenHome, t as buildInitMsg } from "./initMsg-DejbYYjX.js";
+import { n as replyTargetOf, r as shortenHome, t as buildInitMsg } from "./initMsg-axyQAPLK.js";
 
 export { buildInitMsg };

package/dist/{initMsg-DejbYYjX.js → initMsg-axyQAPLK.js}

@@ -86,4 +86,4 @@ function buildInitMsg(prompt, spawner, nonce, identity) {
 
 //#endregion
 export { replyTargetOf as n, shortenHome as r, buildInitMsg as t };
-//# sourceMappingURL=initMsg-DejbYYjX.js.map
+//# sourceMappingURL=initMsg-axyQAPLK.js.map