agent-yes 1.288.0 → 1.289.0

package/dist/{ts-DJLp2_bv.js → ts-CSp4mJ7Z.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin, r as __exportAll } from "./chunk-cZBX9HZv.js";
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { i as getInstalledPackage } from "./versionChecker-CkO7wYyV.js";
+import { i as getInstalledPackage } from "./versionChecker-CWCN4vwm.js";
 import { t as agentYesHome } from "./agentYesHome-BNtn19J4.js";
 import { u as removeControlCharacters } from "./todoAutomation-CbVVS4re.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-BOIPD_Vs.js";
@@ -248,6 +248,20 @@ async function getSessionForCwd(cwd) {
 * Extract session ID from codex output
 * Session IDs are UUIDs in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 */
+/**
+* True for the codex CLI and every codex-derived variant (`codex-ds`,
+* `codex-ds-direct`, …) — they all run the same `codex` binary and print the
+* same session-id banner, so the session capture/resume path must treat them
+* alike. Keying those sites on an exact `=== "codex"` made `--continue` on a
+* variant silently start a fresh session instead of resuming.
+*
+* The per-cwd session store is therefore shared across codex variants. That is
+* fine: resuming re-applies the launching CLI's own `defaultArgs`, so a session
+* resumed via `codex-ds` still talks to DeepSeek.
+*/
+function isCodexFamily(cli) {
+	return cli === "codex" || cli.startsWith("codex-");
+}
 function extractSessionId(output) {
 	const match = output.match(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i);
 	return match ? match[0] : null;
@@ -1599,10 +1613,10 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 	})();
 	const originalPrompt = prompt;
 	if (prompt && inheritedParentPid) try {
-		const { resolveSpawner } = await import("./parentLink-HWunrH1s.js");
+		const { resolveSpawner } = await import("./parentLink-fdiuB13i.js");
 		const spawner = await resolveSpawner(inheritedParentPid);
 		if (spawner) {
-			const { buildInitMsg } = await import("./initMsg-CeF4QNOM.js");
+			const { buildInitMsg } = await import("./initMsg-DoltWTZj.js");
 			const { formatIdentity } = await import("./identity-DFr3dfTO.js");
 			const identity = formatIdentity({
 				cwd: spawner.cwd,
@@ -1666,7 +1680,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 			prompt = prompt ? `[${hint}]\n\n${prompt}` : hint;
 		}
 	} catch {}
-	if (resume) if (cli === "codex" && resume) {
+	if (resume) if (isCodexFamily(cli) && resume) {
 		const storedSessionId = await getSessionForCwd(workingDir);
 		if (storedSessionId) {
 			cliArgs = [
@@ -1905,7 +1919,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 				logger.warn(`[pidStore] Failed to update status for PID ${exitedPid}:`, error);
 			}
 			let restoreArgs = conf.restoreArgs;
-			if (cli === "codex") {
+			if (isCodexFamily(cli)) {
 				const storedSessionId = await getSessionForCwd(workingDir);
 				if (storedSessionId) {
 					restoreArgs = ["resume", storedSessionId];
@@ -2057,7 +2071,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 					await exitAgent();
 					break;
 				}
-				if (cli === "codex") {
+				if (isCodexFamily(cli)) {
 					const sessionId = extractSessionId(line);
 					if (sessionId) {
 						logger.debug(`heartbeat|session|captured session ID: ${sessionId}`);
@@ -2071,7 +2085,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 	}, 100);
 	const cleanupHeartbeat = () => clearInterval(heartbeatInterval);
 	shell.onExit(cleanupHeartbeat);
-	const { startParentPingLoop } = await import("./parentPingLoop-COePRYr9.js");
+	const { startParentPingLoop } = await import("./parentPingLoop-Dc7co5D7.js");
 	const parentPingLoop = startParentPingLoop({
 		parentPid,
 		selfWrapperPid: process.pid,
@@ -2283,7 +2297,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 				ctx.isFatal = true;
 				await exitAgent();
 			}
-			if (cli === "codex") {
+			if (isCodexFamily(cli)) {
 				const sessionId = extractSessionId(line);
 				if (sessionId) {
 					logger.debug(`session|captured session ID: ${sessionId}`);
@@ -2334,4 +2348,4 @@ function sleep(ms) {
 
 //#endregion
 export { hasTodoStore as a, permissionBadge as c, answerAsk as i, AgentContext as l, agentYes as n, listAsks as o, config as r, listAsksForProject as s, CLIS_CONFIG as t, CLAUDE_SESSION_PIN_ENV as u };
-//# sourceMappingURL=ts-DJLp2_bv.js.map
+//# sourceMappingURL=ts-CSp4mJ7Z.js.map

package/dist/{versionChecker-CkO7wYyV.js → versionChecker-CWCN4vwm.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.288.0";
+var version = "1.289.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as a, getInstalledPackage as i, compareVersions as n, displayVersion as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-CkO7wYyV.js.map
+//# sourceMappingURL=versionChecker-CWCN4vwm.js.map

package/dist/{webrtcRemote-H9Hok0_R.js → webrtcRemote-Bevc5ogS.js}

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

package/dist/{widget-CJqpScCG.js → widget-D2cCC8nz.js}

@@ -28,7 +28,7 @@ function parseFlags(args, known) {
 }
 /** Resolve the local daemon base URL + token (flags override discovery). */
 async function daemonTarget(flags) {
-	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-DaDlOtss.js");
+	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-CMsvjqPU.js");
 	const base = typeof flags.base === "string" ? flags.base : await resolveDaemonHttpBase();
 	if (!base) throw new Error("no running ay serve daemon found — start `ay serve` or pass --base <url> (e.g. http://127.0.0.1:PORT)");
 	const token = typeof flags.token === "string" ? flags.token : await loadTokenReadOnly() ?? "";
@@ -186,7 +186,7 @@ async function cmdMint(args) {
 	const bad = caps.filter((c) => !KNOWN_CAPS.has(c));
 	if (bad.length) throw new Error(`unknown cap(s): ${bad.join(", ")} (valid: ${[...KNOWN_CAPS].join(", ")})`);
 	const ttlSec = parseTtlSec(typeof flags.ttl === "string" ? flags.ttl : "15m");
-	const { mintScopedTermToken } = await import("./serve-DaDlOtss.js");
+	const { mintScopedTermToken } = await import("./serve-CMsvjqPU.js");
 	const r = await mintScopedTermToken(target, {
 		ttlSec,
 		caps
@@ -202,4 +202,4 @@ async function cmdMint(args) {
 
 //#endregion
 export { cmdMint, cmdWidget };
-//# sourceMappingURL=widget-CJqpScCG.js.map
+//# sourceMappingURL=widget-D2cCC8nz.js.map

package/dist/{workspaceConfig-D6QndOCz.js → workspaceConfig-DTvPtr5j.js}

@@ -215,4 +215,4 @@ function allowsSkipPermissions() {
 
 //#endregion
 export { getProvisionRoot as a, getWorkspaceRoot as c, isProvisionAllowed as d, resolveSpawnCwd as f, getProvisionHook as i, hasProvisionHook as l, getMaxAgents as n, getSpawnHook as o, setWorkspaceRoot as p, getMinFreeMb as r, getSpawnWaitMs as s, allowsSkipPermissions as t, hasSpawnHook as u };
-//# sourceMappingURL=workspaceConfig-D6QndOCz.js.map
+//# sourceMappingURL=workspaceConfig-DTvPtr5j.js.map

package/dist/{ws-DGENGNrr.js → ws-B5Qb2c-1.js}

@@ -1,5 +1,5 @@
-import { D as listRecords } from "./subcommands-BfiOyfz7.js";
-import { a as getProvisionRoot } from "./workspaceConfig-D6QndOCz.js";
+import { D as listRecords } from "./subcommands-CWDqhKQe.js";
+import { a as getProvisionRoot } from "./workspaceConfig-DTvPtr5j.js";
 import { existsSync } from "fs";
 import { lstat, opendir } from "fs/promises";
 import path from "path";
@@ -424,4 +424,4 @@ async function cmdWs(args) {
 
 //#endregion
 export { isPathInside as a, walkWorkspaces as c, importProvisionModule as i, workspaceStatus as l, cmdWs as n, loadProvision as o, collectWorkspaces as r, resolveOperand as s, WS_JSON_SCHEMA as t };
-//# sourceMappingURL=ws-DGENGNrr.js.map
+//# sourceMappingURL=ws-B5Qb2c-1.js.map

package/dist/{ws-DzCKvzWD.js → ws-CyO9r4jx.js}

@@ -3,10 +3,10 @@ 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 { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-DGENGNrr.js";
+import "./remotes-BjsglpjL.js";
+import { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-B5Qb2c-1.js";
 
 export { WS_JSON_SCHEMA, cmdWs, collectWorkspaces, isPathInside, loadProvision, walkWorkspaces, workspaceStatus };

package/package.json

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

package/ts/agentNice.spec.ts

@@ -1,5 +1,15 @@
-import { describe, expect, it } from "vitest";
-import { agentNiceValue } from "./agentNice.ts";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+// applyAgentNice reaches setPriority through a dynamic `await import("os")`, so
+// the module has to be mocked rather than spied — a namespace object's exports
+// are frozen and a spy on them never takes effect.
+const setPriority = vi.fn();
+vi.mock("os", async (importActual) => {
+  const actual = await importActual<typeof import("os")>();
+  return { ...actual, default: { ...actual, setPriority }, setPriority };
+});
+
+import { agentNiceValue, applyAgentNice } from "./agentNice.ts";
 
 describe("agentNice.agentNiceValue", () => {
   it("defaults to 5 when unset or empty", () => {
@@ -22,3 +32,33 @@ describe("agentNice.agentNiceValue", () => {
     expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "3.9" })).toBe(3); // truncates
   });
 });
+
+describe("agentNice.applyAgentNice", () => {
+  afterEach(() => {
+    setPriority.mockReset();
+  });
+
+  it("deprioritizes the spawned pid to the configured nice", async () => {
+    await applyAgentNice(4242, { AGENT_YES_AGENT_NICE: "7" });
+
+    expect(setPriority).toHaveBeenCalledWith(4242, 7);
+  });
+
+  it("does nothing when nice is 0 (explicitly disabled)", async () => {
+    await applyAgentNice(4242, { AGENT_YES_AGENT_NICE: "0" });
+
+    // 0 means "leave the agent at the default priority" — calling setPriority(0)
+    // anyway would be a no-op syscall, but skipping it keeps the disabled path
+    // free of a platform call that can throw.
+    expect(setPriority).not.toHaveBeenCalled();
+  });
+
+  it("swallows a setPriority failure — a scheduling hint must never break a spawn", async () => {
+    setPriority.mockImplementation(() => {
+      // What an unprivileged container or a pid that already exited looks like.
+      throw new Error("EPERM: operation not permitted");
+    });
+
+    await expect(applyAgentNice(4242, { AGENT_YES_AGENT_NICE: "5" })).resolves.toBeUndefined();
+  });
+});

package/ts/index.ts

@@ -10,6 +10,7 @@ import { agentYesHome } from "./agentYesHome.ts";
 import {
   extractSessionId,
   getSessionForCwd,
+  isCodexFamily,
   storeSessionForCwd,
 } from "./resume/codexSessionManager.ts";
 import pty, { ptyPackage } from "./pty.ts";
@@ -435,7 +436,7 @@ export default async function agentYes({
 
   // Handle --continue flag for codex session restoration
   if (resume) {
-    if (cli === "codex" && resume) {
+    if (isCodexFamily(cli) && resume) {
       // Try to get stored session for this directory
       const storedSessionId = await getSessionForCwd(workingDir);
       if (storedSessionId) {
@@ -827,7 +828,7 @@ export default async function agentYes({
 
       // For codex, try to use stored session ID for this directory
       let restoreArgs = conf.restoreArgs;
-      if (cli === "codex") {
+      if (isCodexFamily(cli)) {
         const storedSessionId = await getSessionForCwd(workingDir);
         if (storedSessionId) {
           // Use specific session ID instead of --last
@@ -1060,7 +1061,7 @@ export default async function agentYes({
         }
 
         // session ID capture for codex
-        if (cli === "codex") {
+        if (isCodexFamily(cli)) {
           const sessionId = extractSessionId(line);
           if (sessionId) {
             logger.debug(`heartbeat|session|captured session ID: ${sessionId}`);
@@ -1447,7 +1448,7 @@ export default async function agentYes({
             }
 
             // session ID capture for codex
-            if (cli === "codex") {
+            if (isCodexFamily(cli)) {
               const sessionId = extractSessionId(line);
               if (sessionId) {
                 logger.debug(`session|captured session ID: ${sessionId}`);

package/ts/notifyDaemon.spec.ts

@@ -72,6 +72,22 @@ describe("notifyd singleton lock", () => {
     expect(await acquireDaemonLock((pid) => pid === 424242)).toBe(true);
   });
 
+  it("GIVES UP (bounded, not a 15ms busy-wait) when the owner is OUR OWN pid, live and fresh", async () => {
+    // The pathological spin: pid reuse hands us the SAME pid a prior daemon held.
+    // With no os_start to prove the disagreement, the decline check skips
+    // (owner.pid === process.pid) AND the shared steal decision refuses (pid is
+    // "self" → not dead; ts fresh → not stale). Before the wait bound this looped
+    // at 15ms forever; now it must decline within the budget instead of spinning.
+    await mkdir(daemonLockDir(), { recursive: true });
+    await writeFile(
+      daemonLockOwnerPath(),
+      JSON.stringify({ pid: process.pid, started_at: 1, ts: Date.now() }),
+    );
+    const t0 = Date.now();
+    expect(await acquireDaemonLock(() => true, 80)).toBe(false); // bounded decline
+    expect(Date.now() - t0).toBeLessThan(2000);
+  });
+
   it("eventually steals a torn owner, but only AFTER the grace (no double daemon)", async () => {
     // A torn owner is also the mkdir→writeOwner window of a concurrent daemon
     // start, so it is respected within the grace (~1s) and stolen only past it —

package/ts/notifyDaemon.ts

@@ -258,6 +258,18 @@ export interface DaemonOptions {
 // the pid+started_at re-check before SIGTERM).
 const OWNER_TTL_MS = 30_000;
 
+// Hard upper bound on how long a contender may wait for the singleton lock. The
+// decline and steal predicates are SUPPOSED to be exhaustive, but they are not
+// complements: a valid owner whose pid equals OUR OWN pid (pid reuse — a prior
+// daemon died and the OS handed us the same pid, with no os_start recorded to
+// prove the disagreement) is skipped by the decline check (`owner.pid !==
+// process.pid`) yet also refused by the shared steal decision (its pid is "self",
+// so not dead; its ts is fresh, so not stale). Without a bound that residue spins
+// at 15ms forever, burning a whole core. Bounded well above the torn-owner grace
+// (~1s) and well below the heartbeat TTL (30s), so a live holder is never waited
+// out to staleness — we decline promptly instead and the next watch poll retries.
+const LOCK_WAIT_BUDGET_MS = 5000;
+
 export interface DaemonIdentity {
   pid: number;
   started_at: number;
@@ -333,11 +345,21 @@ async function writeOwner(): Promise<boolean> {
  */
 export async function acquireDaemonLock(
   isAlive: (pid: number) => boolean = isPidAlive,
+  waitBudgetMs: number = LOCK_WAIT_BUDGET_MS,
 ): Promise<boolean> {
   // The lock dir lives under notify/ — ensure that exists first, else mkdir of
   // the lock throws ENOENT which must NOT be mistaken for "someone holds it".
   await mkdir(notifyDir(), { recursive: true }).catch(() => {});
+  const deadline = Date.now() + waitBudgetMs;
   for (;;) {
+    // Never busy-wait without bound. Every iteration must end in acquire,
+    // decline, or steal; if the identity is so split that NEITHER decline nor
+    // steal applies (see LOCK_WAIT_BUDGET_MS), give up and decline rather than
+    // spin at 15ms indefinitely — the next watch poll re-ensures the daemon.
+    if (Date.now() >= deadline) {
+      logger.warn("[notifyd] gave up acquiring the daemon lock — unverifiable live holder");
+      return false;
+    }
     try {
       await mkdir(daemonLockDir(), { recursive: false });
       daemonStartedAt = Date.now(); // fixed for this daemon's lifetime

package/ts/serve.ts

@@ -58,6 +58,7 @@ import { isCallbackRevoked, loadCallbackSecretReadOnly } from "./callback.ts";
 import { CLAUDE_SESSION_PIN_ENV } from "./sessionEnv.ts";
 import { MAX_CALLBACK_MSG_BYTES, frameVisitorMessage, verifyCapability } from "./callbackCore.ts";
 import { isTerminalReply } from "./terminalReply.ts";
+import * as serveSampler from "./serveSampler.ts";
 import { withIpcLock } from "./ipcLock.ts";
 import { removeControlCharacters } from "./removeControlCharacters.ts";
 import { parseStatusText } from "./statusText.ts";
@@ -2251,6 +2252,10 @@ export async function cmdServe(rest: string[]): Promise<number> {
           : await logBadges(r.log_file).then(async (b) =>
               (await isUserTyping(r.pid)) ? [...b, TYPING_BADGE.id] : b,
             ),
+      // Per-agent resource window (CPU-seconds/RSS/procs) from the background
+      // sampler. Null until the sampler's first pass lands; the console degrades
+      // to a transparent backdrop.
+      res: serveSampler.resField(r.pid),
     };
   };
 
@@ -3095,6 +3100,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
         loadavg: loadavg(),
         mem: { total: totalmem(), free: freemem() },
         uptime: uptime(),
+        resources: serveSampler.resourcesField(),
         caps: {
           send: true, // the console can always drive agent stdin
           kill: true,
@@ -4982,6 +4988,14 @@ export async function cmdServe(rest: string[]): Promise<number> {
       }
     }
 
+    // Start the per-agent resource sampler (left-panel heatmap data). Prime the
+    // first bucket immediately so the first /api/ls already carries `res`. The
+    // sampler reads the live wrapper pids through listRecords (same registry the
+    // /api/ls handler consults), so both agree on the fleet.
+    serveSampler.startSampler(async () =>
+      (await listRecords(undefined, defaultOpts({ all: true }))).map((r) => r.pid),
+    );
+
     // server is null only when we degraded to WebRTC-only above (port wedged);
     // skip the HTTP connection banner since nothing is listening on the port.
     if (server) {