@cohortapp/agent-sdk 2.11.7 → 2.11.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.7",
+  "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
 // ---------------------------------------------------------------------------
@@ -1118,13 +1153,26 @@ export async function resolveSelfMemberId(deps = {}) {
   try {
     const cfg = daemonOrgCfg();
     const conn = configFromAgent(cfg) || {};
-    const apiKey = conn.apiKey || process.env.COHORT_API_KEY || "";
+    // configFromAgent returns the org key as `token` (NOT `apiKey`), and the
+    // daemon's creds come from config/org.yaml, not process.env — so read `token`
+    // first and only fall back to env. The slug lives at cfg.org.cohort.agentId
+    // (same source ladderMemberId used); without it fetchSelfProfile can't hit
+    // /members/<slug> and whoami is ambiguous in a multi-agent org.
+    const apiKey = conn.token || conn.apiKey || process.env.COHORT_API_KEY || "";
     const orgId = conn.orgId || process.env.COHORT_ORG_ID || "";
-    const agentId = conn.agentId || process.env.COHORT_AGENT_ID || "";
+    const agentId =
+      conn.agentId ||
+      (cfg && cfg.org && cfg.org.cohort && cfg.org.cohort.agentId) ||
+      process.env.COHORT_AGENT_ID ||
+      "";
+    const base = conn.base || process.env.COHORT_BASE || "";
     if (!apiKey || !orgId) return _selfMemberId;
     const fetchSelf = deps.fetchSelfProfileImpl || fetchSelfProfile;
-    const res = await fetchSelf({ base: conn.base, apiKey, orgId, agentId });
-    const mid = res && res.ok && res.member && res.member.memberId ? String(res.member.memberId) : "";
+    const res = await fetchSelf({ base, apiKey, orgId, agentId });
+    // fetchSelfProfile returns a res frame with the member under `result` (the
+    // authed call() shape); tolerate `member` too for the raw directory route.
+    const m = res && res.ok ? (res.result || res.member) : null;
+    const mid = m && m.memberId ? String(m.memberId) : "";
     if (mid) {
       _selfMemberId = mid;
       try {
@@ -2130,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/agent-daemon.test.mjs

@@ -830,3 +830,35 @@ test("NO FALLTHROUGH: a TRANSIENT quick-reply failure still falls through to a f
   assert.equal(dispatched, true, "a transient failure falls through to the full session, as before");
   assert.equal(res.path, "session");
 });
+
+test("resolveSelfMemberId reads the member cuid from the res frame's `result` (own-echo keystone)", async () => {
+  daemon._resetSelfMemberId();
+  const pk = process.env.COHORT_API_KEY, po = process.env.COHORT_ORG_ID, pa = process.env.COHORT_AGENT_ID;
+  process.env.COHORT_API_KEY = "nlk_test";
+  process.env.COHORT_ORG_ID = "org_test";
+  process.env.COHORT_AGENT_ID = "A016";
+  try {
+    let calls = 0;
+    // fetchSelfProfile returns the authed call() res frame: the member is under
+    // `result`, and the org key is passed as apiKey. (Both were wrong in 2.11.7.)
+    const mid = await daemon.resolveSelfMemberId({
+      fetchSelfProfileImpl: async (o) => {
+        calls++;
+        assert.equal(o.agentId, "A016", "must pass the slug so /members/<slug> resolves");
+        return { ok: true, result: { memberId: "cmSELFcuid", slug: o.agentId } };
+      },
+    });
+    assert.equal(mid, "cmSELFcuid");
+    // cached: a second call must NOT refetch
+    const again = await daemon.resolveSelfMemberId({
+      fetchSelfProfileImpl: async () => { throw new Error("must not refetch a cached self id"); },
+    });
+    assert.equal(again, "cmSELFcuid");
+    assert.equal(calls, 1);
+  } finally {
+    daemon._resetSelfMemberId();
+    if (pk === undefined) delete process.env.COHORT_API_KEY; else process.env.COHORT_API_KEY = pk;
+    if (po === undefined) delete process.env.COHORT_ORG_ID; else process.env.COHORT_ORG_ID = po;
+    if (pa === undefined) delete process.env.COHORT_AGENT_ID; else process.env.COHORT_AGENT_ID = pa;
+  }
+});