@cohortapp/agent-sdk 2.11.9 → 2.11.10

package/lib/resource-governor.mjs

@@ -195,28 +195,56 @@ const LIVE_CACHE_MS = 2_000;
  *
  * @returns {{ count:number, rssMB:number }}
  */
+/** Resolve the agent root used to scope daemon-session detection. */
+function reaperAgentRoot(explicit) {
+  return explicit || process.env.AGENT_ROOT || process.env.AGENT_DIR || "";
+}
+
+/**
+ * Is this `ps` line a DAEMON-SPAWNED claude session — and NEVER a human's
+ * interactive Claude Code session? Both the concurrency count and the reaper key
+ * on this so they can only ever touch sessions the agent-sdk daemon itself
+ * launched.
+ *
+ * The discriminator is `--print`: the daemon always spawns `claude --print …`
+ * (non-interactive batch mode via child_process), while interactive Claude Code
+ * (`claude`, `claude --resume`, `claude --continue`) is NEVER `--print`. So a
+ * human's session — even a long-running one — is invisible here. When the agent's
+ * own root is known we ALSO require the command to reference it (the daemon passes
+ * `--mcp-config <AGENT_ROOT>/.mcp.json`), so we never touch a DIFFERENT agent's
+ * session either. Requires a FULL command line (`ps -eo … command`), not `comm`.
+ */
+export function isDaemonSpawnedClaude(line, agentRoot) {
+  if (!/claude/i.test(line)) return false;
+  if (/Claude\.app|Claude Helper|watchdog|grep|ps -eo/.test(line)) return false;
+  if (!/(^|\s)--print(\s|$)/.test(line)) return false;      // interactive Claude Code is never --print
+  if (agentRoot && !line.includes(agentRoot)) return false; // scope to THIS agent's own sessions
+  return true;
+}
+
 export function liveClaudeStats(opts = {}) {
   const now = opts.now || Date.now;
   const t = now();
   if (!opts.force && _liveCache.value && t - _liveCache.at < LIVE_CACHE_MS) {
     return _liveCache.value;
   }
+  const agentRoot = reaperAgentRoot(opts.agentRoot);
   let value = { count: 0, rssMB: 0 };
   try {
-    // pid, rss(KB), comm — mirror the watchdog's filter set so the governor's
-    // view of "live claude" matches what the watchdog would act on.
-    const out = execFileSync("/bin/ps", ["-eo", "pid,etime,rss,comm"], { encoding: "utf-8", timeout: 4000 });
+    // FULL command (not comm) so we can require `--print` + the agent root — i.e.
+    // count ONLY this daemon's own sessions, never a human's interactive Claude
+    // Code session (which would otherwise inflate the count and get reaped).
+    const out = execFileSync("/bin/ps", ["-eo", "pid,etime,rss,command"], { encoding: "utf-8", timeout: 4000 });
     let count = 0;
     let rssKb = 0;
     let stale = 0;
     for (const line of out.split("\n")) {
       const l = line.trim();
       if (!l) continue;
-      if (!/claude/i.test(l)) continue;
-      if (/Claude\.app|Claude Helper|watchdog|grep|ps -eo/.test(l)) continue;
+      if (!isDaemonSpawnedClaude(l, agentRoot)) continue;
       const parts = l.split(/\s+/);
-      // Columns: pid etime rss comm...  A STALE session (idle/wedged, older than
-      // STALE_SESSION_MS) does NOT count toward the ceiling and its RSS is
+      // Columns: pid etime rss command...  A STALE session (idle/wedged, older
+      // than STALE_SESSION_MS) does NOT count toward the ceiling and its RSS is
       // excluded — an abandoned lane must not hold a slot or RAM headroom forever.
       const ageMs = etimeToMs(parts[1]);
       if (STALE_SESSION_MS > 0 && ageMs >= STALE_SESSION_MS) { stale += 1; continue; }
@@ -251,17 +279,20 @@ export function _resetLiveCache() { _liveCache = { at: 0, value: null }; }
 export function reapStaleClaude(deps = {}) {
   const reapMs = Number.isFinite(deps.reapMs) ? deps.reapMs : REAP_SESSION_MS;
   if (!(reapMs > 0)) return { reaped: [], errors: 0 };
+  const agentRoot = reaperAgentRoot(deps.agentRoot);
   const reaped = [];
   let errors = 0;
   try {
+    // FULL command (not comm) so isDaemonSpawnedClaude can require `--print` +
+    // this agent's root — we ONLY ever kill sessions the daemon itself launched,
+    // NEVER a human's interactive Claude Code session (which is never --print).
     const out = typeof deps.psImpl === "function"
       ? deps.psImpl()
-      : execFileSync("/bin/ps", ["-eo", "pid,etime,comm"], { encoding: "utf-8", timeout: 4000 });
+      : execFileSync("/bin/ps", ["-eo", "pid,etime,command"], { encoding: "utf-8", timeout: 4000 });
     const kill = typeof deps.killImpl === "function" ? deps.killImpl : (pid) => process.kill(pid, "SIGKILL");
     for (const line of String(out).split("\n")) {
       const l = line.trim();
-      if (!l || !/claude/i.test(l)) continue;
-      if (/Claude\.app|Claude Helper|watchdog|grep|ps -eo/.test(l)) continue;
+      if (!l || !isDaemonSpawnedClaude(l, agentRoot)) continue;
       const parts = l.split(/\s+/);
       const pid = Number(parts[0]);
       if (!Number.isInteger(pid) || pid <= 1) continue;      // never signal pid 0/1

package/lib/resource-governor.test.mjs

@@ -361,33 +361,49 @@ test("etimeToMs parses ps elapsed-time in all three shapes", () => {
   assert.equal(etimeToMs(""), 0);
 });
 
-test("reapStaleClaude kills only claude sessions older than the reap threshold", () => {
+test("reapStaleClaude kills ONLY daemon --print sessions for this agent — never a human's interactive session", () => {
+  const AR = "/Users/x/isla";
   const ps = [
-    "  100 08-07:05:20 claude --dangerously-skip-permissions --resume old", // 8 days → reap
-    "  200 00:30 claude --print young",                                     // 30s → keep
-    "  300 50:00 claude --resume wedged",                                   // 50 min → reap
-    "  400 90:00 node scripts/daemon/maestro-daemon.mjs",                   // not claude → skip
-    "  500 46:00 Claude Helper (Renderer)",                                 // helper → skip
-    "    1 99-00:00:00 launchd",                                            // pid 1 / not claude → skip
+    `  100 08-07:05:20 /usr/local/bin/claude --print --dangerously-skip-permissions --mcp-config ${AR}/.mcp.json old`, // daemon, 8d → reap
+    `  200 00:30 claude --print --mcp-config ${AR}/.mcp.json young`,      // daemon, 30s → keep (young)
+    `  300 50:00 claude --print --mcp-config ${AR}/.mcp.json wedged`,     // daemon, 50m → reap
+    "  310 90:00 claude --dangerously-skip-permissions --resume",         // HUMAN interactive (no --print) → NEVER reap
+    "  315 99:00 claude",                                                 // HUMAN interactive → NEVER reap
+    "  320 99:00 claude --print --mcp-config /Users/x/OTHER/.mcp.json x", // a DIFFERENT agent → not this root → keep
+    "  400 90:00 node scripts/daemon/maestro-daemon.mjs",                 // not claude → skip
+    "  500 46:00 Claude Helper (Renderer)",                              // helper → skip
+    "    1 99-00:00:00 launchd",                                         // pid 1 → skip
   ].join("\n");
   const killed = [];
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 45 * 60_000 });
+  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 45 * 60_000, agentRoot: AR });
   assert.deepEqual(r.reaped.sort((a, b) => a - b), [100, 300]);
   assert.deepEqual(killed.sort((a, b) => a - b), [100, 300]);
   assert.equal(r.errors, 0);
 });
 
+test("reapStaleClaude never touches an interactive Claude Code session even when very old", () => {
+  const AR = "/Users/x/isla";
+  // A human's `claude --resume` running for 8 DAYS — must survive (no --print).
+  const ps = `  777 08-00:00:00 claude --dangerously-skip-permissions --resume\n`;
+  const killed = [];
+  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 45 * 60_000, agentRoot: AR });
+  assert.deepEqual(r.reaped, []);
+  assert.deepEqual(killed, []);
+});
+
 test("reapStaleClaude is a no-op when reaping is disabled (reapMs=0)", () => {
-  const ps = "  100 08-07:05:20 claude --resume old\n";
+  const AR = "/Users/x/isla";
+  const ps = `  100 08-07:05:20 claude --print --mcp-config ${AR}/.mcp.json old\n`;
   const killed = [];
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 0 });
+  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 0, agentRoot: AR });
   assert.deepEqual(r.reaped, []);
   assert.deepEqual(killed, []);
 });
 
 test("reapStaleClaude counts kill failures without throwing", () => {
-  const ps = "  100 08-07:05:20 claude --resume old\n";
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: () => { throw new Error("ESRCH"); }, reapMs: 60_000 });
+  const AR = "/Users/x/isla";
+  const ps = `  100 08-07:05:20 claude --print --mcp-config ${AR}/.mcp.json old\n`;
+  const r = reapStaleClaude({ psImpl: () => ps, killImpl: () => { throw new Error("ESRCH"); }, reapMs: 60_000, agentRoot: AR });
   assert.deepEqual(r.reaped, []);
   assert.equal(r.errors, 1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.9",
+  "version": "2.11.10",
   "description": "Cohort Agent SDK — autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/scripts/daemon/maestro-daemon.mjs

@@ -127,7 +127,7 @@ try {
   const { reapStaleClaude } = await import("../../lib/resource-governor.mjs");
   const sweep = () => {
     try {
-      const r = reapStaleClaude();
+      const r = reapStaleClaude({ agentRoot: AGENT_DIR });
       if (r.reaped.length) console.log(`[DAEMON] reaped ${r.reaped.length} stale claude session(s): ${r.reaped.join(", ")}`);
     } catch { /* best-effort */ }
   };