@cohortapp/agent-sdk 2.11.10 → 2.11.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.10",
+  "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.
 // ---------------------------------------------------------------------------