@cohortapp/agent-sdk 2.6.2 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "Cohort Agent SDK \u2014 autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/scripts/daemon/responder-history.test.mjs

@@ -0,0 +1,169 @@
+/**
+ * responder.test.mjs — conversation history behind holding messages / quick replies.
+ * Run: node --test scripts/daemon/responder.test.mjs
+ *
+ * `loadConversationHistory` used to build its candidate directories as
+ * `memory/interactions/slack/<id>` unconditionally, and its writer
+ * (`logInteraction`) early-returns for any service that is not Slack. A Cohort
+ * DM therefore had nothing written and nothing to read, so every holding
+ * message for Cohort was generated from the current message alone. A bare "?"
+ * produced "What's on your mind?" — indistinguishable from amnesia, and the
+ * CEO read it as exactly that (2026-08-13, dm-h001-a016).
+ *
+ * Cohort has an authoritative `messaging.history`. These tests pin that the
+ * cohort branch reads it, orders it oldest-first, and NEVER throws — the
+ * holding path must degrade to "no history" rather than take the send down.
+ */
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { loadConversationHistory } from "./responder.mjs";
+
+const cohortItem = {
+  sender: "Dana Okafor",
+  service: "cohort",
+  channel: "dm-h001-a016",
+  channel_id: "cmql1802601iihhzpf774vwbk",
+  content: "?",
+};
+
+// Newest-first, the way messaging.history actually returns it.
+const HISTORY = [
+  { id: "m3", createdAt: "2026-08-13T05:47:51Z", authorName: "Dana Okafor", body: "with that in mind, fix these issues you just noted please" },
+  { id: "m2", createdAt: "2026-08-12T13:52:53Z", authorName: "Isla Roselli", body: "Both are merged. #19 went in as 94f227c4." },
+  { id: "m1", createdAt: "2026-08-12T13:47:30Z", authorName: "Dana Okafor", body: "why haven't you merged? please go ahead" },
+];
+
+test("cohort: reads messaging.history and renders it oldest-first", async () => {
+  const seen = [];
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async (params, o) => {
+      seen.push({ params, hasCfg: Boolean(o && o.cfg) });
+      return HISTORY;
+    },
+    loadOrgConfig: () => ({ org: { cohort: { enabled: true, base: "https://x", token: "t" } } }),
+  });
+
+  assert.ok(text, "expected a transcript, got null");
+  assert.match(text, /Dana Okafor: why haven't you merged/);
+  assert.match(text, /Isla Roselli: Both are merged/);
+  assert.match(text, /Dana Okafor: with that in mind/);
+
+  // Oldest-first: the model reads a conversation, not a reversed one.
+  assert.ok(
+    text.indexOf("why haven't you merged") < text.indexOf("with that in mind"),
+    "history must be rendered oldest-first",
+  );
+
+  // The channel it asks for is the item's channel_id, and cfg is ALWAYS passed:
+  // fetchHistory() fails open to [] when cfg is omitted, which is silently
+  // indistinguishable from an empty channel. That is the bug this file exists for.
+  assert.equal(seen.length, 1);
+  assert.equal(seen[0].params.channel, "cmql1802601iihhzpf774vwbk");
+  assert.equal(seen[0].hasCfg, true, "cfg must be passed or fetchHistory returns [] silently");
+});
+
+test("cohort: an empty channel is null, not an empty transcript", async () => {
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async () => [],
+    loadOrgConfig: () => ({}),
+  });
+  assert.equal(text, null);
+});
+
+test("cohort: a failing history call degrades to null and never throws", async () => {
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async () => { throw new Error("cohort unreachable"); },
+    loadOrgConfig: () => ({}),
+  });
+  assert.equal(text, null);
+});
+
+test("cohort: the current message is not fed back as its own history", async () => {
+  const text = await loadConversationHistory(
+    { ...cohortItem, message_id: "m3" },
+    {
+      fetchHistory: async () => HISTORY,
+      loadOrgConfig: () => ({}),
+    },
+  );
+  assert.ok(text);
+  assert.doesNotMatch(text, /with that in mind/, "the inbound message itself must be excluded");
+});
+
+test("slack: still reads the local interaction mirror", async () => {
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "slack", "D099N1JGKRQ");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    [
+      JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "Dana Okafor", content: "ship it" }),
+      JSON.stringify({ ts: "2026-08-13T05:01:00Z", from: "agent", content: "shipped" }),
+    ].join("\n"),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "slack", channel: "D099N1JGKRQ", content: "?" },
+    { agentRepoDir: root },
+  );
+
+  assert.ok(text, "expected the slack mirror to still be read");
+  assert.match(text, /Dana Okafor: ship it/);
+  assert.match(text, /agent: shipped/);
+});
+
+test("cohort: falls back to the local mirror when the server is unreachable", async () => {
+  // Isla's original returned null outright for Cohort when messaging.history
+  // failed. Falling through to the mirror means a transient API blip degrades
+  // to cached context instead of to none — the mirror is a poor source of
+  // truth but a perfectly good backstop.
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "cohort", "chan-1");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "Dana Okafor", content: "cached line" }),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    {
+      agentRepoDir: root,
+      loadOrgConfig: () => ({}),
+      fetchHistory: async () => { throw new Error("network down"); },
+    },
+  );
+
+  assert.ok(text, "a server failure must not erase locally cached context");
+  assert.match(text, /Dana Okafor: cached line/);
+});
+
+test("cohort: server history wins over the local mirror", async () => {
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "cohort", "chan-1");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "stale", content: "outdated mirror line" }),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    {
+      agentRepoDir: root,
+      loadOrgConfig: () => ({}),
+      fetchHistory: async () => ([
+        { id: "m2", authorName: "Dana Okafor", body: "authoritative line", createdAt: "2026-08-13T06:00:00Z" },
+      ]),
+    },
+  );
+
+  assert.match(text, /authoritative line/, "the server is the source of truth");
+  assert.doesNotMatch(text, /outdated mirror line/, "the stale mirror must not be mixed in");
+});

package/scripts/daemon/responder.mjs

@@ -523,23 +523,105 @@ function loadUserProfile(sender) {
 // Load recent conversation history for context
 // ---------------------------------------------------------------------------
 
+/** Cohort's message ids as this item carries them, so history can drop itself. */
+function inboundMessageIds(item) {
+  const ids = new Set();
+  const add = (v) => { if (v) ids.add(String(v)); };
+  add(item.message_id);
+  // Inbox filenames prefix the service: "cohort-cmsr45u91…" → "cmsr45u91…".
+  if (item.id) { add(item.id); add(String(item.id).replace(/^[a-z]+-/, "")); }
+  // raw_ref is "cohort:dm:<messageId>:<seq>".
+  const m = typeof item.raw_ref === "string" ? item.raw_ref.match(/^cohort:[^:]+:([^:]+)/) : null;
+  if (m) add(m[1]);
+  return ids;
+}
+
+const COHORT_HISTORY_LIMIT = 12;
+const COHORT_HISTORY_CHARS = 400;
+
+/**
+ * Cohort history straight from the server, via the same `messaging.history` the
+ * replies are posted to.
+ *
+ * The local mirror below is a cache the agent populates itself, so it carries
+ * context only if the agent has already been talking AND logging correctly.
+ * When the write half broke (logInteraction early-returned for every non-Slack
+ * service), the read half silently returned nothing, memory/interactions/ was
+ * never even created, and holding messages were composed from the inbound
+ * message alone — a bare "?" came back as "What's on your mind?" mid-thread.
+ *
+ * Asking the authority that stores the message removes that coupling: a fresh
+ * agent, or one whose mirror was wiped, still answers with full context.
+ *
+ * Fails open to null on every path. No amount of history is worth failing a send.
+ */
+async function loadCohortHistory(item, deps = {}) {
+  const channel = item.channel_id || item.channel || "";
+  if (!channel) return null;
+
+  try {
+    const fetchHistory = deps.fetchHistory
+      || (await import("../../lib/org/messaging.mjs")).fetchHistory;
+    const loadOrgConfig = deps.loadOrgConfig
+      || (await import("../../lib/org/client.mjs")).loadOrgConfig;
+    const agentRoot = deps.agentRepoDir || process.env.AGENT_ROOT || process.env.AGENT_DIR || AGENT_REPO_DIR;
+
+    // cfg is mandatory. configFromAgent() reads base+token ONLY from the object
+    // handed in — it never loads config/org.yaml — so omitting it returns a
+    // fail-open [] that looks exactly like an empty channel.
+    const messages = await fetchHistory(
+      { channel, limit: COHORT_HISTORY_LIMIT + 1 },
+      { cfg: loadOrgConfig(agentRoot), agentRoot },
+    );
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+
+    const self = inboundMessageIds(item);
+    const rows = messages
+      .filter((m) => m && !self.has(String(m.id)))
+      .slice(0, COHORT_HISTORY_LIMIT)
+      .reverse() // messaging.history is newest-first; a conversation reads the other way
+      .map((m) => {
+        const from = m.authorName || m.author?.name || m.authorId || "unknown";
+        const text = String(m.body ?? m.content ?? "").trim();
+        return `[${m.createdAt || ""}] ${from}: ${text.substring(0, COHORT_HISTORY_CHARS)}`;
+      });
+
+    return rows.length > 0 ? rows.join("\n") : null;
+  } catch (err) {
+    console.warn(`[responder] cohort history unavailable for ${item.sender}: ${err.message}`);
+    return null;
+  }
+}
+
 /**
  * The reader half of `logInteraction`. It looked ONLY under
  * `memory/interactions/slack/…`, so even once a Cohort exchange was written it
  * would not have been found. Both halves are now keyed on the item's service.
+ *
+ * Cohort asks the server first (see loadCohortHistory) and falls back to the
+ * local mirror, so a transient API failure degrades to cached context rather
+ * than to none.
  */
-function loadConversationHistory(item) {
+export async function loadConversationHistory(item, deps = {}) {
   if (!item || !item.sender || !item.service) return null;
 
   const service = String(item.service);
+
+  if (service === "cohort") {
+    const remote = await loadCohortHistory(item, deps);
+    if (remote) return remote;
+  }
+  // Test seam: the mirror's location is a parameter, so a test can point at a
+  // tmpdir instead of mutating process.env for the whole worker.
+  const repoDir = deps.agentRepoDir || AGENT_REPO_DIR;
   const senderSlug = item.sender.replace(/\s+/g, "-").toLowerCase();
   const channelId = service === "slack"
     ? resolveSlackChannel(item)
     : (item.channel_id || item.channel || null);
 
   const candidateDirs = [];
-  if (channelId) candidateDirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, String(channelId)));
-  candidateDirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, `dm-${senderSlug}`));
+  if (channelId) candidateDirs.push(join(repoDir, "memory", "interactions", service, String(channelId)));
+  candidateDirs.push(join(repoDir, "memory", "interactions", service, `dm-${senderSlug}`));
 
   const entries = [];
   for (const dir of candidateDirs) {
@@ -621,7 +703,7 @@ Keep responses focused — 1-4 sentences for simple items, up to a short paragra
 Match the sender's tone and urgency level.
 ${profile ? `\nSender profile:\n${profile}` : ""}`;
 
-  const conversationHistory = loadConversationHistory(item);
+  const conversationHistory = await loadConversationHistory(item);
 
   const userContent = [
     `From: ${item.sender} (${item.sender_privilege || "unknown"})`,