@cohortapp/agent-sdk 2.11.8 → 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.8",
+  "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/agent-daemon.mjs

@@ -125,6 +125,9 @@ import { policyFor } from "../../lib/execution/surface-policy.mjs";
 // ---------------------------------------------------------------------------
 
 const POLL_INTERVAL = parseInt(process.env.DAEMON_POLL_INTERVAL || "60000", 10); // 60s (up from 30s to avoid Slack rate limits)
+// Fast reactive scan of the LOCAL cohort inbox only (no API, no rate limit) so an
+// org-push-fetched DM is answered in seconds, not on the 60s poll. See pollCohortFast.
+const COHORT_FAST_INTERVAL = parseInt(process.env.DAEMON_COHORT_POLL_INTERVAL || "2000", 10); // 2s
 // Backlog sweep cadence — bumped 2min → 10min in 1.10. The dispatcher
 // applies a per-item post-completion cooldown (4h success, 30min failure)
 // so we no longer need a tight sweep loop. Operators with high-throughput
@@ -207,44 +210,8 @@ async function poll() {
   }
 
   let totalItems = 0;
-
   for (const svc of services) {
-    try {
-      const result = await svc.fn();
-      // Dedup by raw_ref first: the same Slack message arrives via
-      // multiple paths (channel scan, thread scan, events-server JSON)
-      // with different item IDs. Using raw_ref as the lock key ensures
-      // a single message is only processed once regardless of path.
-      const seenRefs = new Set();
-      const newItems = result.items.filter((item) => {
-        // Skip the agent's own messages — defensive check in case intake filters miss them
-        const sender = (item.sender || "").toLowerCase();
-        const me = loadAgent();
-        const myFirst = (me.firstName || "").toLowerCase();
-        const myFull = (me.fullName || "").toLowerCase().replace(/\s+/g, "-");
-        if (myFirst && (sender === myFirst || sender === myFull)) return false;
-
-        const lockKey = item.raw_ref || item.id || `${svc.name}-${Date.now()}`;
-        if (seenRefs.has(lockKey)) return false;
-        seenRefs.add(lockKey);
-        const lock = acquireLock(lockKey, {
-          sender: item.sender || "unknown",
-          channel: item.channel || item.channel_id || "unknown",
-        });
-        return lock.acquired;
-      });
-      totalItems += newItems.length;
-
-      for (const item of newItems) {
-        await processItem(item, svc.name);
-      }
-
-      if (result.errors.length > 0) {
-        console.warn(`[daemon] ${svc.name} errors:`, result.errors.slice(0, 3));
-      }
-    } catch (err) {
-      console.error(`[daemon] ${svc.name} poll failed:`, err.message);
-    }
+    totalItems += await pollService(svc);
   }
 
   recordPoll(totalItems);
@@ -254,6 +221,74 @@ async function poll() {
 
 }
 
+/**
+ * Scan + process ONE service's inbox. Factored out of poll() so the reactive
+ * cohort path can run on its own fast interval (pollCohortFast) without waiting
+ * on the 60s full poll. Returns the count of new items processed. Never throws.
+ */
+async function pollService(svc) {
+  try {
+    const result = await svc.fn();
+    // Dedup by raw_ref first: the same Slack message arrives via multiple paths
+    // (channel scan, thread scan, events-server JSON) with different item IDs.
+    // Using raw_ref as the lock key ensures a single message is only processed
+    // once regardless of path.
+    const seenRefs = new Set();
+    const newItems = result.items.filter((item) => {
+      // Skip the agent's own messages — defensive check in case intake filters miss them
+      const sender = (item.sender || "").toLowerCase();
+      const me = loadAgent();
+      const myFirst = (me.firstName || "").toLowerCase();
+      const myFull = (me.fullName || "").toLowerCase().replace(/\s+/g, "-");
+      if (myFirst && (sender === myFirst || sender === myFull)) return false;
+
+      const lockKey = item.raw_ref || item.id || `${svc.name}-${Date.now()}`;
+      if (seenRefs.has(lockKey)) return false;
+      seenRefs.add(lockKey);
+      const lock = acquireLock(lockKey, {
+        sender: item.sender || "unknown",
+        channel: item.channel || item.channel_id || "unknown",
+      });
+      return lock.acquired;
+    });
+
+    for (const item of newItems) {
+      await processItem(item, svc.name);
+    }
+
+    if (result.errors.length > 0) {
+      console.warn(`[daemon] ${svc.name} errors:`, result.errors.slice(0, 3));
+    }
+    return newItems.length;
+  } catch (err) {
+    console.error(`[daemon] ${svc.name} poll failed:`, err.message);
+    return 0;
+  }
+}
+
+// ── Fast reactive cohort scan ────────────────────────────────────────────────
+// The org-push wake pulls org DMs/@mentions into state/inbox/cohort/ within ~2s,
+// but the full poll() runs only every POLL_INTERVAL (60s, kept slow because it
+// also hits the RATE-LIMITED Slack API) — so a DM sat up to 60s BETWEEN being
+// fetched and being answered (measured: ~24-44s reactive round-trips that were
+// almost entirely this gap, not the model). Cohort items are local YAML with no
+// API call, so we drain that ONE directory on a short interval. This is the
+// single biggest reactive-latency win. Overlap-guarded; the item lock dedups
+// against the 60s poll's own cohort scan (kept as a safety net).
+let _cohortPoller = null;
+let _cohortFastRunning = false;
+async function pollCohortFast() {
+  if (_cohortFastRunning) return 0;
+  if (!_existsSync(join(AGENT_REPO_DIR, "config/org.yaml"))) return 0;
+  if (!_cohortPoller) _cohortPoller = makeInboxScanPoller("cohort", { agentRoot: AGENT_REPO_DIR });
+  _cohortFastRunning = true;
+  try {
+    return await pollService({ name: "cohort", fn: _cohortPoller });
+  } finally {
+    _cohortFastRunning = false;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Process a single item
 // ---------------------------------------------------------------------------
@@ -2143,6 +2178,12 @@ async function main() {
     }
   }, POLL_INTERVAL);
 
+  // Fast reactive cohort scan — drains org-push-fetched DMs in ~2s instead of
+  // waiting up to 60s for the full poll. Local YAML only; no API/rate-limit cost.
+  setInterval(() => {
+    pollCohortFast().catch((err) => console.error("[daemon] cohort fast-poll error:", err.message));
+  }, COHORT_FAST_INTERVAL);
+
   // Backlog sweep
   setInterval(async () => {
     try {

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 */ }
   };