@cohortapp/agent-sdk 2.11.9 → 2.11.11

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.11",
   "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

@@ -499,6 +499,43 @@ async function electResponderVerdict(item, deps = {}) {
  *   the in-process quick-reply responder; rung ≥2 requires a spawned session.
  * @returns {Promise<{ok:boolean, path:string, reason?:string}>}
  */
+// Work-verbs that mean "do a task", not "answer a question" — a DM containing one
+// needs the full classify → session path (it may be multi-step work), so it is
+// NEVER fast-pathed to a shallow quick reply.
+const FASTPATH_WORK_RE = /\b(analy[sz]e|create|build|writ(e|ing)|draft|prepare|research|review|compile|generate|implement|fix|debug|refactor|deploy|migrat(e|ing)|audit|investigate|summari[sz]e|put together|pull together|set up|look into|go through|work on|take care of|handle|organi[sz]e|plan out|figure out)\b/;
+// A DM that reads like a question / greeting / quick ask — safe to answer directly.
+const FASTPATH_ASK_RE = /(\?|^(what|how|when|where|who|why|which|is |are |was |were |do |did |does |can |could |would |will |have |has |should |hey|hi |hello|thanks|thank you|yo |quick (q|question)|you (there|around|up)))/i;
+
+/**
+ * Decide whether a directed DM is a "plainly simple question" that can skip the
+ * LLM classifier and be answered directly. Returns a default classResult (the
+ * quick-reply shape) when it qualifies, else null (→ full classify path).
+ * Deliberately CONSERVATIVE: 1:1 DM, short, question-shaped, no work-verbs.
+ * `deps.fastPathClassify` can override (tests); `deps.disableFastPath` disables.
+ */
+export function fastPathClassify(item, isDm, deps = {}) {
+  if (deps && typeof deps.fastPathClassify === "function") return deps.fastPathClassify(item, isDm);
+  if (deps && deps.disableFastPath) return null;
+  if (process.env.DAEMON_DISABLE_FASTPATH === "1") return null;
+  if (!isDm) return null;                                   // 1:1 DMs only (never group/ambient)
+  const content = String(item.content || item.subject || "").trim();
+  if (!content || content.length > 240) return null;        // short only
+  if (item.has_attachments || item.attachments) return null;
+  const lc = content.toLowerCase();
+  if (FASTPATH_WORK_RE.test(lc)) return null;               // work-request → full path
+  if (!FASTPATH_ASK_RE.test(content)) return null;          // must look like a question/greeting
+  return {
+    priority: "high",            // a directed DM is latency-sensitive → preempts backlog
+    action: "respond",
+    model: "sonnet",             // fast model; a simple question does not need opus
+    summary: content.slice(0, 80),
+    category: "action_required",
+    directed_at_agent: true,
+    answerable: true,            // routes to the in-process quick-reply responder
+    fast_path: true,
+  };
+}
+
 export async function answerItem(item, service, itemId, trace_id, deps = {}, routed = null) {
   // Resolve collaborators: real imports by default (production), injected fakes
   // only when a test supplies them. Names match the imported symbols 1:1.
@@ -523,23 +560,36 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
     // session has no idea it is discharging a planned obligation.
     if (routed) item.execution = routed;
 
-    // Classify via Haiku API
-    const classResult = await _classify({
-      sender: item.sender || "unknown",
-      sender_privilege: item.sender_privilege || item.priority_signals?.from_ceo ? "ceo" : "unknown",
-      channel: item.channel || "unknown",
-      service,
-      content: item.content || item.subject || "",
-      is_reply: item.is_reply || false,
-      thread_context: item.thread_context || null,
-      subject: item.subject || "",
-      is_dm: isDm,
-      is_group: !isDm && service === "slack",
-      agent_in_thread: item.agent_in_thread === true,
-      kind: item.kind || "message",
-    });
+    // FAST PATH: a short, directed, question-shaped DM with no work-verbs does not
+    // need a ~5-8s LLM classification to decide "answer this" — skip the classify
+    // `claude` call entirely and go straight to a quick reply. This is the single
+    // biggest reactive-latency cut after the fetch fix (the two sequential claude
+    // calls dominate processItem). CONSERVATIVE by construction: only a plain
+    // short question qualifies; work-requests and anything ambiguous fall through
+    // to the full classify → route path below, so nothing is shallow-answered.
+    let classResult = fastPathClassify(item, isDm, deps);
+    if (classResult) {
+      recordClassification(true);
+      console.log(`[daemon] fast-path DM — skipped classify (${classResult.model}): ${classResult.summary}`);
+    } else {
+      // Classify via Haiku CLI
+      classResult = await _classify({
+        sender: item.sender || "unknown",
+        sender_privilege: item.sender_privilege || item.priority_signals?.from_ceo ? "ceo" : "unknown",
+        channel: item.channel || "unknown",
+        service,
+        content: item.content || item.subject || "",
+        is_reply: item.is_reply || false,
+        thread_context: item.thread_context || null,
+        subject: item.subject || "",
+        is_dm: isDm,
+        is_group: !isDm && service === "slack",
+        agent_in_thread: item.agent_in_thread === true,
+        kind: item.kind || "message",
+      });
 
-    recordClassification(true);
+      recordClassification(true);
+    }
 
     logEvent("classifications", {
       item_id: itemId,

package/scripts/daemon/agent-daemon.test.mjs

@@ -862,3 +862,29 @@ test("resolveSelfMemberId reads the member cuid from the res frame's `result` (o
     if (pa === undefined) delete process.env.COHORT_AGENT_ID; else process.env.COHORT_AGENT_ID = pa;
   }
 });
+
+test("fastPathClassify: a short directed question skips the classifier; work-requests do not", async () => {
+  const fp = (content, isDm = true, extra = {}) => daemon.fastPathClassify({ content, ...extra }, isDm);
+  // Plain short questions → fast-path (quick reply, high priority, sonnet).
+  const q = fp("what OS is your machine on?");
+  assert.equal(q && q.fast_path, true);
+  assert.equal(q.answerable, true);
+  assert.equal(q.priority, "high");
+  assert.equal(q.action, "respond");
+  assert.ok(daemon.fastPathClassify({ content: "hey, you around?" }, true));
+  assert.ok(daemon.fastPathClassify({ content: "thanks!" }, true));
+  // Work-requests → NOT fast-pathed (fall through to full classify → session).
+  assert.equal(fp("can you analyze the Q3 report and send me the findings?"), null);
+  assert.equal(fp("please review the PR and fix the failing tests"), null);
+  assert.equal(fp("build a dashboard for the sales pipeline"), null);
+  // Non-questions, long messages, group, and non-DM → NOT fast-pathed.
+  assert.equal(fp("here are the notes from the meeting for your records"), null);
+  assert.equal(fp("x".repeat(300)), null);
+  assert.equal(fp("what OS?", false), null); // not a DM
+  assert.equal(fp(""), null);
+  // Attachments → full path.
+  assert.equal(daemon.fastPathClassify({ content: "what's this?", has_attachments: true }, true), null);
+  // Kill switch (deps.disableFastPath) forces the full classify path.
+  assert.ok(daemon.fastPathClassify({ content: "what OS?" }, true));
+  assert.equal(daemon.fastPathClassify({ content: "what OS?" }, true, { disableFastPath: true }), null);
+});

package/scripts/daemon/execution-ladder.test.mjs

@@ -142,7 +142,10 @@ function dm(over = {}) {
     channel_id: "D77",
     sender: "Priya Raman",
     sender_id: "U_PRIYA",
-    content: "can you confirm the deadline?",
+    // A work-request ("review") so this shared fixture takes the full classify →
+    // route path — the fast-path (fastPathClassify) deliberately skips the
+    // classifier only for PLAIN short questions; that path has its own test below.
+    content: "can you review and confirm the deadline for the launch plan?",
     timestamp: new Date().toISOString(),
     ...over,
   };
@@ -190,6 +193,20 @@ test("LADDER: a DM is journalled intake→match→route→outcome AND still quic
   assert.equal(s.seen.dispatch.length, 0, "no session spawned for a rung-0 reply");
 });
 
+test("LADDER: a plain short question DM FAST-PATHS — quick-replies WITHOUT a classifier call", async () => {
+  const item = dm({ id: "MSG-DM-FAST", raw_ref: "slack:D91:1", channel_id: "D91", content: "what's the deadline?" });
+  writeLive(item, "slack");
+  const s = spy(RESPOND);
+  await daemon.processItem(item, "slack", s.deps);
+
+  // The whole point: the ~5-8s Haiku classify call is SKIPPED for a plain question.
+  assert.equal(s.seen.classify, 0, "fast-path: a plain directed question skips the classifier");
+  // ...but the DM is still answered via the quick-reply path, still journalled.
+  assert.deepEqual(s.seen.quick, [{ id: "MSG-DM-FAST", rung: 0 }], "the quick reply still went out at rung 0");
+  assert.equal(s.seen.dispatch.length, 0, "no session spawned");
+  assert.ok(decisions().some((r) => r.surface === "dm" && r.disposition === "react_now"), "still journalled intake→route→outcome");
+});
+
 // ---------------------------------------------------------------------------
 // 2) A board task is WORK: it queues, and never reaches the classifier.
 // ---------------------------------------------------------------------------

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