@cohortapp/agent-sdk 2.17.0 → 2.18.4

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

@@ -1,221 +0,0 @@
-/**
- * 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, deriveRouterItem } from "./responder.mjs";
-import { routingKey } from "./lib/session-router.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 roomless surface never asks messaging.history for its LABEL", async () => {
-  // A board / doc / decision item has a blank `channel_id` by design and its
-  // `channel` is the human label (`task/<title>`). This used to fall back to
-  // that label, so the history read asked hq for a channel named after a task
-  // title and got nothing — the same label-for-an-id substitution that had the
-  // REPLY posted to a task title. The entity's own thread already rides on the
-  // item as `thread_context`, so there is nothing to fetch here.
-  const seen = [];
-  const text = await loadConversationHistory(
-    { sender: "Dana Okafor", service: "cohort", kind: "task_comment", channel: "task/Roll out tier-3 guardrails", channel_id: "", content: "?" },
-    { fetchHistory: async (params) => { seen.push(params); return []; }, loadOrgConfig: () => ({}) },
-  );
-  assert.equal(seen.length, 0, "no history call may be made with a label");
-  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", channel_id: "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", channel_id: "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");
-});
-
-// ---------------------------------------------------------------------------
-// Session continuity: the responder's router adapter (design §3 R10)
-//
-// `deriveRouterItem` returned null for `cohort`, so every Cohort turn fell back
-// to a fresh pre-minted UUID and the session router — which exists, and which
-// Slack and Gmail have used all along — never saw the one surface the owner
-// actually uses.
-// ---------------------------------------------------------------------------
-
-test("deriveRouterItem keys a Cohort item on its room, so a follow-up can resume", () => {
-  const out = deriveRouterItem(cohortItem);
-  assert.deepEqual(out, {
-    source: "cohort",
-    channel: "cmql1802601iihhzpf774vwbk",
-    thread_root_id: null,
-  });
-  assert.equal(routingKey(out), "cohort:cmql1802601iihhzpf774vwbk");
-});
-
-test("deriveRouterItem narrows to the thread when there is one", () => {
-  const out = deriveRouterItem({ ...cohortItem, thread_id: "root-42" });
-  assert.equal(routingKey(out), "cohort:cmql1802601iihhzpf774vwbk:root-42");
-});
-
-test("deriveRouterItem refuses the display label as a key", () => {
-  // `task/<title>` and `doc/<name>` are labels; two rooms can share one.
-  assert.equal(deriveRouterItem({ sender: "Dana", service: "cohort", channel: "task/Ship the thing" }), null);
-});
-
-test("deriveRouterItem still keys slack, gmail and calendar exactly as before", () => {
-  assert.equal(routingKey(deriveRouterItem({ service: "slack", channel: "D099", thread_id: null })), "slack:D099");
-  assert.equal(routingKey(deriveRouterItem({ service: "gmail", thread_id: "t-1" })), "gmail:t-1");
-  assert.equal(routingKey(deriveRouterItem({ service: "calendar", event_id: "e-1" })), "calendar:e-1");
-});

package/scripts/daemon/sdk-version.test.mjs

@@ -1,31 +0,0 @@
-/**
- * sdk-version.test.mjs — the daemon's own-version resolution prefers the
- * version of the COPIED tree (the manifest) over node_modules.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveRunningSdkVersion, SDK_PACKAGE } from "./sdk-version.mjs";
-
-function reader(files) {
-  return (p) => { if (p in files) return files[p]; throw new Error(`ENOENT ${p}`); };
-}
-const A = "/seat/ivy-ai";
-const MANIFEST = `${A}/.maestro/shipped-manifest.json`;
-const DEP = `${A}/node_modules/@cohortapp/agent-sdk/package.json`;
-const OWN = "/sdk/package.json";
-
-test("the manifest's sdkVersion wins: node_modules may already hold the NEXT version while the copied scripts are still the old one", () => {
-  const r = resolveRunningSdkVersion({ agentDir: A, ownPackagePath: OWN, readJson: reader({
-    [MANIFEST]: { version: 1, sdkVersion: "2.11.17" },
-    [DEP]: { name: SDK_PACKAGE, version: "2.12.0" },
-  }) });
-  assert.deepEqual(r, { version: "2.11.17", source: "manifest" });
-});
-
-test("a pre-2.12 manifest (no sdkVersion) or none → node_modules; then the package this file ships in; then empty", () => {
-  assert.deepEqual(resolveRunningSdkVersion({ agentDir: A, readJson: reader({ [MANIFEST]: { version: 1, files: [] }, [DEP]: { name: SDK_PACKAGE, version: "2.11.15" } }) }), { version: "2.11.15", source: "node_modules" });
-  assert.deepEqual(resolveRunningSdkVersion({ agentDir: A, ownPackagePath: OWN, readJson: reader({ [OWN]: { name: SDK_PACKAGE, version: "2.12.0" } }) }), { version: "2.12.0", source: "package" });
-  assert.deepEqual(resolveRunningSdkVersion({ agentDir: A, ownPackagePath: OWN, readJson: reader({ [OWN]: { name: "ivy-ai", version: "1.0.0" } }) }), { version: "", source: "none" }, "an agent's own package.json is not the SDK");
-  assert.deepEqual(resolveRunningSdkVersion({ agentDir: A, readJson: () => { throw new Error("EACCES"); } }), { version: "", source: "none" }, "fail-open");
-});

package/scripts/daemon/session-lock.test.mjs

@@ -1,252 +0,0 @@
-#!/usr/bin/env node
-/**
- * test-session-lock.mjs — Tests for file-based session locks and sent-message registry
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-import { join } from "path";
-
-// Tests use a temporary directory to avoid polluting real state
-const TEST_DIR = join(import.meta.dirname, "../../.test-session-locks");
-const LOCKS_DIR = join(TEST_DIR, "locks");
-const REGISTRY_PATH = join(TEST_DIR, "sent-registry.jsonl");
-
-// We'll set these env vars so the module uses our test paths
-process.env.__TEST_SESSION_DIR = TEST_DIR;
-
-const {
-  sanitiseItemId,
-  acquireLock,
-  releaseLock,
-  updateLock,
-  readLock,
-  scanStaleLocks,
-  checkRecentlySent,
-  registerSent,
-} = await import("./session-lock.mjs");
-
-// ─── sanitiseItemId ─────────────────────────────────────────────
-
-describe("sanitiseItemId", () => {
-  it("replaces colons and dots with hyphens", () => {
-    assert.equal(
-      sanitiseItemId("slack:D099N1JGKRQ:1775331885.690669"),
-      "slack-D099N1JGKRQ-1775331885-690669"
-    );
-  });
-
-  it("handles simple alphanumeric IDs unchanged", () => {
-    assert.equal(sanitiseItemId("abc123"), "abc123");
-  });
-
-  it("replaces spaces and special chars", () => {
-    assert.equal(sanitiseItemId("foo bar/baz@qux"), "foo-bar-baz-qux");
-  });
-});
-
-// ─── acquireLock / releaseLock / readLock ────────────────────────
-
-describe("acquireLock / releaseLock / readLock", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("acquires a lock on first call", () => {
-    const result = acquireLock("test-item-1", { sender: "Alice", channel: "C001" });
-    assert.equal(result.acquired, true);
-    assert.equal(existsSync(join(LOCKS_DIR, "test-item-1.lock")), true);
-  });
-
-  it("rejects second acquire for same item", () => {
-    acquireLock("test-item-2", { sender: "Alice", channel: "C001" });
-    const result = acquireLock("test-item-2", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, false);
-    assert.ok(result.existing);
-    assert.equal(result.existing.sender, "Alice");
-  });
-
-  it("allows acquire after release", () => {
-    acquireLock("test-item-3", { sender: "Alice", channel: "C001" });
-    releaseLock("test-item-3");
-    const result = acquireLock("test-item-3", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, true);
-  });
-
-  it("readLock returns lock data when locked", () => {
-    acquireLock("test-item-4", { sender: "Alice", channel: "C001" });
-    const data = readLock("test-item-4");
-    assert.equal(data.sender, "Alice");
-    assert.equal(data.channel, "C001");
-    assert.equal(data.holdingSent, false);
-    assert.equal(data.substantiveSent, false);
-  });
-
-  it("readLock returns null when no lock", () => {
-    const data = readLock("nonexistent-item");
-    assert.equal(data, null);
-  });
-
-  it("overwrites stale lock (older than STALE_LOCK_MS)", () => {
-    // Write a lock older than STALE_LOCK_MS (2h — raised from 15min so it
-    // exceeds the longest inbox/Opus session and survives daemon restarts;
-    // see session-lock.mjs). A 3h-old lock is unambiguously stale.
-    const lockPath = join(LOCKS_DIR, "test-item-5.lock");
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    const staleLock = {
-      sessionId: "old-session",
-      itemId: "test-item-5",
-      sender: "Alice",
-      channel: "C001",
-      acquiredAt: new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString(),
-      holdingSent: false,
-      substantiveSent: false,
-    };
-    writeFileSync(lockPath, JSON.stringify(staleLock));
-
-    const result = acquireLock("test-item-5", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, true);
-    const data = readLock("test-item-5");
-    assert.equal(data.sender, "Bob");
-  });
-
-  it("does NOT overwrite a fresh lock younger than STALE_LOCK_MS", () => {
-    // 20 min old: well within the 2h freshness window, so a re-acquire must be
-    // denied (this is the behaviour the old ">15 min" test wrongly assumed
-    // would expire). Guards against any future shortening of STALE_LOCK_MS that
-    // would re-introduce the mid-session triple-dispatch incident.
-    const lockPath = join(LOCKS_DIR, "test-item-5b.lock");
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    writeFileSync(lockPath, JSON.stringify({
-      sessionId: "live-session", itemId: "test-item-5b", sender: "Alice", channel: "C001",
-      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
-      holdingSent: false, substantiveSent: false,
-    }));
-    const result = acquireLock("test-item-5b", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, false, "a 20-min-old lock is still fresh under the 2h window");
-    assert.equal(readLock("test-item-5b").sender, "Alice", "the live lock is preserved");
-  });
-});
-
-// ─── updateLock ─────────────────────────────────────────────────
-
-describe("updateLock", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("updates holdingSent flag on existing lock", () => {
-    acquireLock("test-item-6", { sender: "Alice", channel: "C001" });
-    updateLock("test-item-6", { holdingSent: true });
-    const data = readLock("test-item-6");
-    assert.equal(data.holdingSent, true);
-    assert.equal(data.substantiveSent, false);
-  });
-
-  it("no-ops when lock does not exist", () => {
-    // Should not throw
-    updateLock("nonexistent", { holdingSent: true });
-  });
-});
-
-// ─── scanStaleLocks ─────────────────────────────────────────────
-
-describe("scanStaleLocks", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("clears stale locks and leaves fresh ones", () => {
-    // Fresh lock
-    acquireLock("fresh-item", { sender: "Alice", channel: "C001" });
-
-    // Stale lock — older than STALE_LOCK_MS (2h). 3h ago is unambiguously
-    // stale. (The old fixture used 20min, which the raised threshold no longer
-    // treats as stale.)
-    const stalePath = join(LOCKS_DIR, "stale-item.lock");
-    writeFileSync(stalePath, JSON.stringify({
-      sessionId: "old", itemId: "stale-item", sender: "Bob", channel: "C002",
-      acquiredAt: new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString(),
-      holdingSent: false, substantiveSent: false,
-    }));
-
-    const cleared = scanStaleLocks();
-    assert.equal(cleared, 1);
-    assert.equal(existsSync(join(LOCKS_DIR, "fresh-item.lock")), true);
-    assert.equal(existsSync(stalePath), false);
-  });
-});
-
-// ─── sent-message registry ──────────────────────────────────────
-
-describe("sent-message registry", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    // Ensure clean registry
-    try { unlinkSync(REGISTRY_PATH); } catch {}
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("allows first send to a channel", () => {
-    const result = checkRecentlySent("C001", "1234.5678", "holding");
-    assert.equal(result.allowed, true);
-  });
-
-  it("blocks duplicate send to same channel+thread+type within window", () => {
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C001", "1234.5678", "holding");
-    assert.equal(result.allowed, false);
-    assert.ok(result.reason.includes("duplicate"));
-  });
-
-  it("blocks a different type to the same channel+thread (thread cooldown — Rule 2)", () => {
-    // Rule 2 deliberately blocks ANY type within the same channel+thread window
-    // (not just same-type). This prevents cascading replies when one thread is
-    // re-ingested across poll cycles as different message types. (The original
-    // expectation — "different type is allowed" — predated Rule 2 and was a
-    // stale assertion; the product intentionally cools down the whole thread.)
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C001", "1234.5678", "substantive");
-    assert.equal(result.allowed, false);
-    assert.match(result.reason, /thread cooldown/);
-  });
-
-  it("allows a different type to the same NON-threaded channel (no thread cooldown)", () => {
-    // With threadTs=null there is no thread to cool down, so Rule 1 (same
-    // channel+thread+TYPE) is the only same-channel gate — a different type is
-    // allowed. (Uses a non-DM channel so the DM channel-level dedup, Rule 0b,
-    // doesn't apply.)
-    registerSent("C010", null, "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C010", null, "substantive");
-    assert.equal(result.allowed, true);
-  });
-
-  it("allows same type to different channel", () => {
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C002", "1234.5678", "holding");
-    assert.equal(result.allowed, true);
-  });
-
-  it("blocks rapid substantive sends to same channel even with different threads", () => {
-    registerSent("C001", "1111.0000", "substantive", "s-1", "Here is the answer");
-    const result = checkRecentlySent("C001", "2222.0000", "substantive");
-    assert.equal(result.allowed, false);
-    assert.ok(result.reason.includes("rapid"));
-  });
-});