@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/daemon/inbox-deferral.test.mjs

@@ -1,336 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { markDeferred, promoteDeferred } from "./inbox-deferral.mjs";
-
-function makeAgentRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-deferral-"));
-  mkdirSync(join(root, "state", "inbox", "slack"), { recursive: true });
-  return root;
-}
-
-function writeInboxItem(root, name, { channel_id, timestamp, id = "test-id", thread_id, scope_id }) {
-  const body = [
-    `id: "${id}"`,
-    `service: "slack"`,
-    `channel_id: "${channel_id}"`,
-    ...(thread_id ? [`thread_id: "${thread_id}"`] : []),
-    ...(scope_id ? [`scope_id: "${scope_id}"`] : []),
-    `timestamp: "${timestamp}"`,
-    `content: |`,
-    `  body`,
-    "",
-  ].join("\n");
-  writeFileSync(join(root, "state", "inbox", "slack", name), body);
-}
-
-test("markDeferred renames live file to .deferred", () => {
-  const root = makeAgentRoot();
-  try {
-    writeInboxItem(root, "msg-A.yaml", {
-      channel_id: "D001",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "msg-A",
-    });
-    const n = markDeferred({ id: "msg-A" }, "slack", root);
-    assert.equal(n, 1);
-    const files = readdirSync(join(root, "state", "inbox", "slack"));
-    assert.deepEqual(files, ["msg-A.yaml.deferred"]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("markDeferred is idempotent — already-deferred files are skipped", () => {
-  const root = makeAgentRoot();
-  try {
-    writeInboxItem(root, "msg-B.yaml.deferred", {
-      channel_id: "D001",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "msg-B",
-    });
-    const n = markDeferred({ id: "msg-B" }, "slack", root);
-    assert.equal(n, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("markDeferred is no-op when item has no matching file (e.g. backlog)", () => {
-  const root = makeAgentRoot();
-  try {
-    const n = markDeferred({ id: "no-such-id" }, "slack", root);
-    assert.equal(n, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred with single item: renames back to live", () => {
-  const root = makeAgentRoot();
-  try {
-    writeInboxItem(root, "msg-C.yaml.deferred", {
-      channel_id: "D099N1JEA10",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "msg-C",
-    });
-    const r = promoteDeferred("D099N1JEA10", root);
-    assert.equal(r.promoted, 1);
-    assert.equal(r.bundled, 0);
-    assert.equal(r.service, "slack");
-    const files = readdirSync(join(root, "state", "inbox", "slack"));
-    assert.deepEqual(files, ["msg-C.yaml"]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred with multiple items: keeps latest, bundles rest", () => {
-  const root = makeAgentRoot();
-  try {
-    writeInboxItem(root, "msg-1.yaml.deferred", {
-      channel_id: "D001",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "msg-1",
-    });
-    writeInboxItem(root, "msg-2.yaml.deferred", {
-      channel_id: "D001",
-      timestamp: "2026-05-13T00:01:00Z",
-      id: "msg-2",
-    });
-    writeInboxItem(root, "msg-3.yaml.deferred", {
-      channel_id: "D001",
-      timestamp: "2026-05-13T00:02:00Z",
-      id: "msg-3",
-    });
-    const r = promoteDeferred("D001", root);
-    assert.equal(r.promoted, 1);
-    assert.equal(r.bundled, 2);
-    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
-    assert.deepEqual(files, [
-      "msg-1.yaml.processed-bundled",
-      "msg-2.yaml.processed-bundled",
-      "msg-3.yaml", // latest survives as live
-    ]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred bundles WITHIN a surface, not across the whole channel", () => {
-  // A directed 1:1 DM thread AND the actor's doc-comment events resolve to the
-  // same channel_id. Bundling latest-wins across the channel would drop the DM
-  // just because a newer doc event landed. Each surface must promote its own
-  // latest; nothing is bundled across surfaces.
-  const root = makeAgentRoot();
-  try {
-    // The directed DM (one message, thread T-DM).
-    writeInboxItem(root, "dm-1.yaml.deferred", {
-      channel_id: "room-1", thread_id: "T-DM", id: "dm-1",
-      timestamp: "2026-05-13T00:00:30Z",
-    });
-    // Two doc-comment events on the same room but a different surface (scope S-DOC),
-    // the later of which would have "won" under the old channel-wide bundling.
-    writeInboxItem(root, "doc-1.yaml.deferred", {
-      channel_id: "room-1", scope_id: "S-DOC", id: "doc-1",
-      timestamp: "2026-05-13T00:01:00Z",
-    });
-    writeInboxItem(root, "doc-2.yaml.deferred", {
-      channel_id: "room-1", scope_id: "S-DOC", id: "doc-2",
-      timestamp: "2026-05-13T00:02:00Z",
-    });
-    const r = promoteDeferred("room-1", root);
-    assert.equal(r.promoted, 2, "the DM and the latest doc event are BOTH promoted");
-    assert.equal(r.bundled, 1, "only the older doc event (same surface) is bundled");
-    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
-    assert.deepEqual(files, [
-      "dm-1.yaml",                    // the directed DM survives — NOT dropped
-      "doc-1.yaml.processed-bundled", // older doc event folded into doc-2
-      "doc-2.yaml",                   // latest doc event promoted
-    ]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred ignores items in other channels", () => {
-  const root = makeAgentRoot();
-  try {
-    writeInboxItem(root, "for-A.yaml.deferred", {
-      channel_id: "D-A",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "for-A",
-    });
-    writeInboxItem(root, "for-B.yaml.deferred", {
-      channel_id: "D-B",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "for-B",
-    });
-    const r = promoteDeferred("D-A", root);
-    assert.equal(r.promoted, 1);
-    assert.equal(r.bundled, 0);
-    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
-    assert.deepEqual(files, ["for-A.yaml", "for-B.yaml.deferred"]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred no-op when nothing to promote", () => {
-  const root = makeAgentRoot();
-  try {
-    const r = promoteDeferred("D999", root);
-    assert.equal(r.promoted, 0);
-    assert.equal(r.bundled, 0);
-    assert.equal(r.service, null);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Audit L7 — block-scalar body must not be mis-parsed for routing fields
-// ---------------------------------------------------------------------------
-
-/**
- * Write an inbox item whose `content` block scalar body itself contains lines
- * that look like top-level `channel_id:` / `timestamp:` keys. A naive
- * `^\s*field:` regex would match the INDENTED body line and mis-route.
- */
-function writeInboxItemWithTrickyBody(root, name, { channel_id, timestamp, id, bodyChannel, bodyTimestamp }) {
-  const lines = [
-    `id: "${id}"`,
-    `service: "slack"`,
-    `channel_id: "${channel_id}"`,
-    `timestamp: "${timestamp}"`,
-    `content: |`,
-    `  Hi team — quoting an old config below:`,
-    `  channel_id: ${bodyChannel}`,
-    `  timestamp: ${bodyTimestamp}`,
-    `  please review.`,
-    "",
-  ];
-  writeFileSync(join(root, "state", "inbox", "slack", name), lines.join("\n"));
-}
-
-test("L7: body line `channel_id:` in a block scalar does not mis-route", () => {
-  const root = makeAgentRoot();
-  try {
-    // Real top-level channel is D-REAL. The body mentions D-EVIL on an
-    // indented `channel_id:` line — promote must target D-REAL only.
-    writeInboxItemWithTrickyBody(root, "tricky.yaml.deferred", {
-      channel_id: "D-REAL",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "tricky",
-      bodyChannel: "D-EVIL",
-      bodyTimestamp: "1999-01-01T00:00:00Z",
-    });
-
-    // Promoting the body's channel must find NOTHING (the body line is not a
-    // real top-level field).
-    const evil = promoteDeferred("D-EVIL", root);
-    assert.equal(evil.promoted, 0, "must not match the indented body channel_id");
-    assert.equal(evil.bundled, 0);
-
-    // Promoting the genuine top-level channel must succeed.
-    const real = promoteDeferred("D-REAL", root);
-    assert.equal(real.promoted, 1, "real top-level channel_id must match");
-    assert.equal(real.bundled, 0);
-    const files = readdirSync(join(root, "state", "inbox", "slack"));
-    assert.deepEqual(files, ["tricky.yaml"]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("L7: latest-wins uses top-level timestamp, not a body `timestamp:` line", () => {
-  const root = makeAgentRoot();
-  try {
-    // Two items in the same channel. Item B is genuinely later by its
-    // top-level timestamp, but its block-scalar body contains an EARLY
-    // `timestamp:` line. A naive parser could read the body line, pick A as
-    // "latest" and bundle B. Correct behaviour: B wins (later top-level ts).
-    writeInboxItem(root, "A.yaml.deferred", {
-      channel_id: "D-TS",
-      timestamp: "2026-05-13T00:00:00Z",
-      id: "A",
-    });
-    writeInboxItemWithTrickyBody(root, "B.yaml.deferred", {
-      channel_id: "D-TS",
-      timestamp: "2026-05-13T09:00:00Z", // genuinely later
-      id: "B",
-      bodyChannel: "D-TS",
-      bodyTimestamp: "2000-01-01T00:00:00Z", // decoy early ts in the body
-    });
-
-    const r = promoteDeferred("D-TS", root);
-    assert.equal(r.promoted, 1);
-    assert.equal(r.bundled, 1);
-    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
-    assert.deepEqual(files, [
-      "A.yaml.processed-bundled", // earlier item bundled
-      "B.yaml", // later top-level timestamp survives as live
-    ]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-// --- service-dir discovery (the cohort/orgmail regression) -------------------
-
-/** Write a deferred item into ANY service dir (creating it). */
-function writeDeferredIn(root, service, name, { channel_id, timestamp, id }) {
-  mkdirSync(join(root, "state", "inbox", service), { recursive: true });
-  const body = [
-    `id: "${id}"`,
-    `service: "${service}"`,
-    `channel_id: "${channel_id}"`,
-    `timestamp: "${timestamp}"`,
-    `content: |`,
-    `  body`,
-    "",
-  ].join("\n");
-  writeFileSync(join(root, "state", "inbox", service, name), body);
-}
-
-test("promoteDeferred finds services the hardcoded list never knew about (cohort/orgmail)", () => {
-  const root = makeAgentRoot();
-  try {
-    writeDeferredIn(root, "cohort", "cohort-msg.yaml.deferred", {
-      channel_id: "ch_build",
-      timestamp: "2026-08-11T00:00:00Z",
-      id: "cohort-msg",
-    });
-    const r = promoteDeferred("ch_build", root);
-    assert.equal(r.promoted, 1, "a deferred Cohort message was previously un-promotable forever");
-    assert.equal(r.service, "cohort");
-    assert.deepEqual(readdirSync(join(root, "state", "inbox", "cohort")), ["cohort-msg.yaml"]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("promoteDeferred signals the inbox wake so the promoted item is not stuck behind the poll", async () => {
-  const { waitForInboxWake, resetInboxWake } = await import("./inbox-wake.mjs");
-  const root = makeAgentRoot();
-  resetInboxWake();
-  try {
-    writeDeferredIn(root, "cohort", "burst-2.yaml.deferred", {
-      channel_id: "ch_dm",
-      timestamp: "2026-08-11T00:00:01Z",
-      id: "burst-2",
-    });
-    // scanMs is disabled so ONLY the in-process signal can settle this.
-    const waiting = waitForInboxWake({ agentRoot: root, timeoutMs: 3_000, scanMs: 600_000 });
-    setTimeout(() => promoteDeferred("ch_dm", root), 20);
-    const woke = await waiting;
-    assert.equal(woke.woke, true);
-    assert.equal(woke.service, "cohort");
-  } finally {
-    resetInboxWake();
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/scripts/daemon/inbox-wake.test.mjs

@@ -1,199 +0,0 @@
-/**
- * inbox-wake.test.mjs — the daemon's "something landed" wake signal.
- *
- * Exercised against a REAL temp filesystem (fs.watch semantics are the thing
- * under test), plus one injected-watch case that proves the scan floor carries
- * the load when every watcher is dead — the property that keeps a missed event
- * from turning into a silently late agent.
- *
- * Run: node --test scripts/daemon/inbox-wake.test.mjs
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, renameSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  waitForInboxWake,
-  signalInbox,
-  findLiveInboxService,
-  isLiveItemName,
-  resetInboxWake,
-  DEFAULT_SERVICES,
-} from "./inbox-wake.mjs";
-
-function makeRoot() {
-  const root = mkdtempSync(join(tmpdir(), "inbox-wake-"));
-  mkdirSync(join(root, "state", "inbox", "cohort"), { recursive: true });
-  return root;
-}
-
-function writeItem(root, service, name, body = "id: x\n") {
-  writeFileSync(join(root, "state", "inbox", service, name), body);
-}
-
-// --- the predicate ----------------------------------------------------------
-
-test("isLiveItemName: only un-drained, non-dot files count as work", () => {
-  assert.equal(isLiveItemName("2026-08-11-abc.yaml"), true);
-  assert.equal(isLiveItemName("2026-08-11-abc.yaml.processed"), false);
-  assert.equal(isLiveItemName("2026-08-11-abc.yaml.deferred"), false);
-  assert.equal(isLiveItemName("2026-08-11-abc.yaml.processed-bundled"), false);
-  assert.equal(isLiveItemName(".DS_Store"), false);
-  assert.equal(isLiveItemName(""), false);
-});
-
-test("findLiveInboxService: names the service holding work, else null", () => {
-  const root = makeRoot();
-  try {
-    assert.equal(findLiveInboxService({ agentRoot: root }), null);
-    writeItem(root, "cohort", "a.yaml.processed");
-    assert.equal(findLiveInboxService({ agentRoot: root }), null, "a drained item is not work");
-    writeItem(root, "cohort", "b.yaml");
-    assert.equal(findLiveInboxService({ agentRoot: root }), "cohort");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("the cohort + orgmail dirs are in the default service set (the ones that were missed)", () => {
-  assert.ok(DEFAULT_SERVICES.includes("cohort"));
-  assert.ok(DEFAULT_SERVICES.includes("orgmail"));
-  assert.ok(DEFAULT_SERVICES.includes("telegram"));
-});
-
-// --- the wake ---------------------------------------------------------------
-
-test("returns immediately when work is already waiting (never sleep on a full inbox)", async () => {
-  const root = makeRoot();
-  try {
-    writeItem(root, "cohort", "a.yaml");
-    const r = await waitForInboxWake({ agentRoot: root, timeoutMs: 5_000 });
-    assert.equal(r.woke, true);
-    assert.equal(r.reason, "pending");
-    assert.equal(r.service, "cohort");
-    assert.equal(r.waitedMs, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("wakes on a file written by another writer, far inside the 60s poll interval", async () => {
-  const root = makeRoot();
-  try {
-    const started = Date.now();
-    const waiting = waitForInboxWake({ agentRoot: root, timeoutMs: 8_000 });
-    setTimeout(() => writeItem(root, "cohort", "late.yaml"), 50);
-    const r = await waiting;
-    assert.equal(r.woke, true);
-    assert.ok(["watch", "scan"].includes(r.reason), `unexpected reason ${r.reason}`);
-    assert.equal(r.service, "cohort");
-    assert.ok(Date.now() - started < 3_000, "a wake must not take seconds");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("does NOT wake when the only change is an item being drained", async () => {
-  const root = makeRoot();
-  try {
-    writeItem(root, "cohort", "a.yaml");
-    // Drain it, then wait: renaming to `.processed` raises watch events for BOTH
-    // names, so an event-driven wake would spin here.
-    renameSync(
-      join(root, "state", "inbox", "cohort", "a.yaml"),
-      join(root, "state", "inbox", "cohort", "a.yaml.processed")
-    );
-    const r = await waitForInboxWake({ agentRoot: root, timeoutMs: 400 });
-    assert.equal(r.woke, false);
-    assert.equal(r.reason, "timeout");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("times out cleanly with an empty inbox (the loop shape is unchanged)", async () => {
-  const root = makeRoot();
-  try {
-    const r = await waitForInboxWake({ agentRoot: root, timeoutMs: 200 });
-    assert.deepEqual(
-      { woke: r.woke, reason: r.reason, service: r.service },
-      { woke: false, reason: "timeout", service: null }
-    );
-    assert.ok(r.waitedMs >= 150);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("signalInbox wakes an in-process waiter (the dispatcher's promote path)", async () => {
-  const root = makeRoot();
-  resetInboxWake();
-  try {
-    const waiting = waitForInboxWake({ agentRoot: root, timeoutMs: 5_000, scanMs: 60_000 });
-    setTimeout(() => {
-      // Simulate promoteDeferred: the file becomes live, then we nudge.
-      writeItem(root, "cohort", "promoted.yaml");
-      signalInbox("promote");
-    }, 20);
-    const r = await waiting;
-    assert.equal(r.woke, true);
-    assert.equal(r.service, "cohort");
-  } finally {
-    resetInboxWake();
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("signalInbox with no work does NOT wake (a spurious nudge is free)", async () => {
-  const root = makeRoot();
-  resetInboxWake();
-  try {
-    const waiting = waitForInboxWake({ agentRoot: root, timeoutMs: 400, scanMs: 60_000 });
-    setTimeout(() => signalInbox("noise"), 20);
-    const r = await waiting;
-    assert.equal(r.woke, false);
-  } finally {
-    resetInboxWake();
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("with EVERY watcher dead the scan floor still wakes it — and says so once", async () => {
-  const root = makeRoot();
-  const logs = [];
-  try {
-    const watchImpl = () => {
-      throw new Error("EMFILE: watcher limit reached");
-    };
-    const waiting = waitForInboxWake({
-      agentRoot: root,
-      timeoutMs: 6_000,
-      scanMs: 100,
-      watchImpl,
-      log: (m) => logs.push(m),
-    });
-    setTimeout(() => writeItem(root, "cohort", "floor.yaml"), 30);
-    const r = await waiting;
-    assert.equal(r.woke, true);
-    assert.equal(r.reason, "scan", "correctness must not depend on fs.watch");
-    assert.equal(logs.length, 1, "a dead watcher is reported — fail-open, never silent");
-    assert.match(logs[0], /falling back to the 100ms rescan/);
-  } finally {
-    resetInboxWake();
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a missing service dir is not an error (an un-enrolled agent just times out)", async () => {
-  const root = mkdtempSync(join(tmpdir(), "inbox-wake-bare-"));
-  try {
-    const r = await waitForInboxWake({ agentRoot: root, timeoutMs: 200 });
-    assert.equal(r.woke, false);
-    assert.equal(r.reason, "timeout");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/scripts/daemon/integration.test.mjs

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-/**
- * test-integration.mjs — End-to-end integration tests for session lock + context compiler pipeline
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const TEST_DIR = join(__dirname, "../../.test-integration");
-
-// Set env BEFORE importing modules. context-compiler.mjs reads its repo root
-// from __TEST_AGENT_DIR (the legacy __TEST_SOPHIE_DIR name was never honoured by
-// the module, so the disclosure-boundary fixtures were written here but read
-// from the real repo — the cause of the end-to-end failure). Set both: the
-// session-lock module reads __TEST_SESSION_DIR; the compiler reads
-// __TEST_AGENT_DIR + __TEST_SESSION_DIR.
-process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
-process.env.__TEST_AGENT_DIR = TEST_DIR;
-process.env.__TEST_SOPHIE_DIR = TEST_DIR; // kept for any legacy reader; harmless
-
-function setupTestEnv() {
-  mkdirSync(join(TEST_DIR, "state", "sessions", "locks"), { recursive: true });
-  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
-  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user"), { recursive: true });
-  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
-  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
-
-  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), `domains:
-  internal-legal:
-    description: "Northwind legal strategy, GC advice, privilege-protected"
-    default_sensitivity: high
-  strategic-initiative:
-    description: "the strategic initiative M&A targets, deal terms, pipeline"
-    default_sensitivity: critical
-  public:
-    description: "Published information, press, website"
-    default_sensitivity: none
-`);
-}
-
-function cleanTestEnv() {
-  rmSync(TEST_DIR, { recursive: true, force: true });
-}
-
-const { acquireLock, releaseLock, registerSent, checkRecentlySent } = await import("./session-lock.mjs");
-const { compileContext } = await import("./context-compiler.mjs");
-
-// ─── Integration tests ─────────────────────────────────────────────────
-
-describe("Integration: lock → compile → prompt pipeline", () => {
-  beforeEach(setupTestEnv);
-  afterEach(cleanTestEnv);
-
-  it("acquireLock prevents duplicate processing of same item", () => {
-    const first = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
-    assert.equal(first.acquired, true);
-
-    const second = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
-    assert.equal(second.acquired, false);
-
-    releaseLock("slack-C001-12345");
-  });
-
-  it("sent-registry prevents duplicate sends across quick-reply and holding paths", () => {
-    // Holding message sent
-    registerSent("C001", "12345.6789", "holding", "s-1", "Looking into this now");
-
-    // A quick reply to the SAME channel+thread is blocked by the thread-cooldown
-    // rule (Rule 2): once anything has been sent to a thread, the whole thread
-    // cools down so the quick-reply path and the full-session path can't both
-    // fire into the same thread. (The original assertion expected the different
-    // type to be allowed — that predated Rule 2 and was stale; Rule 2 is the
-    // whole point of this test, "prevents duplicate sends across paths".)
-    const quickCheck = checkRecentlySent("C001", "12345.6789", "quick_reply");
-    assert.equal(quickCheck.allowed, false);
-    assert.match(quickCheck.reason, /thread cooldown/);
-
-    // Another holding to same channel+thread is likewise blocked.
-    const holdCheck = checkRecentlySent("C001", "12345.6789", "holding");
-    assert.equal(holdCheck.allowed, false);
-
-    // But a different, untouched thread is still free to receive a quick reply —
-    // the cooldown is scoped to the thread, not the whole channel (non-DM).
-    const otherThread = checkRecentlySent("C001", "99999.0000", "quick_reply");
-    assert.equal(otherThread.allowed, true);
-  });
-
-  it("context compiler respects disclosure boundaries end-to-end", async () => {
-    // Create a profile with restrictions
-    writeFileSync(
-      join(TEST_DIR, "memory", "profiles", "users", "test-user.yaml"),
-      `name: Test User\ninformation_boundaries:\n  excluded_domains:\n    - strategic-initiative\n`
-    );
-
-    // Create history with mixed content
-    const today = new Date().toISOString().split("T")[0];
-    writeFileSync(
-      join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user", `${today}.jsonl`),
-      [
-        JSON.stringify({ ts: "100", from: "test-user", content: "What is the status?", received_at: "2026-04-06T10:00:00Z" }),
-        JSON.stringify({ ts: "101", from: "robin", content: "the strategic initiative deal terms are looking good", received_at: "2026-04-06T10:01:00Z" }),
-        JSON.stringify({ ts: "102", from: "robin", content: "The public website update is live", received_at: "2026-04-06T10:02:00Z" }),
-      ].join("\n") + "\n"
-    );
-
-    const { contextBlock } = await compileContext(
-      { sender: "Test User", channel: "D001", channel_id: "D001" },
-      { priority: "normal", model: "sonnet", action: "respond" },
-      {}
-    );
-
-    // Public content should be included
-    assert.ok(contextBlock.includes("website update is live"));
-    // Strategic-initiative content should be filtered. (The old assertion
-    // checked for "Aether deal terms" — absent from the fixture — so it was a
-    // tautology; assert against the actual excluded fixture text.)
-    assert.ok(!contextBlock.includes("strategic initiative deal terms"));
-    // Should have disclosure boundaries
-    assert.ok(contextBlock.includes("DO NOT mention"));
-  });
-
-  it("active sessions are visible in compiled context", async () => {
-    writeFileSync(
-      join(TEST_DIR, "state", "sessions", "active.json"),
-      JSON.stringify({
-        "s-999": {
-          sender: "Alice",
-          channel: "C002",
-          summary: "Preparing board pack",
-          model: "opus",
-          startTime: Date.now() - 120000,
-        },
-      })
-    );
-
-    const { contextBlock } = await compileContext(
-      { sender: "Test", channel: "C001" },
-      { priority: "normal", model: "sonnet", action: "respond" },
-      {}
-    );
-
-    assert.ok(contextBlock.includes("Preparing board pack"));
-    assert.ok(contextBlock.includes("Active Sessions"));
-  });
-});