@cohortapp/agent-sdk 2.3.0

package/scripts/daemon/context-compiler.test.mjs

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/**
+ * test-context-compiler.mjs — Tests for context-compiler.mjs
+ *
+ * Uses node:test and node:assert/strict.
+ * Test directory: .test-context-compiler via process.env.__TEST_SOPHIE_DIR
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// ── Set up test environment BEFORE importing the module ────────────
+
+const TEST_DIR = join(tmpdir(), ".test-context-compiler-" + process.pid);
+// context-compiler.mjs reads its repo root from __TEST_AGENT_DIR (the legacy
+// __TEST_SOPHIE_DIR name this harness used was never honoured by the module, so
+// every profile/history/policy fixture was written to the test dir but read
+// from the real repo — the cause of the disclosure-filter failures). Point the
+// module at our fixtures via the env var it actually reads.
+process.env.__TEST_AGENT_DIR = TEST_DIR;
+process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
+
+// Dynamic import AFTER env vars are set (ESM module caching is fine)
+const { compileContext } = await import("./context-compiler.mjs");
+
+// ── Test fixtures ──────────────────────────────────────────────────
+
+const BARRIERS_YAML = `domains:
+  internal-legal:
+    description: "Northwind's own legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  strategic-initiative:
+    description: "the strategic initiative M&A targets, deal terms, pipeline"
+    default_sensitivity: critical
+  partner-operations:
+    description: "PartnerCo JV operational matters shared domain"
+    default_sensitivity: low
+  public:
+    description: "Published information, press, website no restrictions"
+    default_sensitivity: none
+`;
+
+function setupTestDir() {
+  // Create directory structure
+  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "D001TESTCH"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "state", "sessions"), { recursive: true });
+
+  // Write barriers policy
+  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), BARRIERS_YAML);
+
+  // Write empty active.json
+  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
+}
+
+function teardownTestDir() {
+  try {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  } catch { /* ignore */ }
+}
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe("context-compiler", () => {
+  beforeEach(() => {
+    setupTestDir();
+  });
+
+  afterEach(() => {
+    teardownTestDir();
+  });
+
+  // 1. Token budget adapts to priority
+  it("token budget adapts to priority", async () => {
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+
+    const critical = await compileContext(item, { priority: "critical" });
+    assert.ok(critical.tokenBudget >= 12000, `critical budget should be >= 12000, got ${critical.tokenBudget}`);
+
+    const normal = await compileContext(item, { priority: "normal" });
+    assert.ok(normal.tokenBudget >= 8000 && normal.tokenBudget < 12000,
+      `normal budget should be 8000-11999, got ${normal.tokenBudget}`);
+
+    const low = await compileContext(item, { priority: "low" });
+    assert.ok(low.tokenBudget >= 4000 && low.tokenBudget < 8000,
+      `low budget should be 4000-7999, got ${low.tokenBudget}`);
+  });
+
+  // 2. Includes sender profile when available
+  it("includes sender profile when available", async () => {
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Sender Profile"), "should include Sender Profile header");
+    assert.ok(result.contextBlock.includes("Alice Smith"), "should include the sender name");
+  });
+
+  // 3. Produces minimal block when no profile exists
+  it("produces minimal block when no profile exists", async () => {
+    const item = { sender: "unknown-person", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("--- COMPILED CONTEXT"), "should include COMPILED CONTEXT marker");
+    assert.ok(result.contextBlock.includes("--- END CONTEXT ---"), "should include END CONTEXT marker");
+    // Should not crash — that's the main test
+    assert.ok(result.tokenBudget > 0, "should have a positive token budget");
+  });
+
+  // 4. Filters history by disclosure boundaries
+  it("filters history by disclosure boundaries", async () => {
+    // Profile with excluded_domains
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+information_boundaries:
+  excluded_domains:
+    - strategic-initiative
+    - internal-legal
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    // History entries — 4 messages
+    const history = [
+      JSON.stringify({ ts: "1001", from: "robin", content: "PartnerCo project update: everything on track for Q2 delivery", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "1002", from: "alex", content: "the strategic initiative acquisition target list needs review of deal terms and pipeline", received_at: "2026-04-06T10:01:00Z" }),
+      JSON.stringify({ ts: "1003", from: "robin", content: "PartnerCo operations dashboard is looking good this week", received_at: "2026-04-06T10:02:00Z" }),
+      JSON.stringify({ ts: "1004", from: "nima", content: "GC advice on legal strategy is privileged under Northwind internal counsel", received_at: "2026-04-06T10:03:00Z" }),
+    ].join("\n");
+
+    writeFileSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith", "2026-04-06.jsonl"), history);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    // Safe entries should be included
+    assert.ok(result.contextBlock.includes("PartnerCo project update"), "should include safe PartnerCo project entry");
+    assert.ok(result.contextBlock.includes("PartnerCo operations dashboard"), "should include safe PartnerCo operations entry");
+
+    // Forbidden entries should be excluded. (The old assertion checked for
+    // "Aether" — a codename that never appears in the fixture — so it was a
+    // tautology; assert against the actual strategic-initiative text instead.)
+    assert.ok(!result.contextBlock.includes("acquisition target list"), "should NOT include strategic-initiative content");
+    assert.ok(!result.contextBlock.includes("legal strategy is privileged"), "should NOT include legal content");
+  });
+
+  // 5. Includes disclosure boundaries block with restrictions
+  it("includes disclosure boundaries block with restrictions", async () => {
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+information_boundaries:
+  excluded_domains:
+    - strategic-initiative
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Disclosure Boundaries"), "should include Disclosure Boundaries header");
+    assert.ok(result.contextBlock.includes("DO NOT mention"), "should include DO NOT mention instruction");
+  });
+
+  // 6. Includes active sessions when present
+  it("includes active sessions when present", async () => {
+    const activeSessions = {
+      "sess-001": {
+        sessionId: "sess-001",
+        summary: "Processing hiring pipeline review",
+        model: "sonnet",
+        sender: "alex-chen",
+        startTime: new Date().toISOString(),
+      },
+    };
+    writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), JSON.stringify(activeSessions));
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Active Sessions"), "should include Active Sessions header");
+    assert.ok(result.contextBlock.includes("Processing hiring pipeline review"), "should include session summary");
+  });
+
+  // 7. Includes sent-registry entries for same channel
+  it("includes sent-registry entries for same channel", async () => {
+    const registryEntry = JSON.stringify({
+      timestamp: "2026-04-06T09:00:00Z",
+      channelId: "D001TESTCH",
+      type: "reply",
+      preview: "I'll get back to you on the hiring update shortly",
+    });
+    writeFileSync(join(TEST_DIR, "state", "sessions", "sent-registry.jsonl"), registryEntry + "\n");
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Already Sent"), "should include Already Sent header");
+    assert.ok(result.contextBlock.includes("hiring update shortly"), "should include sent message preview");
+  });
+
+  // 7b. Injects org shared memory when the integration is enabled
+  it("injects org shared memory when the org integration is enabled", async () => {
+    const enabledCfg = { org: { cohort: { enabled: true, base: "https://org.example" } } };
+    const seen = [];
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH", subject: "Acme renewal" };
+    const result = await compileContext(item, { priority: "normal", summary: "Acme Q2 renewal" }, {
+      orgCfg: enabledCfg,
+      orgRecall: async (query, opts) => {
+        seen.push({ query, opts });
+        return [
+          { id: "k1", text: "Acme's renewal was flagged at-risk last quarter" },
+          "The Acme account owner is Robin",
+        ];
+      },
+    });
+
+    assert.ok(result.contextBlock.includes("Org Shared Memory"), "should include the Org Shared Memory header");
+    assert.ok(result.contextBlock.includes("renewal was flagged at-risk"), "should render an object fact");
+    assert.ok(result.contextBlock.includes("The Acme account owner is Robin"), "should render a string fact");
+    assert.ok(result.contextBlock.includes("[k1]"), "should surface the fact id when present");
+    assert.equal(seen.length, 1, "recall should be called exactly once per context build");
+    assert.ok(seen[0].query.includes("Acme"), "recall query derives from summary/subject");
+  });
+
+  // 7c. Omits org shared memory when disabled — and never calls recall
+  it("omits org shared memory when the integration is disabled", async () => {
+    let called = false;
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH", subject: "Acme renewal" };
+    const result = await compileContext(item, { priority: "normal", summary: "Acme Q2 renewal" }, {
+      orgCfg: {}, // disabled
+      orgRecall: async () => { called = true; return [{ text: "should not appear" }]; },
+    });
+
+    assert.ok(!result.contextBlock.includes("Org Shared Memory"), "should not include org memory header when disabled");
+    assert.ok(!result.contextBlock.includes("should not appear"), "should not render recall output when disabled");
+    assert.equal(called, false, "recall must not be called when the integration is disabled");
+  });
+
+  // 7d. Fail-open: a throwing recall does not break the compiled context
+  it("is fail-open when org recall throws", async () => {
+    const enabledCfg = { org: { cohort: { enabled: true, base: "https://org.example" } } };
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH", subject: "Acme renewal" };
+    const result = await compileContext(item, { priority: "normal", summary: "Acme" }, {
+      orgCfg: enabledCfg,
+      orgRecall: async () => { throw new Error("org server unreachable"); },
+    });
+
+    assert.ok(result.contextBlock.includes("--- COMPILED CONTEXT"), "context still builds");
+    assert.ok(!result.contextBlock.includes("Org Shared Memory"), "no org memory section on failure");
+    assert.ok(result.tokenBudget > 0, "still returns a valid budget");
+  });
+
+  // 8. CEO gets all domains — no filtering
+  it("CEO gets all domains — no filtering", async () => {
+    const profileYaml = `name: Alex Chen
+slug: alex-chen
+role: CEO
+privilege_level: ceo
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alex-chen.yaml"), profileYaml);
+
+    // History with rollup and legal content
+    const history = [
+      JSON.stringify({ ts: "2001", from: "robin", content: "the strategic initiative acquisition target list has nine deal terms in the pipeline", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "2002", from: "nima", content: "GC advice on legal strategy is privileged under internal counsel review", received_at: "2026-04-06T10:01:00Z" }),
+      JSON.stringify({ ts: "2003", from: "robin", content: "PartnerCo operations are on track", received_at: "2026-04-06T10:02:00Z" }),
+    ].join("\n");
+
+    mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alex-chen"), { recursive: true });
+    writeFileSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alex-chen", "2026-04-06.jsonl"), history);
+
+    const item = { sender: "alex-chen", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "critical" });
+
+    // ALL content should appear for CEO. (The old assertion checked for
+    // "Aether acquisition target" — absent from the fixture text "the strategic
+    // initiative acquisition target list …" — so it failed even though the CEO
+    // correctly sees everything. Assert against the actual fixture text.)
+    assert.ok(result.contextBlock.includes("acquisition target list"), "CEO should see strategic-initiative content");
+    assert.ok(result.contextBlock.includes("legal strategy is privileged"), "CEO should see legal content");
+    assert.ok(result.contextBlock.includes("PartnerCo operations"), "CEO should see PartnerCo content");
+
+    // No disclosure boundaries block for CEO
+    assert.ok(!result.contextBlock.includes("DO NOT mention"), "CEO should NOT see DO NOT mention block");
+  });
+});

package/scripts/daemon/dispatcher-cooldown.test.mjs

@@ -0,0 +1,122 @@
+/**
+ * dispatcher-cooldown.test.mjs — Coverage for the backlog post-completion
+ * cooldown that stopped the 159-redundant-spawns-per-day loop.
+ *
+ * The dispatcher module is stateful (in-memory Sets/Maps for active
+ * sessions, retry counts, cooldowns) and reads from AGENT_DIR at import
+ * time, so each test isolates by setting AGENT_DIR before dynamic-importing
+ * a fresh module instance.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fsp } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+async function freshDispatcher() {
+  // Isolated tmpdir per test so cooldown state file doesn't bleed.
+  const dir = join(
+    tmpdir(),
+    `dispatcher-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  await fsp.mkdir(join(dir, "state/sessions"), { recursive: true });
+  await fsp.mkdir(join(dir, "logs/daemon"), { recursive: true });
+  process.env.AGENT_DIR = dir;
+  // Bust the module cache so state resets cleanly.
+  const url = new URL("./dispatcher.mjs", import.meta.url);
+  const mod = await import(`${url.href}?test=${Math.random()}`);
+  return { mod, dir };
+}
+
+async function cleanup(dir) {
+  try { await fsp.rm(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+test("canDispatchBacklog: allowed for a fresh item", async () => {
+  const { mod, dir } = await freshDispatcher();
+  try {
+    const r = mod.canDispatchBacklog({ id: "TEST-1", title: "Fresh item" });
+    assert.equal(r.allowed, true);
+  } finally { await cleanup(dir); }
+});
+
+test("canDispatchBacklog: blocked while cooldown is active", async () => {
+  const { mod, dir } = await freshDispatcher();
+  try {
+    // Simulate a session completion by directly writing the cooldown state
+    // file the dispatcher reads on init. We can't easily call internal
+    // setters, but the cooldown file IS public API for state persistence.
+    const cooldownPath = join(dir, "state/sessions/backlog-cooldowns.json");
+    const tomorrow = Date.now() + 60 * 60 * 1000; // +1h
+    await fsp.writeFile(cooldownPath, JSON.stringify({
+      "TEST-2": tomorrow,
+    }) + "\n");
+    // Re-import to load the cooldown file.
+    const { mod: mod2, dir: dir2 } = await freshDispatcher();
+    try {
+      // Plant the same cooldown in this fresh dispatcher's dir.
+      await fsp.writeFile(
+        join(dir2, "state/sessions/backlog-cooldowns.json"),
+        JSON.stringify({ "TEST-2": tomorrow }) + "\n"
+      );
+      // Reload yet again with the cooldown file present.
+      const { mod: mod3, dir: dir3 } = await freshDispatcher();
+      try {
+        await fsp.writeFile(
+          join(dir3, "state/sessions/backlog-cooldowns.json"),
+          JSON.stringify({ "TEST-2": tomorrow }) + "\n"
+        );
+        // Final import — this one reads the cooldown file at module load.
+        process.env.AGENT_DIR = dir3;
+        const url = new URL("./dispatcher.mjs", import.meta.url);
+        const final = await import(`${url.href}?cooldown=${Math.random()}`);
+        const r = final.canDispatchBacklog({ id: "TEST-2", title: "Cooldown item" });
+        assert.equal(r.allowed, false);
+        assert.equal(r.reason, "post_completion_cooldown");
+        assert.ok(r.remaining_min >= 1 && r.remaining_min <= 60);
+      } finally { await cleanup(dir3); }
+    } finally { await cleanup(dir2); }
+  } finally { await cleanup(dir); }
+});
+
+test("canDispatchBacklog: allowed after cooldown expires", async () => {
+  const dir = join(
+    tmpdir(),
+    `dispatcher-expire-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  try {
+    await fsp.mkdir(join(dir, "state/sessions"), { recursive: true });
+    await fsp.mkdir(join(dir, "logs/daemon"), { recursive: true });
+    // Cooldown already expired (set to 1h ago).
+    await fsp.writeFile(
+      join(dir, "state/sessions/backlog-cooldowns.json"),
+      JSON.stringify({ "TEST-3": Date.now() - 3_600_000 }) + "\n"
+    );
+    process.env.AGENT_DIR = dir;
+    const url = new URL("./dispatcher.mjs", import.meta.url);
+    const mod = await import(`${url.href}?expired=${Math.random()}`);
+    const r = mod.canDispatchBacklog({ id: "TEST-3", title: "Expired cooldown item" });
+    assert.equal(r.allowed, true);
+  } finally { await cleanup(dir); }
+});
+
+test("backlog-cooldowns.json persists across simulated daemon restarts", async () => {
+  const dir = join(
+    tmpdir(),
+    `dispatcher-persist-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  try {
+    await fsp.mkdir(join(dir, "state/sessions"), { recursive: true });
+    await fsp.mkdir(join(dir, "logs/daemon"), { recursive: true });
+    const cooldownPath = join(dir, "state/sessions/backlog-cooldowns.json");
+    const future = Date.now() + 30 * 60_000;
+    await fsp.writeFile(cooldownPath, JSON.stringify({ "RESTART-1": future }) + "\n");
+    process.env.AGENT_DIR = dir;
+    const url = new URL("./dispatcher.mjs", import.meta.url);
+    const mod = await import(`${url.href}?persist=${Math.random()}`);
+    const r = mod.canDispatchBacklog({ id: "RESTART-1", title: "After restart" });
+    assert.equal(r.allowed, false, "loaded cooldown should block dispatch");
+    assert.equal(r.reason, "post_completion_cooldown");
+  } finally { await cleanup(dir); }
+});