@cohortapp/agent-sdk 2.11.8 → 2.11.9

package/package.json

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