@cohortapp/agent-sdk 2.11.6 → 2.11.8

package/package.json

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

@@ -84,7 +84,7 @@ const RUNG_MECHANISM = Object.fromEntries(RUNGS.map((r) => [r.id, r.mechanism]))
 // work and land it in the org's shared, ACL'd store so the fleet's memory
 // compounds. Fail-open + best-effort — never blocks or throws into the hot path;
 // local SQLite/interaction logs remain the fail-open cache.
-import { isEnabled as orgEnabled, loadOrgConfig, configFromAgent, electResponder } from "../../lib/org/client.mjs";
+import { isEnabled as orgEnabled, loadOrgConfig, configFromAgent, electResponder, fetchSelfProfile } from "../../lib/org/client.mjs";
 import { remember as orgRemember } from "../../lib/org/knowledge.mjs";
 import { sweepSessionOutcomes, resultTextFromStdout } from "./session-outcomes.mjs";
 import { recordWorkStep as orgRecordWorkStep, cohortChannelId, cohortMessageId } from "../../lib/org/work-ledger.mjs";
@@ -1085,8 +1085,83 @@ export function _resetLadderCaches() {
   _ladderDisabledWarned = false;
 }
 
+// The seat's own member id (cuid), resolved once. This is the `actor` on every
+// message/event the seat sends, so the own-echo guard needs it — NOT the slug
+// (e.g. "A016"), which never matches a cuid actor. COHORT_AGENT_ID is a slug, so
+// using it as `me` (the old behaviour) left own-echo permanently broken: the seat
+// re-ingested its own replies and held a conversation with itself.
+let _selfMemberId = null;
+
+/** Read a previously-persisted memberId (cuid) from config/agent.json. */
+function persistedSelfMemberId() {
+  try {
+    const c = JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config", "agent.json"), "utf-8"));
+    const mid = c && typeof c.memberId === "string" ? c.memberId : "";
+    // Guard against a slug ever being persisted here — the field MUST be a cuid.
+    return mid && mid !== process.env.COHORT_AGENT_ID ? mid : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Resolve + cache the seat's own member cuid via /whoami (org/members/<slug>),
+ * persisting it to config/agent.json so subsequent boots — and every own-echo
+ * check — have it instantly. Best-effort and idempotent; safe to await on the
+ * hot path (cached after the first success). Requires hq to expose `memberId`
+ * on the profile DTO (org-api whoami/members).
+ */
+export async function resolveSelfMemberId(deps = {}) {
+  if (_selfMemberId) return _selfMemberId;
+  const fromDisk = persistedSelfMemberId();
+  if (fromDisk) { _selfMemberId = fromDisk; return _selfMemberId; }
+  try {
+    const cfg = daemonOrgCfg();
+    const conn = configFromAgent(cfg) || {};
+    // 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 ||
+      (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, 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 {
+        const cfgPath = join(AGENT_REPO_DIR, "config", "agent.json");
+        const c = JSON.parse(readFileSync(cfgPath, "utf-8"));
+        c.memberId = mid;
+        writeFileSync(cfgPath, JSON.stringify(c, null, 2) + "\n");
+      } catch { /* best-effort persist — resolution still cached in-memory */ }
+    }
+  } catch { /* best-effort — falls back to slug until hq exposes memberId */ }
+  return _selfMemberId;
+}
+
+/** For tests: reset the cached self member id. */
+export function _resetSelfMemberId() { _selfMemberId = null; }
+
 /** The seat's org member id — the `me` every directedness join is relative to. */
 function ladderMemberId() {
+  // Prefer the resolved member cuid (the actor on events). Fall back to the slug
+  // only until resolution completes — the slug can't power own-echo, but it is no
+  // worse than the historical behaviour.
+  if (_selfMemberId) return _selfMemberId;
+  const disk = persistedSelfMemberId();
+  if (disk) { _selfMemberId = disk; return disk; }
   const cfg = daemonOrgCfg();
   return (
     process.env.COHORT_AGENT_ID ||
@@ -1315,6 +1390,10 @@ export async function runExecutionLadder(item, service, itemId, trace_id, deps =
 
   let answered = null;
   try {
+    // Ensure the seat's own member cuid is resolved BEFORE directedness runs, so
+    // the own-echo guard can recognize this seat's own messages (the actor on an
+    // event is a cuid, not the slug). Cached after the first resolve.
+    await resolveSelfMemberId(deps);
     const me = ladderMemberId();
     const obligations = await ladderObligations(log);
 

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;
+  }
+});