claude-yes 1.165.0 → 1.166.0

package/dist/SUPPORTED_CLIS-ClQgRKQu.js

@@ -0,0 +1,8 @@
+import "./ts-CXxZiZKE.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-Dv5DhRs3.js";
+import "./pidStore-BfoBWUjc.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Xem8nliL.js";
+
+export { SUPPORTED_CLIS };

package/dist/{SUPPORTED_CLIS-H7IIw10E.js → SUPPORTED_CLIS-Xem8nliL.js}

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

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-C0UJyFcN.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-Dv5DhRs3.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -481,7 +481,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 } = await import("./subcommands-CIFWi9vq.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-BnsjTNpy.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp(managerCommands);
 		process.exit(0);
@@ -495,14 +495,23 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-BMzpUSfa.js");
+	const { startTray } = await import("./tray-CZarCA2Q.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-BMzpUSfa.js");
+	const { ensureTray } = await import("./tray-CZarCA2Q.js");
 	ensureTray();
 }
+if (!config.showVersion && !config.appendPrompt && !config.tray) {
+	const { waitForSpawnCapacity } = await import("./spawnGate-UH73I2le.js");
+	await waitForSpawnCapacity({
+		onWait: (reason, waitedMs) => {
+			if (config.verbose || waitedMs === 0) console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
+		},
+		onProceedAnyway: (reason, waitedMs) => console.error(`[agent-yes] spawn gate: ${reason} — waited ${Math.round(waitedMs / 1e3)}s, proceeding anyway`)
+	});
+}
 if (config.useRust) {
 	let rustBinary;
 	try {
@@ -514,7 +523,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-dBgLp3mi.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-ClQgRKQu.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-jDEwTsVt.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CXxZiZKE.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C0UJyFcN.js";
+import "./versionChecker-Dv5DhRs3.js";
 import "./pidStore-BfoBWUjc.js";
 import "./globalPidIndex-DlmmJlO8.js";
 

package/dist/{remotes-DkNuq417.js → remotes-ClT1bq16.js}

@@ -1,5 +1,5 @@
 import "./e2e-Bfw7qL9O.js";
 import "./webrtcLink-CBZkZ-LT.js";
-import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-DBCvpp3B.js";
+import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-T6nf0t3K.js";
 
 export { cmdRemote };

package/dist/{remotes-DBCvpp3B.js → remotes-T6nf0t3K.js}

@@ -86,7 +86,7 @@ async function resolveRemoteSpec(spec) {
 * The bridge lives for the rest of the process (torn down on `process.exit`).
 */
 async function resolveWebrtc(link, keyword) {
-	const { startWebrtcBridge } = await import("./webrtcRemote-Ccdzmuc-.js");
+	const { startWebrtcBridge } = await import("./webrtcRemote-GAgF5K45.js");
 	const bridge = await startWebrtcBridge(link);
 	return {
 		url: bridge.baseUrl,
@@ -173,4 +173,4 @@ async function cmdRemote(rest) {
 
 //#endregion
 export { resolveRemoteSpec as a, readRemotes as i, deleteRemoteAlias as n, writeRemoteAlias as o, parseDirectRemoteSpec as r, cmdRemote as t };
-//# sourceMappingURL=remotes-DBCvpp3B.js.map
+//# sourceMappingURL=remotes-T6nf0t3K.js.map

package/dist/{schedule-BobQwIBS.js → schedule-CwAX3y8s.js}

@@ -1,10 +1,10 @@
-import "./ts-jDEwTsVt.js";
+import "./ts-CXxZiZKE.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C0UJyFcN.js";
+import "./versionChecker-Dv5DhRs3.js";
 import "./pidStore-BfoBWUjc.js";
 import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-H7IIw10E.js";
-import { o as resolveSpawnCwd } from "./workspaceConfig-B0Q9-q2B.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Xem8nliL.js";
+import { l as resolveSpawnCwd } from "./workspaceConfig-D3OH7and.js";
 import { createHash } from "node:crypto";
 
 //#region ts/oxmgrService.ts
@@ -141,4 +141,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-BobQwIBS.js.map
+//# sourceMappingURL=schedule-CwAX3y8s.js.map

package/dist/{serve-DzOWMI_8.js → serve-DeJBMba0.js}

@@ -1,16 +1,17 @@
-import "./ts-jDEwTsVt.js";
+import "./ts-CXxZiZKE.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-C0UJyFcN.js";
+import { r as getInstalledPackage } from "./versionChecker-Dv5DhRs3.js";
 import "./pidStore-BfoBWUjc.js";
 import { a as updateGlobalPidStatus } from "./globalPidIndex-DlmmJlO8.js";
 import { t as pgidForWrapper } from "./reaper-C-eWAxIj.js";
 import "./configShared-CEyhl0WH.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-H7IIw10E.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Xem8nliL.js";
 import "./e2e-Bfw7qL9O.js";
 import "./webrtcLink-CBZkZ-LT.js";
-import "./remotes-DBCvpp3B.js";
-import { a as isProvisionAllowed, i as hasSpawnHook, n as getSpawnHook, o as resolveSpawnCwd, t as getProvisionRoot } from "./workspaceConfig-B0Q9-q2B.js";
-import { A as writeToIpc, D as snapshotStatus, S as resolveOne, b as renderRawLog, c as extractNeedsInput, h as listRecords, i as controlCodeFromName, l as extractTaskCounts, o as deriveLiveStatus, v as readNotes, y as readPtysize } from "./subcommands-DtwxPMYe.js";
+import "./remotes-T6nf0t3K.js";
+import { c as isProvisionAllowed, i as getSpawnHook, l as resolveSpawnCwd, r as getProvisionRoot, s as hasSpawnHook } from "./workspaceConfig-D3OH7and.js";
+import { A as writeToIpc, D as snapshotStatus, S as resolveOne, b as renderRawLog, c as extractNeedsInput, h as listRecords, i as controlCodeFromName, l as extractTaskCounts, o as deriveLiveStatus, v as readNotes, y as readPtysize } from "./subcommands-BY0mIDo9.js";
+import { r as spawnRejectionReason } from "./spawnGate-B_VDMXYL.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, stat, unlink, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -307,7 +308,7 @@ async function cmdServeDaemon(sub, args) {
 		let shareLink = null;
 		let shareLinkMinted = false;
 		if (webrtcDaemon) try {
-			const { loadOrCreateShareRoom, shareLinkFromRoomUrl } = await import("./share-Bq_tDXQU.js");
+			const { loadOrCreateShareRoom, shareLinkFromRoomUrl } = await import("./share-BjqQBWM-.js");
 			const explicit = explicitWebrtcUrl(effArgs);
 			shareLink = shareLinkFromRoomUrl(explicit ?? await loadOrCreateShareRoom());
 			shareLinkMinted = !explicit;
@@ -1169,6 +1170,8 @@ Options:
 			const cli = String(body.cli ?? "claude");
 			if (!SUPPORTED_CLIS.includes(cli)) return new Response(`unsupported cli: ${cli}`, { status: 400 });
 			const prompt = String(body.prompt ?? "");
+			const reject = await spawnRejectionReason();
+			if (reject) return new Response(reject, { status: 429 });
 			let cwd;
 			let provisioned = null;
 			const fork = body.fork && typeof body.fork.fromCwd === "string" && body.fork.fromCwd.trim() && typeof body.fork.branch === "string" && body.fork.branch.trim() ? {
@@ -1383,7 +1386,7 @@ Options:
 		const webrtcVal = argv.webrtc ?? argv.share;
 		const explicitUrl = typeof webrtcVal === "string" && webrtcVal.startsWith("webrtc://") ? webrtcVal : void 0;
 		try {
-			const { startShare, loadOrCreateShareRoom } = await import("./share-Bq_tDXQU.js");
+			const { startShare, loadOrCreateShareRoom } = await import("./share-BjqQBWM-.js");
 			const linkFile = path.join(process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes"), ".share-link");
 			const announce = async (room, link, rotated) => {
 				const lead = rotated ? "the room was rejected by signaling (stale generation) — rotated to a fresh link" : "shared over WebRTC — open this link (the token is eaten from the URL on open)";
@@ -1442,4 +1445,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-DzOWMI_8.js.map
+//# sourceMappingURL=serve-DeJBMba0.js.map

package/dist/{setup-tVfp7djj.js → setup-hWG3ZBG3.js}

@@ -1,4 +1,4 @@
-import { r as getWorkspaceRoot, s as setWorkspaceRoot } from "./workspaceConfig-B0Q9-q2B.js";
+import { o as getWorkspaceRoot, u as setWorkspaceRoot } from "./workspaceConfig-D3OH7and.js";
 import { existsSync } from "node:fs";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
@@ -32,7 +32,7 @@ async function cmdSetup(rest) {
 	if (!existsSync(abs)) process.stderr.write(`  note: that directory doesn't exist yet — create it, or agents spawned there will fail\n`);
 	if (noShare) return 0;
 	process.stdout.write(`\nsharing this machine to agent-yes.com…\n`);
-	const { cmdServe } = await import("./serve-DzOWMI_8.js");
+	const { cmdServe } = await import("./serve-DeJBMba0.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-tVfp7djj.js.map
+//# sourceMappingURL=setup-hWG3ZBG3.js.map

package/dist/{share-Bq_tDXQU.js → share-BjqQBWM-.js}

@@ -534,4 +534,4 @@ async function startShare(opts) {
 
 //#endregion
 export { loadOrCreateShareRoom, shareLinkFromRoomUrl, startShare };
-//# sourceMappingURL=share-Bq_tDXQU.js.map
+//# sourceMappingURL=share-BjqQBWM-.js.map

package/dist/spawnGate-B_VDMXYL.js

@@ -0,0 +1,107 @@
+import { i as readGlobalPids } from "./globalPidIndex-DlmmJlO8.js";
+import { a as getSpawnWaitMs, n as getMinFreeMb, t as getMaxAgents } from "./workspaceConfig-D3OH7and.js";
+import { readFile } from "fs/promises";
+
+//#region ts/spawnGate.ts
+/**
+* Spawn admission control — keep an unbounded fan-out of agents from exhausting
+* host RAM and tripping the kernel OOM-killer (which, on a box with no cgroup
+* memory limit, hangs the whole machine). Two opt-in limits:
+*   - {@link getMaxAgents}  — max concurrently-live agents
+*   - {@link getMinFreeMb}  — minimum free memory before admitting a spawn
+*
+* Two entry points share one instantaneous check ({@link spawnRejectionReason}):
+*   - the `ay serve` daemon HARD-REJECTS (`/api/spawn` → 429) so the caller retries;
+*   - the CLI path BLOCKS-AND-WAITS ({@link waitForSpawnCapacity}) with φ-backoff,
+*     failing open after a timeout so recursive `ay <cli>` spawns get spaced out
+*     (the actual cause of the burst storms) without ever deadlocking a workflow.
+*/
+/**
+* System available memory in MB. Prefers Linux `/proc/meminfo` `MemAvailable`
+* (the kernel's own estimate of what's reclaimable without swapping — far more
+* accurate than free RAM), falling back to `os.freemem()` on other platforms or
+* if the file can't be parsed. Returns null when nothing usable is available.
+*/
+async function memAvailableMb() {
+	try {
+		const txt = await readFile("/proc/meminfo", "utf-8");
+		const m = /^MemAvailable:\s+(\d+)\s*kB/m.exec(txt);
+		if (m) return Math.floor(Number(m[1]) / 1024);
+	} catch {}
+	try {
+		const { freemem } = await import("os");
+		return Math.floor(freemem() / (1024 * 1024));
+	} catch {
+		return null;
+	}
+}
+/** True when at least one spawn limit is configured (else the gate is a no-op). */
+function spawnGateEnabled() {
+	return getMaxAgents() !== void 0 || getMinFreeMb() !== void 0;
+}
+/**
+* Instantaneous capacity check. Returns a human-readable reason string when a
+* new spawn should be held back (cap reached / memory too low), or null when
+* there's capacity. Both limits are opt-in — unset means no check.
+*
+* NOTE — the `maxAgents` count is BEST-EFFORT, not a hard barrier: the check is
+* non-atomic (check here → register in `pids.jsonl` later, in another process),
+* so a simultaneous burst can briefly overshoot the cap before the new wrappers
+* appear in the live count. That's acceptable because (a) the CLI path's
+* φ-backoff desynchronizes retries, spreading a burst out, and (b) `minFreeMb`
+* is the HARD OOM guard — it's re-evaluated against live `/proc/meminfo` on every
+* attempt, so once RAM actually drops, further spawns are held regardless of the
+* count. Exact admission would need a cross-process reservation+lock (a TTL'd
+* reservation file); deliberately deferred to avoid stale reservations wedging
+* spawns, which would be worse than a transient overshoot.
+*/
+async function spawnRejectionReason() {
+	const maxAgents = getMaxAgents();
+	if (maxAgents !== void 0) {
+		const live = (await readGlobalPids({ liveOnly: true })).length;
+		if (live >= maxAgents) return `too many agents running (${live}/${maxAgents}) — this agent wasn't started. Please wait for one to finish and try again. (host: raise "maxAgents" in ~/.agent-yes/config.json or AGENT_YES_MAX_AGENTS)`;
+	}
+	const minFreeMb = getMinFreeMb();
+	if (minFreeMb !== void 0) {
+		const avail = await memAvailableMb();
+		if (avail !== null && avail < minFreeMb) return `the host is low on memory (${avail}MB free, needs ${minFreeMb}MB) — this agent wasn't started, to avoid crashing the machine. Please try again in a moment. (host: adjust "minFreeMb" in ~/.agent-yes/config.json or AGENT_YES_MIN_FREE_MB)`;
+	}
+	return null;
+}
+const PHI = 1.618;
+const BACKOFF_CAP_MS = 6e4;
+const BACKOFF_BASE_MS = 1e3;
+/**
+* Block until there's spawn capacity, polling with φ-backoff (1s × φⁿ, capped at
+* 60s — there is no OS event for "memory freed", so polling is unavoidable here).
+* Fails open after {@link getSpawnWaitMs} ms (default 10 min): on timeout it logs
+* and proceeds, so a set of mutually-waiting recursive spawns can never deadlock
+* permanently. A no-op (returns immediately) when no limit is configured, so it
+* adds ~zero overhead to the spawn hot path for users who haven't opted in.
+*
+* `sleep`/`now` are injectable for tests. `onWait` fires once per backoff cycle.
+*/
+async function waitForSpawnCapacity(opts) {
+	if (!spawnGateEnabled()) return;
+	const maxWaitMs = opts?.maxWaitMs ?? getSpawnWaitMs();
+	const now = opts?.now ?? (() => performance.now());
+	const sleep = opts?.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+	const start = now();
+	let delay = BACKOFF_BASE_MS;
+	for (;;) {
+		const reason = await spawnRejectionReason();
+		if (!reason) return;
+		const waited = now() - start;
+		if (waited >= maxWaitMs) {
+			opts?.onProceedAnyway?.(reason, waited);
+			return;
+		}
+		opts?.onWait?.(reason, waited);
+		await sleep(Math.min(delay, BACKOFF_CAP_MS, maxWaitMs - waited));
+		delay = Math.min(delay * PHI, BACKOFF_CAP_MS);
+	}
+}
+
+//#endregion
+export { waitForSpawnCapacity as i, spawnGateEnabled as n, spawnRejectionReason as r, memAvailableMb as t };
+//# sourceMappingURL=spawnGate-B_VDMXYL.js.map

package/dist/spawnGate-UH73I2le.js

@@ -0,0 +1,5 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import { i as waitForSpawnCapacity, n as spawnGateEnabled, r as spawnRejectionReason, t as memAvailableMb } from "./spawnGate-B_VDMXYL.js";
+
+export { waitForSpawnCapacity };

package/dist/{subcommands-DtwxPMYe.js → subcommands-BY0mIDo9.js}

@@ -3,7 +3,7 @@ import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-DlmmJlO8.js";
 import { t as loadSharedCliDefaults } from "./configShared-CEyhl0WH.js";
 import { n as isWebrtcSpec } from "./webrtcLink-CBZkZ-LT.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-DBCvpp3B.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-T6nf0t3K.js";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
@@ -597,19 +597,19 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-DzOWMI_8.js");
+				const { cmdServe } = await import("./serve-DeJBMba0.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-tVfp7djj.js");
+				const { cmdSetup } = await import("./setup-hWG3ZBG3.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-BobQwIBS.js");
+				const { cmdSchedule } = await import("./schedule-CwAX3y8s.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-DkNuq417.js");
+				const { cmdRemote } = await import("./remotes-ClT1bq16.js");
 				return cmdRemote(rest);
 			}
 			case "reap":
@@ -982,7 +982,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-Ccdzmuc-.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-GAgF5K45.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -3005,4 +3005,4 @@ async function cmdResultSet(rest) {
 
 //#endregion
 export { writeToIpc as A, resolveReadWindow as C, snapshotStatus as D, runSubcommand as E, stopTipForCli as O, resolveOne as S, restartHintLines as T, menuSelectKeys as _, cursorAbs as a, renderRawLog as b, extractNeedsInput as c, isAgentStuck as d, isExitRequest as f, matchKeyword as g, listRecords as h, controlCodeFromName as i, writeKeysPaced as k, extractTaskCounts as l, isSubcommand as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isPidAlive as p, cmdHelp as r, extractMenu as s, GRACEFUL_EXIT_COMMANDS as t, finalizedLines as u, readNotes as v, resolveResumeArgs as w, renderRawLogLines as x, readPtysize as y };
-//# sourceMappingURL=subcommands-DtwxPMYe.js.map
+//# sourceMappingURL=subcommands-BY0mIDo9.js.map

package/dist/{subcommands-CIFWi9vq.js → subcommands-BnsjTNpy.js}

@@ -3,7 +3,7 @@ import "./globalPidIndex-DlmmJlO8.js";
 import "./configShared-CEyhl0WH.js";
 import "./e2e-Bfw7qL9O.js";
 import "./webrtcLink-CBZkZ-LT.js";
-import "./remotes-DBCvpp3B.js";
-import { A as writeToIpc, C as resolveReadWindow, D as snapshotStatus, E as runSubcommand, O as stopTipForCli, S as resolveOne, T as restartHintLines, _ as menuSelectKeys, a as cursorAbs, b as renderRawLog, c as extractNeedsInput, d as isAgentStuck, f as isExitRequest, g as matchKeyword, h as listRecords, i as controlCodeFromName, k as writeKeysPaced, l as extractTaskCounts, m as isSubcommand, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isPidAlive, r as cmdHelp, s as extractMenu, t as GRACEFUL_EXIT_COMMANDS, u as finalizedLines, v as readNotes, w as resolveResumeArgs, x as renderRawLogLines, y as readPtysize } from "./subcommands-DtwxPMYe.js";
+import "./remotes-T6nf0t3K.js";
+import { A as writeToIpc, C as resolveReadWindow, D as snapshotStatus, E as runSubcommand, O as stopTipForCli, S as resolveOne, T as restartHintLines, _ as menuSelectKeys, a as cursorAbs, b as renderRawLog, c as extractNeedsInput, d as isAgentStuck, f as isExitRequest, g as matchKeyword, h as listRecords, i as controlCodeFromName, k as writeKeysPaced, l as extractTaskCounts, m as isSubcommand, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isPidAlive, r as cmdHelp, s as extractMenu, t as GRACEFUL_EXIT_COMMANDS, u as finalizedLines, v as readNotes, w as resolveResumeArgs, x as renderRawLogLines, y as readPtysize } from "./subcommands-BY0mIDo9.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-BMzpUSfa.js → tray-CZarCA2Q.js}

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

package/dist/{ts-jDEwTsVt.js → ts-CXxZiZKE.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-C0UJyFcN.js";
+import { r as getInstalledPackage } from "./versionChecker-Dv5DhRs3.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-V4qvXgAw.js";
 import { t as PidStore } from "./pidStore-BfoBWUjc.js";
@@ -1803,4 +1803,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-jDEwTsVt.js.map
+//# sourceMappingURL=ts-CXxZiZKE.js.map

package/dist/{versionChecker-C0UJyFcN.js → versionChecker-Dv5DhRs3.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "claude-yes";
-var version = "1.165.0";
+var version = "1.166.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-C0UJyFcN.js.map
+//# sourceMappingURL=versionChecker-Dv5DhRs3.js.map

package/dist/{webrtcRemote-Ccdzmuc-.js → webrtcRemote-GAgF5K45.js}

@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-Ccdzmuc-.js.map
+//# sourceMappingURL=webrtcRemote-GAgF5K45.js.map

package/dist/{workspaceConfig-B0Q9-q2B.js → workspaceConfig-D3OH7and.js}

@@ -96,6 +96,45 @@ function getSpawnHook() {
 function hasSpawnHook() {
 	return getSpawnHook() !== null;
 }
+/**
+* Cap on concurrently-live agents admitted via `/api/spawn`. Env
+* `AGENT_YES_MAX_AGENTS` overrides the config `maxAgents`. A non-positive,
+* missing, or unparseable value means **unlimited** (returns undefined), which
+* preserves the historical no-cap behavior. Exists to stop an unbounded fan-out
+* of agents from exhausting host RAM and tripping the OOM-killer.
+*/
+function getMaxAgents() {
+	const raw = process.env.AGENT_YES_MAX_AGENTS?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().maxAgents;
+	const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+	return v > 0 ? v : void 0;
+}
+/**
+* Minimum system MemAvailable (MB) required to admit a new spawn. Env
+* `AGENT_YES_MIN_FREE_MB` overrides config `minFreeMb`. Non-positive/unset =
+* no floor (undefined). Complements {@link getMaxAgents}: a count cap alone
+* can't stop OOM when individual agents are large, so we also refuse to spawn
+* when free memory is already low.
+*/
+function getMinFreeMb() {
+	const raw = process.env.AGENT_YES_MIN_FREE_MB?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().minFreeMb;
+	const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+	return v > 0 ? v : void 0;
+}
+/**
+* Max time (ms) a CLI spawn blocks waiting for capacity before failing open.
+* Env `AGENT_YES_SPAWN_WAIT_MS` overrides config `spawnWaitMs`. A non-negative
+* finite value is used as-is (0 = don't wait, check once then proceed); anything
+* missing/garbage falls back to the 10-minute default. Bounded fail-open is
+* deliberate: recursive spawns must never deadlock permanently on each other.
+*/
+function getSpawnWaitMs() {
+	const DEFAULT = 6e5;
+	const raw = process.env.AGENT_YES_SPAWN_WAIT_MS?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().spawnWaitMs;
+	return typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT;
+}
 /** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
 function setWorkspaceRoot(dir) {
 	const abs = path.resolve(expandTilde(dir));
@@ -122,5 +161,5 @@ function resolveSpawnCwd(input) {
 }
 
 //#endregion
-export { isProvisionAllowed as a, hasSpawnHook as i, getSpawnHook as n, resolveSpawnCwd as o, getWorkspaceRoot as r, setWorkspaceRoot as s, getProvisionRoot as t };
-//# sourceMappingURL=workspaceConfig-B0Q9-q2B.js.map
+export { getSpawnWaitMs as a, isProvisionAllowed as c, getSpawnHook as i, resolveSpawnCwd as l, getMinFreeMb as n, getWorkspaceRoot as o, getProvisionRoot as r, hasSpawnHook as s, getMaxAgents as t, setWorkspaceRoot as u };
+//# sourceMappingURL=workspaceConfig-D3OH7and.js.map

package/package.json

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

package/ts/cli.ts

@@ -62,6 +62,27 @@ if (config.tray) {
   ensureTray(); // fire-and-forget, don't await
 }
 
+// Spawn admission control — applies to a REAL agent launch only (subcommands,
+// --version, --tray already handled/exited above; --append-prompt / --version
+// below are not launches). Sits BEFORE the --rust dispatch so it gates BOTH the
+// Rust and the TypeScript runtimes. Blocks with φ-backoff until there's capacity
+// (or fails open after a timeout) so a burst of recursive `ay <cli>` spawns gets
+// spaced out instead of storming the host into the OOM-killer. No-op (instant)
+// unless maxAgents/minFreeMb is configured — see ts/spawnGate.ts.
+if (!config.showVersion && !config.appendPrompt && !config.tray) {
+  const { waitForSpawnCapacity } = await import("./spawnGate.ts");
+  await waitForSpawnCapacity({
+    onWait: (reason, waitedMs) => {
+      if (config.verbose || waitedMs === 0)
+        console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
+    },
+    onProceedAnyway: (reason, waitedMs) =>
+      console.error(
+        `[agent-yes] spawn gate: ${reason} — waited ${Math.round(waitedMs / 1000)}s, proceeding anyway`,
+      ),
+  });
+}
+
 // Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
   let rustBinary: string | undefined;

package/ts/serve.ts

@@ -21,6 +21,7 @@ import {
   type CommonOpts,
 } from "./subcommands.ts";
 import { updateGlobalPidStatus } from "./globalPidIndex.ts";
+import { spawnRejectionReason } from "./spawnGate.ts";
 import { pgidForWrapper } from "./reaper.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { getInstalledPackage } from "./versionChecker.ts";
@@ -1705,6 +1706,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
         return new Response(`unsupported cli: ${cli}`, { status: 400 });
       const prompt = String(body.prompt ?? "");
 
+      // Admission control BEFORE any provisioning (clone/worktree) so a capped
+      // request fails fast without doing expensive work. Enforces the optional
+      // concurrency cap + memory floor that keep a fan-out of agents from
+      // driving the host into the OOM-killer. 429 = back-pressure, retry later.
+      const reject = await spawnRejectionReason();
+      if (reject) return new Response(reject, { status: 429 });
+
       // Resolve the working directory. A `from` source is provisioned (clone /
       // worktree) through codehost/provision; a plain `cwd` is resolved to the
       // workspace root and mkdir-p'd so a missing dir no longer ENOENTs.

package/ts/spawnGate.spec.ts

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import {
+  memAvailableMb,
+  spawnGateEnabled,
+  spawnRejectionReason,
+  waitForSpawnCapacity,
+} from "./spawnGate.ts";
+
+// Build a minimal live pid record. Using the test runner's own pid guarantees
+// `isProcessAlive` (process.kill(pid, 0)) succeeds, so the record counts as live.
+const liveRecord = (pid: number) =>
+  JSON.stringify({
+    pid,
+    cli: "claude",
+    prompt: null,
+    cwd: "/tmp",
+    log_file: null,
+    status: "active",
+    exit_code: null,
+    exit_reason: null,
+    started_at: 0,
+  });
+
+describe("spawnGate", () => {
+  let original: string | undefined;
+  let tmp: string;
+  const writePids = (lines: string[]) =>
+    writeFileSync(path.join(tmp, "pids.jsonl"), lines.join("\n") + "\n");
+
+  beforeEach(() => {
+    original = process.env.AGENT_YES_HOME;
+    tmp = mkdtempSync(path.join(tmpdir(), "ay-gate-"));
+    process.env.AGENT_YES_HOME = tmp;
+  });
+  afterEach(() => {
+    if (original === undefined) delete process.env.AGENT_YES_HOME;
+    else process.env.AGENT_YES_HOME = original;
+    delete process.env.AGENT_YES_MAX_AGENTS;
+    delete process.env.AGENT_YES_MIN_FREE_MB;
+    delete process.env.AGENT_YES_SPAWN_WAIT_MS;
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  describe("memAvailableMb", () => {
+    it("returns a positive number on this host", async () => {
+      const mb = await memAvailableMb();
+      expect(mb).not.toBeNull();
+      expect(mb!).toBeGreaterThan(0);
+    });
+  });
+
+  describe("spawnGateEnabled", () => {
+    it("is false when nothing is configured", () => {
+      expect(spawnGateEnabled()).toBe(false);
+    });
+    it("is true when a cap or floor is set", () => {
+      process.env.AGENT_YES_MAX_AGENTS = "5";
+      expect(spawnGateEnabled()).toBe(true);
+    });
+  });
+
+  describe("spawnRejectionReason", () => {
+    it("returns null when no limits are configured", async () => {
+      expect(await spawnRejectionReason()).toBeNull();
+    });
+
+    it("rejects when live agents reach the cap", async () => {
+      writePids([liveRecord(process.pid)]);
+      process.env.AGENT_YES_MAX_AGENTS = "1";
+      expect(await spawnRejectionReason()).toMatch(/too many agents running \(1\/1\)/);
+    });
+
+    it("admits when live agents are under the cap", async () => {
+      writePids([liveRecord(process.pid)]);
+      process.env.AGENT_YES_MAX_AGENTS = "5";
+      expect(await spawnRejectionReason()).toBeNull();
+    });
+
+    it("ignores dead pids when counting live agents", async () => {
+      // pid 2^31-1 is effectively never a live process → not counted.
+      writePids([liveRecord(2147483646)]);
+      process.env.AGENT_YES_MAX_AGENTS = "1";
+      expect(await spawnRejectionReason()).toBeNull();
+    });
+
+    it("rejects when free memory is below the floor", async () => {
+      process.env.AGENT_YES_MIN_FREE_MB = String(Number.MAX_SAFE_INTEGER);
+      expect(await spawnRejectionReason()).toMatch(/host is low on memory/);
+    });
+
+    it("admits when free memory is above the floor", async () => {
+      process.env.AGENT_YES_MIN_FREE_MB = "1";
+      expect(await spawnRejectionReason()).toBeNull();
+    });
+  });
+
+  describe("waitForSpawnCapacity", () => {
+    it("returns immediately (no sleep) when the gate is disabled", async () => {
+      const sleeps: number[] = [];
+      await waitForSpawnCapacity({ sleep: async (ms) => void sleeps.push(ms) });
+      expect(sleeps).toEqual([]);
+    });
+
+    it("backs off with φ growth and fails open at the deadline", async () => {
+      writePids([liveRecord(process.pid)]);
+      process.env.AGENT_YES_MAX_AGENTS = "1"; // always over → never admits
+
+      let t = 0;
+      const sleeps: number[] = [];
+      let proceededAfter: number | null = null;
+      await waitForSpawnCapacity({
+        maxWaitMs: 5000,
+        now: () => t,
+        sleep: async (ms) => {
+          sleeps.push(ms);
+          t += ms;
+        },
+        onProceedAnyway: (_r, waited) => {
+          proceededAfter = waited;
+        },
+      });
+
+      // 1000, then ×φ (1618), then clamped to the remaining 2382ms before deadline.
+      expect(sleeps[0]).toBe(1000);
+      expect(sleeps[1]).toBe(1618);
+      expect(sleeps.reduce((a, b) => a + b, 0)).toBe(5000);
+      expect(proceededAfter).toBe(5000);
+    });
+
+    it("admits as soon as capacity frees, without proceeding-anyway", async () => {
+      writePids([liveRecord(process.pid)]);
+      process.env.AGENT_YES_MAX_AGENTS = "1";
+
+      const sleeps: number[] = [];
+      let proceeded = false;
+      await waitForSpawnCapacity({
+        maxWaitMs: 600_000,
+        sleep: async (ms) => {
+          sleeps.push(ms);
+          // free up capacity after two backoff cycles
+          if (sleeps.length >= 2) process.env.AGENT_YES_MAX_AGENTS = "10";
+        },
+        onProceedAnyway: () => {
+          proceeded = true;
+        },
+      });
+
+      expect(sleeps.length).toBe(2);
+      expect(proceeded).toBe(false);
+    });
+  });
+});

package/ts/spawnGate.ts

@@ -0,0 +1,123 @@
+/**
+ * Spawn admission control — keep an unbounded fan-out of agents from exhausting
+ * host RAM and tripping the kernel OOM-killer (which, on a box with no cgroup
+ * memory limit, hangs the whole machine). Two opt-in limits:
+ *   - {@link getMaxAgents}  — max concurrently-live agents
+ *   - {@link getMinFreeMb}  — minimum free memory before admitting a spawn
+ *
+ * Two entry points share one instantaneous check ({@link spawnRejectionReason}):
+ *   - the `ay serve` daemon HARD-REJECTS (`/api/spawn` → 429) so the caller retries;
+ *   - the CLI path BLOCKS-AND-WAITS ({@link waitForSpawnCapacity}) with φ-backoff,
+ *     failing open after a timeout so recursive `ay <cli>` spawns get spaced out
+ *     (the actual cause of the burst storms) without ever deadlocking a workflow.
+ */
+import { readFile } from "fs/promises";
+import { readGlobalPids } from "./globalPidIndex.ts";
+import { getMaxAgents, getMinFreeMb, getSpawnWaitMs } from "./workspaceConfig.ts";
+
+/**
+ * System available memory in MB. Prefers Linux `/proc/meminfo` `MemAvailable`
+ * (the kernel's own estimate of what's reclaimable without swapping — far more
+ * accurate than free RAM), falling back to `os.freemem()` on other platforms or
+ * if the file can't be parsed. Returns null when nothing usable is available.
+ */
+export async function memAvailableMb(): Promise<number | null> {
+  try {
+    const txt = await readFile("/proc/meminfo", "utf-8");
+    const m = /^MemAvailable:\s+(\d+)\s*kB/m.exec(txt);
+    if (m) return Math.floor(Number(m[1]) / 1024);
+  } catch {
+    /* not Linux / unreadable — fall through */
+  }
+  try {
+    const { freemem } = await import("os");
+    return Math.floor(freemem() / (1024 * 1024));
+  } catch {
+    return null;
+  }
+}
+
+/** True when at least one spawn limit is configured (else the gate is a no-op). */
+export function spawnGateEnabled(): boolean {
+  return getMaxAgents() !== undefined || getMinFreeMb() !== undefined;
+}
+
+/**
+ * Instantaneous capacity check. Returns a human-readable reason string when a
+ * new spawn should be held back (cap reached / memory too low), or null when
+ * there's capacity. Both limits are opt-in — unset means no check.
+ *
+ * NOTE — the `maxAgents` count is BEST-EFFORT, not a hard barrier: the check is
+ * non-atomic (check here → register in `pids.jsonl` later, in another process),
+ * so a simultaneous burst can briefly overshoot the cap before the new wrappers
+ * appear in the live count. That's acceptable because (a) the CLI path's
+ * φ-backoff desynchronizes retries, spreading a burst out, and (b) `minFreeMb`
+ * is the HARD OOM guard — it's re-evaluated against live `/proc/meminfo` on every
+ * attempt, so once RAM actually drops, further spawns are held regardless of the
+ * count. Exact admission would need a cross-process reservation+lock (a TTL'd
+ * reservation file); deliberately deferred to avoid stale reservations wedging
+ * spawns, which would be worse than a transient overshoot.
+ */
+export async function spawnRejectionReason(): Promise<string | null> {
+  const maxAgents = getMaxAgents();
+  if (maxAgents !== undefined) {
+    // Live agents already running (this wrapper hasn't registered itself yet),
+    // so "live >= cap" admits exactly `maxAgents` concurrent agents.
+    const live = (await readGlobalPids({ liveOnly: true })).length;
+    if (live >= maxAgents)
+      // Phrased for the end user who clicked "Spawn" (the console shows this
+      // string verbatim), with a host-admin hint appended in parentheses.
+      return `too many agents running (${live}/${maxAgents}) — this agent wasn't started. Please wait for one to finish and try again. (host: raise "maxAgents" in ~/.agent-yes/config.json or AGENT_YES_MAX_AGENTS)`;
+  }
+  const minFreeMb = getMinFreeMb();
+  if (minFreeMb !== undefined) {
+    const avail = await memAvailableMb();
+    if (avail !== null && avail < minFreeMb)
+      return `the host is low on memory (${avail}MB free, needs ${minFreeMb}MB) — this agent wasn't started, to avoid crashing the machine. Please try again in a moment. (host: adjust "minFreeMb" in ~/.agent-yes/config.json or AGENT_YES_MIN_FREE_MB)`;
+  }
+  return null;
+}
+
+const PHI = 1.618; // golden-ratio backoff base (snomiao global pref)
+const BACKOFF_CAP_MS = 60_000;
+const BACKOFF_BASE_MS = 1_000;
+
+/**
+ * Block until there's spawn capacity, polling with φ-backoff (1s × φⁿ, capped at
+ * 60s — there is no OS event for "memory freed", so polling is unavoidable here).
+ * Fails open after {@link getSpawnWaitMs} ms (default 10 min): on timeout it logs
+ * and proceeds, so a set of mutually-waiting recursive spawns can never deadlock
+ * permanently. A no-op (returns immediately) when no limit is configured, so it
+ * adds ~zero overhead to the spawn hot path for users who haven't opted in.
+ *
+ * `sleep`/`now` are injectable for tests. `onWait` fires once per backoff cycle.
+ */
+export async function waitForSpawnCapacity(opts?: {
+  maxWaitMs?: number;
+  onWait?: (reason: string, waitedMs: number) => void;
+  onProceedAnyway?: (reason: string, waitedMs: number) => void;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+}): Promise<void> {
+  if (!spawnGateEnabled()) return; // fast path: nothing configured
+  const maxWaitMs = opts?.maxWaitMs ?? getSpawnWaitMs();
+  // Monotonic clock for the deadline — `Date.now()` can step backward (NTP /
+  // suspend) and stretch the fail-open wait far past `maxWaitMs`.
+  const now = opts?.now ?? (() => performance.now());
+  const sleep = opts?.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const start = now();
+  let delay = BACKOFF_BASE_MS;
+  for (;;) {
+    const reason = await spawnRejectionReason();
+    if (!reason) return; // capacity available — admit
+    const waited = now() - start;
+    if (waited >= maxWaitMs) {
+      opts?.onProceedAnyway?.(reason, waited);
+      return; // fail open — never deadlock a workflow
+    }
+    opts?.onWait?.(reason, waited);
+    // Don't oversleep past the deadline.
+    await sleep(Math.min(delay, BACKOFF_CAP_MS, maxWaitMs - waited));
+    delay = Math.min(delay * PHI, BACKOFF_CAP_MS);
+  }
+}

package/ts/workspaceConfig.spec.ts

@@ -4,6 +4,9 @@ import { homedir, tmpdir } from "os";
 import path from "path";
 import {
   expandTilde,
+  getMaxAgents,
+  getMinFreeMb,
+  getSpawnWaitMs,
   getProvisionAllowlist,
   getProvisionRoot,
   getSpawnHook,
@@ -28,6 +31,9 @@ describe("workspaceConfig", () => {
     delete process.env.CODEHOST_WS_ROOT;
     delete process.env.CODEHOST_PROVISION_ALLOWLIST;
     delete process.env.AGENT_YES_SPAWN_HOOK;
+    delete process.env.AGENT_YES_MAX_AGENTS;
+    delete process.env.AGENT_YES_MIN_FREE_MB;
+    delete process.env.AGENT_YES_SPAWN_WAIT_MS;
     rmSync(tmp, { recursive: true, force: true });
   });
 
@@ -146,6 +152,85 @@ describe("workspaceConfig", () => {
     });
   });
 
+  describe("getMaxAgents", () => {
+    it("is undefined (unlimited) when neither env nor config is set", () => {
+      expect(getMaxAgents()).toBeUndefined();
+    });
+
+    it("reads a positive integer from config", () => {
+      writeConfig({ maxAgents: 8 });
+      expect(getMaxAgents()).toBe(8);
+    });
+
+    it("env AGENT_YES_MAX_AGENTS overrides config", () => {
+      writeConfig({ maxAgents: 8 });
+      process.env.AGENT_YES_MAX_AGENTS = "3";
+      expect(getMaxAgents()).toBe(3);
+    });
+
+    it("floors a fractional value", () => {
+      process.env.AGENT_YES_MAX_AGENTS = "4.9";
+      expect(getMaxAgents()).toBe(4);
+    });
+
+    it("treats 0, negative, and garbage as unlimited (undefined)", () => {
+      writeConfig({ maxAgents: 0 });
+      expect(getMaxAgents()).toBeUndefined();
+      process.env.AGENT_YES_MAX_AGENTS = "-5";
+      expect(getMaxAgents()).toBeUndefined();
+      process.env.AGENT_YES_MAX_AGENTS = "lots";
+      expect(getMaxAgents()).toBeUndefined();
+    });
+
+    it("treats a fractional value < 1 as unlimited, not a 0 hard-cap", () => {
+      // Regression: 0.5 must NOT floor to 0 (which would reject every spawn).
+      process.env.AGENT_YES_MAX_AGENTS = "0.5";
+      expect(getMaxAgents()).toBeUndefined();
+    });
+  });
+
+  describe("getMinFreeMb", () => {
+    it("is undefined (no floor) when unset", () => {
+      expect(getMinFreeMb()).toBeUndefined();
+    });
+
+    it("reads config and lets env override", () => {
+      writeConfig({ minFreeMb: 1024 });
+      expect(getMinFreeMb()).toBe(1024);
+      process.env.AGENT_YES_MIN_FREE_MB = "2048";
+      expect(getMinFreeMb()).toBe(2048);
+    });
+
+    it("treats non-positive/garbage/sub-1 as no floor", () => {
+      process.env.AGENT_YES_MIN_FREE_MB = "0";
+      expect(getMinFreeMb()).toBeUndefined();
+      process.env.AGENT_YES_MIN_FREE_MB = "nope";
+      expect(getMinFreeMb()).toBeUndefined();
+      process.env.AGENT_YES_MIN_FREE_MB = "0.5";
+      expect(getMinFreeMb()).toBeUndefined();
+    });
+  });
+
+  describe("getSpawnWaitMs", () => {
+    it("defaults to 10 minutes when unset", () => {
+      expect(getSpawnWaitMs()).toBe(600_000);
+    });
+
+    it("reads config and lets env override; allows 0 (don't wait)", () => {
+      writeConfig({ spawnWaitMs: 5000 });
+      expect(getSpawnWaitMs()).toBe(5000);
+      process.env.AGENT_YES_SPAWN_WAIT_MS = "0";
+      expect(getSpawnWaitMs()).toBe(0);
+    });
+
+    it("falls back to the default on negative/garbage", () => {
+      process.env.AGENT_YES_SPAWN_WAIT_MS = "-1";
+      expect(getSpawnWaitMs()).toBe(600_000);
+      process.env.AGENT_YES_SPAWN_WAIT_MS = "soon";
+      expect(getSpawnWaitMs()).toBe(600_000);
+    });
+  });
+
   describe("getSpawnHook / hasSpawnHook", () => {
     const isPosix = process.platform !== "win32";
 

package/ts/workspaceConfig.ts

@@ -25,6 +25,24 @@ interface Config {
    * arbitrary local code that runs on every spawn.
    */
   spawnHook?: string;
+  /**
+   * Max number of concurrently-live agents the daemon will admit via
+   * `/api/spawn`. `0`/unset = unlimited (current behavior). See {@link getMaxAgents}.
+   */
+  maxAgents?: number;
+  /**
+   * Refuse a new spawn when system MemAvailable is below this many MB — a memory
+   * floor so a burst of spawns can't drive the host into the OOM-killer. `0`/unset
+   * = no floor. See {@link getMinFreeMb}.
+   */
+  minFreeMb?: number;
+  /**
+   * How long (ms) a CLI spawn will block-and-wait for capacity (φ-backoff) before
+   * failing open and proceeding anyway. Prevents a burst of recursive `ay <cli>`
+   * spawns from storming the host while never permanently deadlocking a workflow.
+   * Unset = default 10 min. See {@link getSpawnWaitMs}.
+   */
+  spawnWaitMs?: number;
 }
 
 function configPath(): string {
@@ -131,6 +149,52 @@ export function hasSpawnHook(): boolean {
   return getSpawnHook() !== null;
 }
 
+/**
+ * Cap on concurrently-live agents admitted via `/api/spawn`. Env
+ * `AGENT_YES_MAX_AGENTS` overrides the config `maxAgents`. A non-positive,
+ * missing, or unparseable value means **unlimited** (returns undefined), which
+ * preserves the historical no-cap behavior. Exists to stop an unbounded fan-out
+ * of agents from exhausting host RAM and tripping the OOM-killer.
+ */
+export function getMaxAgents(): number | undefined {
+  const raw = process.env.AGENT_YES_MAX_AGENTS?.trim();
+  const n = raw !== undefined && raw !== "" ? Number(raw) : readConfig().maxAgents;
+  // Floor BEFORE the >0 check: a fractional 0<n<1 would otherwise floor to 0 and
+  // turn "invalid/unlimited" into "reject every spawn" (live >= 0 always true).
+  const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+  return v > 0 ? v : undefined;
+}
+
+/**
+ * Minimum system MemAvailable (MB) required to admit a new spawn. Env
+ * `AGENT_YES_MIN_FREE_MB` overrides config `minFreeMb`. Non-positive/unset =
+ * no floor (undefined). Complements {@link getMaxAgents}: a count cap alone
+ * can't stop OOM when individual agents are large, so we also refuse to spawn
+ * when free memory is already low.
+ */
+export function getMinFreeMb(): number | undefined {
+  const raw = process.env.AGENT_YES_MIN_FREE_MB?.trim();
+  const n = raw !== undefined && raw !== "" ? Number(raw) : readConfig().minFreeMb;
+  // Floor before the >0 check (see getMaxAgents) so a fractional value can't
+  // collapse to a meaningless 0 floor.
+  const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+  return v > 0 ? v : undefined;
+}
+
+/**
+ * Max time (ms) a CLI spawn blocks waiting for capacity before failing open.
+ * Env `AGENT_YES_SPAWN_WAIT_MS` overrides config `spawnWaitMs`. A non-negative
+ * finite value is used as-is (0 = don't wait, check once then proceed); anything
+ * missing/garbage falls back to the 10-minute default. Bounded fail-open is
+ * deliberate: recursive spawns must never deadlock permanently on each other.
+ */
+export function getSpawnWaitMs(): number {
+  const DEFAULT = 600_000;
+  const raw = process.env.AGENT_YES_SPAWN_WAIT_MS?.trim();
+  const n = raw !== undefined && raw !== "" ? Number(raw) : readConfig().spawnWaitMs;
+  return typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT;
+}
+
 /** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
 export function setWorkspaceRoot(dir: string): string {
   const abs = path.resolve(expandTilde(dir));

package/dist/SUPPORTED_CLIS-dBgLp3mi.js

@@ -1,8 +0,0 @@
-import "./ts-jDEwTsVt.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C0UJyFcN.js";
-import "./pidStore-BfoBWUjc.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-H7IIw10E.js";
-
-export { SUPPORTED_CLIS };