agent-yes 1.266.0 → 1.267.0

package/dist/cmdPs-D7NlwNFV.js

@@ -0,0 +1,577 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import "./messageLog-BYFwioFY.js";
+import "./e2e-CUMZC53I.js";
+import "./configShared-DtHMBCl7.js";
+import { $ as buildAgentForest, O as listRecords, d as deriveLiveState, et as flattenForest } from "./subcommands-ujgVZRT3.js";
+import "./notifyStore-Cbw2ZJ0X.js";
+import "./webrtcLink-DyCj380i.js";
+import "./remotes-DdAfueOu.js";
+import yargs from "yargs";
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { readFile, readdir } from "node:fs/promises";
+import { promisify } from "node:util";
+
+//#region ts/procStats.ts
+/**
+* Per-process-TREE resource rollup, for `ay ps`.
+*
+* Why this exists: `ay ls` lists WRAPPER pids, but a single ay-managed agent is
+* a whole subtree — the wrapper, the CLI, its version process, `bg-pty-host`,
+* `bg-spare`, the daemon, plus whatever the agent itself spawned. On a busy box
+* one session can be 30+ processes. `ps`/`htop`/`glances` see those as
+* unrelated rows and cannot attribute them to an agent; only ay knows the
+* wrapper pids, so only ay can roll the cost up to "this session costs 612 MiB".
+*
+* Two things here are deliberately NOT the obvious approach:
+*
+* 1. CPU is a SAMPLED DELTA, never `ps`'s lifetime average. A session alive for
+*    7 days shows a meaningless smeared percentage; "is this agent busy right
+*    now" needs two reads of the cumulative counter a moment apart. That's why
+*    the caller must await a sampling window — see `sampleTrees`.
+*
+* 2. Rollup walks the FULL descendant closure, not direct children. Agents spawn
+*    subagents that spawn shells; a depth-1 sum undercounts badly.
+*
+* BEST-EFFORT by contract, like `procStartTime.ts`: every reader returns null /
+* empty when it cannot answer (no /proc, unreadable pid, a process that exited
+* mid-sample). Callers render "-" rather than failing — this is an inspection
+* command, it must never be the thing that breaks.
+*/
+const execFileAsync = promisify(execFile);
+/**
+* USER_HZ. The kernel reports utime/stime in clock ticks, and this is 100 on
+* every Linux ABI we run on — it is fixed at the syscall boundary, NOT the
+* configurable CONFIG_HZ. There is no cheap way to query it from Node.
+*/
+const USER_HZ = 100;
+/** Assumed page size when we cannot measure the real one. */
+const DEFAULT_PAGE_SIZE = 4096;
+/**
+* Real page size for the `rss` field of /proc/<pid>/stat, which is in PAGES.
+*
+* Hardcoding 4 KiB under-reports by 4× on a 16 KiB-page arm64 kernel, so measure
+* it instead — for free, with no `getconf` spawn: /proc/self/status reports our
+* own VmRSS in kB while /proc/self/stat reports the same figure in pages, and
+* the ratio is the page size. Snapped to the nearest supported power of two
+* because VmRSS is kB-rounded. Measured once per process, then cached.
+*/
+let cachedPageSize = null;
+function derivePageSize(statLine, statusText) {
+	const close = statLine.lastIndexOf(")");
+	if (close < 0) return DEFAULT_PAGE_SIZE;
+	const pages = Number(statLine.slice(close + 1).trim().split(/\s+/)[21]);
+	const kb = Number(/^VmRSS:\s+(\d+)/m.exec(statusText)?.[1]);
+	if (!Number.isFinite(pages) || !Number.isFinite(kb) || pages <= 0 || kb <= 0) return DEFAULT_PAGE_SIZE;
+	const raw = kb * 1024 / pages;
+	let best = DEFAULT_PAGE_SIZE;
+	for (const candidate of [
+		4096,
+		8192,
+		16384,
+		65536
+	]) if (Math.abs(raw - candidate) < Math.abs(raw - best)) best = candidate;
+	return best;
+}
+async function pageSize(deps) {
+	if (cachedPageSize !== null) return cachedPageSize;
+	const readSys = deps?.readSys ?? defaultReadSys;
+	const [stat, status] = await Promise.all([readSys("self/stat"), readSys("self/status")]);
+	cachedPageSize = stat && status ? derivePageSize(stat, status) : DEFAULT_PAGE_SIZE;
+	return cachedPageSize;
+}
+/**
+* Parse the fields of a /proc/<pid>/stat line that we need.
+*
+* As in `parseLinuxStartTime`, the parse MUST start after the last `)`: field 2
+* is the comm and may contain spaces and parens, so naive splitting mis-indexes
+* everything after it. Post-`)` fields begin at field 3, so field N is at index
+* N-3: state=3→0, ppid=4→1, utime=14→11, stime=15→12, starttime=22→19, rss=24→21.
+*/
+function parseProcStat(pid, stat, pageSizeBytes = DEFAULT_PAGE_SIZE) {
+	const close = stat.lastIndexOf(")");
+	if (close < 0) return null;
+	const f = stat.slice(close + 1).trim().split(/\s+/);
+	const state = f[0];
+	const ppid = Number(f[1]);
+	const utime = Number(f[11]);
+	const stime = Number(f[12]);
+	const rssPages = Number(f[21]);
+	if (!state || !Number.isFinite(ppid) || !Number.isFinite(utime) || !Number.isFinite(stime)) return null;
+	return {
+		pid,
+		ppid,
+		rss: Number.isFinite(rssPages) ? rssPages * pageSizeBytes : 0,
+		cpuSeconds: (utime + stime) / USER_HZ,
+		state,
+		startToken: f[19] ?? ""
+	};
+}
+async function defaultListPids() {
+	try {
+		const entries = await readdir("/proc");
+		const out = [];
+		for (const e of entries) if (/^\d+$/.test(e)) out.push(Number(e));
+		return out;
+	} catch {
+		return [];
+	}
+}
+async function defaultReadStat(pid) {
+	try {
+		return await readFile(`/proc/${pid}/stat`, "utf8");
+	} catch {
+		return null;
+	}
+}
+async function defaultReadSys(name) {
+	try {
+		return await readFile(`/proc/${name}`, "utf8");
+	} catch {
+		return null;
+	}
+}
+async function defaultReadPsTable() {
+	try {
+		const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,rss=,time=,state="], {
+			encoding: "utf8",
+			timeout: 3e3,
+			maxBuffer: 16 * 1024 * 1024
+		});
+		return stdout;
+	} catch {
+		return null;
+	}
+}
+/** Parse `[[dd-]hh:]mm:ss` (ps `time=`) into seconds. */
+function parsePsTime(raw) {
+	const [dayPart, clockPart] = raw.includes("-") ? raw.split("-", 2) : [null, raw];
+	const parts = (clockPart ?? "").split(":").map(Number);
+	if (parts.some((n) => !Number.isFinite(n))) return 0;
+	let seconds = 0;
+	for (const p of parts) seconds = seconds * 60 + p;
+	if (dayPart !== null) {
+		const days = Number(dayPart);
+		if (Number.isFinite(days)) seconds += days * 86400;
+	}
+	return seconds;
+}
+/** Parse the `ps -eo pid=,ppid=,rss=,time=,state=` fallback table. */
+function parsePsTable(out) {
+	const procs = /* @__PURE__ */ new Map();
+	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 pid = Number(pidS);
+		const ppid = Number(ppidS);
+		const rssKib = Number(rssS);
+		if (!Number.isFinite(pid) || !Number.isFinite(ppid)) continue;
+		procs.set(pid, {
+			pid,
+			ppid,
+			rss: Number.isFinite(rssKib) ? rssKib * 1024 : 0,
+			cpuSeconds: parsePsTime(timeS ?? ""),
+			state: state ?? "?",
+			startToken: ""
+		});
+	}
+	return procs;
+}
+/** One snapshot of every visible process, keyed by pid. */
+async function snapshotProcs(deps) {
+	if ((deps?.platform ?? process.platform) !== "linux" && !deps?.listPids) {
+		const table = await (deps?.readPsTable ?? defaultReadPsTable)();
+		return table ? parsePsTable(table) : /* @__PURE__ */ new Map();
+	}
+	const pids = await (deps?.listPids ?? defaultListPids)();
+	const readStat = deps?.readStat ?? defaultReadStat;
+	const bytesPerPage = await pageSize(deps);
+	const procs = /* @__PURE__ */ new Map();
+	const samples = await Promise.all(pids.map(async (pid) => {
+		const stat = await readStat(pid);
+		return stat ? parseProcStat(pid, stat, bytesPerPage) : null;
+	}));
+	for (const s of samples) if (s) procs.set(s.pid, s);
+	return procs;
+}
+/** ppid → children index, for descendant walks. */
+function buildChildIndex(procs) {
+	const kids = /* @__PURE__ */ new Map();
+	for (const p of procs.values()) {
+		const list = kids.get(p.ppid);
+		if (list) list.push(p.pid);
+		else kids.set(p.ppid, [p.pid]);
+	}
+	return kids;
+}
+/**
+* Every pid in the subtree rooted at `root`, inclusive.
+*
+* Iterative with a seen-set: a corrupt/racing snapshot can present a parent
+* cycle, and recursion would blow the stack rather than degrade.
+*/
+function descendantsOf(root, kids, seen = /* @__PURE__ */ new Set()) {
+	const out = /* @__PURE__ */ new Set();
+	const stack = [root];
+	while (stack.length > 0) {
+		const pid = stack.pop();
+		if (out.has(pid) || seen.has(pid)) continue;
+		out.add(pid);
+		for (const child of kids.get(pid) ?? []) stack.push(child);
+	}
+	return out;
+}
+function rollup(root, members, first, second, elapsedSeconds) {
+	let rss = 0;
+	let cpuDelta = 0;
+	let count = 0;
+	for (const pid of members) {
+		const now = second.get(pid);
+		if (!now) continue;
+		count++;
+		rss += now.rss;
+		const before = first.get(pid);
+		const reused = before !== void 0 && before.startToken !== "" && now.startToken !== "" && before.startToken !== now.startToken;
+		if (before && !reused) cpuDelta += Math.max(0, now.cpuSeconds - before.cpuSeconds);
+	}
+	return {
+		pid: root,
+		rss,
+		cpuPercent: elapsedSeconds > 0 ? cpuDelta / elapsedSeconds * 100 : 0,
+		procs: count
+	};
+}
+/**
+* Sample every root's subtree over a real time window.
+*
+* Roots are attributed in the order given, and a pid is claimed by the FIRST
+* root that reaches it — so a nested agent whose wrapper is itself listed as a
+* root is never double-counted into its parent's total.
+*
+* Pass DEEPEST-FIRST (children before parents). A nested agent must claim its
+* own subtree before its parent walks through it; parent-first instead makes the
+* parent absorb everything and renders the child as a bogus 0-proc row.
+*/
+async function sampleTrees(roots, opts = {}) {
+	const windowMs = Math.max(100, opts.windowMs ?? 1e3);
+	const firstStart = Date.now();
+	const first = await snapshotProcs(opts.deps);
+	const firstMid = (firstStart + Date.now()) / 2;
+	await new Promise((r) => setTimeout(r, windowMs));
+	const secondStart = Date.now();
+	const second = await snapshotProcs(opts.deps);
+	const secondMid = (secondStart + Date.now()) / 2;
+	const elapsedSeconds = Math.max(.001, (secondMid - firstMid) / 1e3);
+	const kids = buildChildIndex(second);
+	const claimed = /* @__PURE__ */ new Set();
+	const trees = /* @__PURE__ */ new Map();
+	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));
+	}
+	const rest = /* @__PURE__ */ new Set();
+	for (const pid of second.keys()) if (!claimed.has(pid)) rest.add(pid);
+	return {
+		trees,
+		unattributed: rollup(0, rest, first, second, elapsedSeconds)
+	};
+}
+/** Parse /proc/meminfo (`MemTotal:  16316360 kB`) into a kB-valued map. */
+function parseMeminfo(raw) {
+	const out = /* @__PURE__ */ new Map();
+	for (const line of raw.split("\n")) {
+		const m = /^(\w+):\s+(\d+)/.exec(line);
+		if (m?.[1] && m[2]) out.set(m[1], Number(m[2]) * 1024);
+	}
+	return out;
+}
+async function systemStats(procs, deps) {
+	const readSys = deps?.readSys ?? defaultReadSys;
+	const [loadRaw, memRaw] = await Promise.all([readSys("loadavg"), readSys("meminfo")]);
+	const loadFields = loadRaw?.trim().split(/\s+/) ?? [];
+	const load = loadFields.length >= 3 ? [
+		Number(loadFields[0]),
+		Number(loadFields[1]),
+		Number(loadFields[2])
+	] : null;
+	const mem = memRaw ? parseMeminfo(memRaw) : /* @__PURE__ */ new Map();
+	let zombies = 0;
+	for (const p of procs.values()) if (p.state === "Z") zombies++;
+	const os = await import("node:os");
+	const osLoad = os.loadavg();
+	const loadFallback = process.platform !== "win32" && osLoad.some((n) => n > 0) ? [
+		osLoad[0],
+		osLoad[1],
+		osLoad[2]
+	] : null;
+	return {
+		load: load && load.every(Number.isFinite) ? load : loadFallback,
+		ncpu: os.cpus().length || 1,
+		memTotalBytes: mem.get("MemTotal") ?? os.totalmem() ?? null,
+		memAvailableBytes: mem.get("MemAvailable") ?? os.freemem() ?? null,
+		swapTotalBytes: mem.get("SwapTotal") ?? null,
+		swapFreeBytes: mem.get("SwapFree") ?? null,
+		zombies
+	};
+}
+/** `612Mi`, `1.4Gi` — fixed-width-ish, no trailing noise. */
+function humanBytes(bytes) {
+	if (bytes === null || !Number.isFinite(bytes)) return "-";
+	for (const [scale, suffix] of [
+		[1024 ** 3, "Gi"],
+		[1024 ** 2, "Mi"],
+		[1024, "Ki"]
+	]) if (bytes >= scale) {
+		const v = bytes / scale;
+		return `${v >= 100 ? Math.round(v) : v.toFixed(1)}${suffix}`;
+	}
+	return `${Math.round(bytes)}B`;
+}
+
+//#endregion
+//#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("   ");
+}
+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) {
+	const cells = rows.map((r) => ({
+		pid: 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,
+		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: "-",
+		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))
+	};
+	const line = (pid, cli, status, cpu, rss, procs, repo, 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}`;
+	const out = [line("PID", "CLI", "STATUS", "CPU%", "RSS", "PROCS", "REPO")];
+	for (const c of cells) out.push(line(c.pid, c.cli, c.status, c.cpu, c.rss, c.procs, c.repo, c.self ? "  ← this session" : ""));
+	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: "Keep ay ls's parent>child forest order instead of sorting"
+	}).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 --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 ordered = flattenForest(buildAgentForest(records)).map((r) => r.record);
+	const windowMs = Math.max(100, (Number.isFinite(argv.interval) ? argv.interval : 1) * 1e3);
+	const { trees, unattributed } = 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) => ({
+		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)
+	}));
+	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) + "\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-D7NlwNFV.js.map

package/dist/{cwdConflictWarn-CtQhl-vF.js → cwdConflictWarn-BpweoAiy.js}

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

package/dist/{cwdPassthroughHint-apaX_O7p.js → cwdPassthroughHint-BlRuOGo_.js}

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

package/dist/{expose-BXn6My6A.js → expose-DyiZ5AU0.js}

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

package/dist/{forkNested-CDfWPiHw.js → forkNested-B_4c-TQk.js}

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

package/dist/{hist-BpocAe1N.js → hist-BoZPJ2ah.js}

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

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CJgW9DHY.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-CGtoPER5.js";
+import "./versionChecker-D49xkrMv.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-CQIqcW7_.js";
 import { _ as isKnownKind, a as renderTree, b as statesOf, c as monitorHint, d as openStore, f as DONE_STATE, g as initialState, h as canTransition, i as renderDigest, l as CycleError, m as ORPHANED_STATE, o as unblockedTasks, p as LIFECYCLES, r as openBlockers, s as describeBlock, t as reconcileTodos, u as TodoStore, v as nextStates, x as removeControlCharacters, y as requiredGate } from "./todoAutomation-BQRW614S.js";
 import "./JsonlStore-CPGIR0Wy.js";
 import "./globalPidIndex-Dq4KY2IV.js";

package/dist/{initMsg-C-w4A_eF.js → initMsg-BKqWDYFk.js}

@@ -82,4 +82,4 @@ function buildInitMsg(prompt, spawner, nonce) {
 
 //#endregion
 export { replyTargetOf as n, shortenHome as r, buildInitMsg as t };
-//# sourceMappingURL=initMsg-C-w4A_eF.js.map
+//# sourceMappingURL=initMsg-BKqWDYFk.js.map

package/dist/{initMsg-BjRseolL.js → initMsg-D8cmdY76.js}

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

package/dist/{nodeRuntime-CRoEMWkp.js → nodeRuntime-QihGFQbI.js}

@@ -53,4 +53,4 @@ async function ensureNodeRuntime(which = Bun.which) {
 
 //#endregion
 export { liveEnv as n, ensureNodeRuntime as t };
-//# sourceMappingURL=nodeRuntime-CRoEMWkp.js.map
+//# sourceMappingURL=nodeRuntime-QihGFQbI.js.map

package/dist/{notifyDaemon-BFzqcdN1.js → notifyDaemon-B-vCwFi3.js}

@@ -3,10 +3,10 @@ import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
 import "./e2e-CUMZC53I.js";
 import "./configShared-DtHMBCl7.js";
-import { L as renderLogTailLines, O as listRecords, d as deriveLiveState, x as isPidAlive } from "./subcommands-DtF31RoW.js";
+import { L as renderLogTailLines, O as listRecords, d as deriveLiveState, x as isPidAlive } from "./subcommands-ujgVZRT3.js";
 import { f as readInbox, g as daemonLockOwnerPath, h as daemonLockDir, i as gcInboxes, l as listInboxParents, m as shouldStealLock, n as appendEvent, s as hostId, u as liveWatchers, x as notifyDir } from "./notifyStore-Cbw2ZJ0X.js";
 import "./webrtcLink-DyCj380i.js";
-import "./remotes-iMhdZytp.js";
+import "./remotes-DdAfueOu.js";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
 import { randomUUID } from "node:crypto";
 import { execFile, execFileSync } from "node:child_process";
@@ -863,4 +863,4 @@ async function ensureDaemon() {
 
 //#endregion
 export { daemonStatus, ensureDaemon, requestDaemonStop, runDaemon };
-//# sourceMappingURL=notifyDaemon-BFzqcdN1.js.map
+//# sourceMappingURL=notifyDaemon-B-vCwFi3.js.map

package/dist/{openBrowser-DhQ9pJRi.js → openBrowser-Cs46NiH6.js}

@@ -68,4 +68,4 @@ async function offerOpenInBrowser(url, prompt = "Open in browser now? [Y/n] ") {
 
 //#endregion
 export { offerOpenInBrowser };
-//# sourceMappingURL=openBrowser-DhQ9pJRi.js.map
+//# sourceMappingURL=openBrowser-Cs46NiH6.js.map

package/dist/{parentLink-B798ASCW.js → parentLink-CQrn998L.js}

@@ -1,5 +1,5 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-Dq4KY2IV.js";
-import { n as spawnerFromRecords, t as resolveSpawner } from "./parentLink-C0cIRjfL.js";
+import { n as spawnerFromRecords, t as resolveSpawner } from "./parentLink-CTgZZCgw.js";
 
 export { resolveSpawner };

package/dist/{parentLink-C0cIRjfL.js → parentLink-CTgZZCgw.js}

@@ -50,4 +50,4 @@ function spawnerFromRecords(records, parentPid) {
 
 //#endregion
 export { spawnerFromRecords as n, resolveSpawner as t };
-//# sourceMappingURL=parentLink-C0cIRjfL.js.map
+//# sourceMappingURL=parentLink-CTgZZCgw.js.map