@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/channels/pairing.test.mjs

@@ -1,270 +0,0 @@
-/**
- * pairing.test.mjs — node:test coverage for lib/channels/pairing.mjs
- *
- * Covers: default-deny for unknown DM senders, self/peer drops, non-DM bypass,
- * pair-command interception, startPairing TTL + 0600 perms, redeemPairing
- * (happy path, expired, unknown, channel-mismatch, single-use), allowlist
- * read/append round-trip. Hermetic — uses an injectable `now` and tmpdirs.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { statSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  checkAllowed,
-  startPairing,
-  redeemPairing,
-  parsePairCommand,
-  readAllowlist,
-  appendToAllowlist,
-  sweepExpiredCodes,
-  mintCode,
-} from "./pairing.mjs";
-
-async function makeRoot() {
-  const p = join(tmpdir(), `pairing-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(p, { recursive: true });
-  return p;
-}
-async function rmRoot(p) { try { await fsp.rm(p, { recursive: true, force: true }); } catch { /* */ } }
-
-function dmEvent(channel, senderId, text = "hello") {
-  return {
-    channel,
-    text,
-    from: { id: senderId },
-    source: { channel, chatId: senderId, userScope: "dm", peerId: senderId },
-  };
-}
-function groupEvent(channel, senderId, text = "hello team") {
-  return {
-    channel,
-    text,
-    from: { id: senderId },
-    source: { channel, chatId: "G1", userScope: "group", peerId: senderId },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// checkAllowed — default-DENY
-// ---------------------------------------------------------------------------
-
-test("unknown DM sender is denied with reason not-paired", async () => {
-  const root = await makeRoot();
-  try {
-    const res = checkAllowed(dmEvent("telegram", "987"), { agentRoot: root });
-    assert.equal(res.allowed, false);
-    assert.equal(res.reason, "not-paired");
-    assert.equal(res.isPairingCommand, false);
-  } finally { await rmRoot(root); }
-});
-
-test("paired DM sender is allowed", async () => {
-  const root = await makeRoot();
-  try {
-    appendToAllowlist(root, "telegram", "987");
-    const res = checkAllowed(dmEvent("telegram", "987"), { agentRoot: root });
-    assert.equal(res.allowed, true);
-    assert.equal(res.reason, "paired");
-  } finally { await rmRoot(root); }
-});
-
-test("self-message is dropped", async () => {
-  const root = await makeRoot();
-  try {
-    const res = checkAllowed(dmEvent("slack", "UAGENT"), { agentRoot: root, ownId: "UAGENT" });
-    assert.equal(res.allowed, false);
-    assert.equal(res.reason, "self-message");
-  } finally { await rmRoot(root); }
-});
-
-test("peer-agent message is dropped", async () => {
-  const root = await makeRoot();
-  try {
-    const res = checkAllowed(dmEvent("slack", "UPEER"), { agentRoot: root, peerAgentIds: ["UPEER", "UPEER2"] });
-    assert.equal(res.allowed, false);
-    assert.equal(res.reason, "peer-agent");
-  } finally { await rmRoot(root); }
-});
-
-test("non-DM (group) traffic bypasses pairing", async () => {
-  const root = await makeRoot();
-  try {
-    // Unknown sender, but in a group → allowed (membership + directed-gate govern).
-    const res = checkAllowed(groupEvent("slack", "USTRANGER"), { agentRoot: root });
-    assert.equal(res.allowed, true);
-    assert.equal(res.reason, "non-dm");
-  } finally { await rmRoot(root); }
-});
-
-test("pair command is flagged isPairingCommand even from an unknown DM sender", async () => {
-  const root = await makeRoot();
-  try {
-    const res = checkAllowed(dmEvent("telegram", "987", "pair 7Q4KMN"), { agentRoot: root });
-    assert.equal(res.isPairingCommand, true);
-    assert.equal(res.code, "7Q4KMN");
-    // Still not a normal allowed message until redeemed.
-    assert.equal(res.allowed, false);
-    assert.equal(res.reason, "not-paired");
-  } finally { await rmRoot(root); }
-});
-
-test("parsePairCommand matches ^pair <code>$ only", () => {
-  assert.equal(parsePairCommand("pair ABCD"), "ABCD");
-  assert.equal(parsePairCommand("PAIR abcd23"), "ABCD23");
-  assert.equal(parsePairCommand("  pair 7q4k  "), "7Q4K");
-  assert.equal(parsePairCommand("please pair ABCD now"), null);
-  assert.equal(parsePairCommand("pairing"), null);
-  assert.equal(parsePairCommand(""), null);
-  assert.equal(parsePairCommand(undefined), null);
-});
-
-// ---------------------------------------------------------------------------
-// startPairing — code + TTL + 0600
-// ---------------------------------------------------------------------------
-
-test("startPairing mints a code, persists it 0600, with a TTL", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 1_000_000;
-    const { code, expiresAt } = startPairing("telegram", { agentRoot: root, ttlMs: 60_000, now: () => t0 });
-    assert.match(code, /^[A-Z0-9]{6}$/);
-    assert.equal(expiresAt, t0 + 60_000);
-    const file = join(root, "state/channels/pairing", `${code}.json`);
-    assert.ok(existsSync(file));
-    // POSIX perms: 0600 (owner rw only). Mask to the permission bits.
-    const mode = statSync(file).mode & 0o777;
-    assert.equal(mode, 0o600, `expected 0600, got ${mode.toString(8)}`);
-  } finally { await rmRoot(root); }
-});
-
-test("mintCode uses an unambiguous alphabet (no 0/O/1/I/L)", () => {
-  for (let i = 0; i < 50; i++) {
-    const c = mintCode();
-    assert.doesNotMatch(c, /[01OIL]/, `code ${c} contains an ambiguous char`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// redeemPairing
-// ---------------------------------------------------------------------------
-
-test("redeemPairing: happy path adds the peer and consumes the code", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 5_000;
-    const { code } = startPairing("telegram", { agentRoot: root, ttlMs: 60_000, now: () => t0 });
-    const res = redeemPairing("telegram", "987", code, { agentRoot: root, now: () => t0 + 1000 });
-    assert.equal(res.ok, true);
-    assert.equal(res.added, true);
-    // Peer is now on the allowlist.
-    const allow = readAllowlist(root);
-    assert.ok(allow.telegram.has("987"));
-    // Code file consumed (single-use).
-    assert.ok(!existsSync(join(root, "state/channels/pairing", `${code}.json`)));
-    // A now-allowed DM passes the gate.
-    const gate = checkAllowed(dmEvent("telegram", "987"), { agentRoot: root });
-    assert.equal(gate.allowed, true);
-  } finally { await rmRoot(root); }
-});
-
-test("redeemPairing: expired code is rejected and cleaned up", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 10_000;
-    const { code } = startPairing("telegram", { agentRoot: root, ttlMs: 1000, now: () => t0 });
-    const res = redeemPairing("telegram", "987", code, { agentRoot: root, now: () => t0 + 5000 });
-    assert.equal(res.ok, false);
-    assert.equal(res.reason, "expired");
-    assert.ok(!existsSync(join(root, "state/channels/pairing", `${code}.json`)));
-    // Not added.
-    assert.equal(readAllowlist(root).telegram, undefined);
-  } finally { await rmRoot(root); }
-});
-
-test("redeemPairing: unknown code rejected", async () => {
-  const root = await makeRoot();
-  try {
-    const res = redeemPairing("telegram", "987", "ZZZZZZ", { agentRoot: root });
-    assert.equal(res.ok, false);
-    assert.equal(res.reason, "unknown-code");
-  } finally { await rmRoot(root); }
-});
-
-test("redeemPairing: channel mismatch rejected, code not consumed", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 1000;
-    const { code } = startPairing("telegram", { agentRoot: root, ttlMs: 60_000, now: () => t0 });
-    const res = redeemPairing("slack", "987", code, { agentRoot: root, now: () => t0 + 100 });
-    assert.equal(res.ok, false);
-    assert.equal(res.reason, "channel-mismatch");
-    // Still present (so the right channel can redeem it).
-    assert.ok(existsSync(join(root, "state/channels/pairing", `${code}.json`)));
-  } finally { await rmRoot(root); }
-});
-
-test("redeemPairing is single-use: a second redeem fails", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 1000;
-    const { code } = startPairing("telegram", { agentRoot: root, ttlMs: 60_000, now: () => t0 });
-    assert.equal(redeemPairing("telegram", "987", code, { agentRoot: root, now: () => t0 + 1 }).ok, true);
-    const second = redeemPairing("telegram", "654", code, { agentRoot: root, now: () => t0 + 2 });
-    assert.equal(second.ok, false);
-    assert.equal(second.reason, "unknown-code");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// allowlist read/append + sweep
-// ---------------------------------------------------------------------------
-
-test("appendToAllowlist is idempotent and groups under the channel key", async () => {
-  const root = await makeRoot();
-  try {
-    assert.equal(appendToAllowlist(root, "slack", "U1"), true);
-    assert.equal(appendToAllowlist(root, "slack", "U1"), false, "duplicate should not re-add");
-    assert.equal(appendToAllowlist(root, "slack", "U2"), true);
-    assert.equal(appendToAllowlist(root, "telegram", "987"), true);
-    const allow = readAllowlist(root);
-    assert.deepEqual([...allow.slack].sort(), ["U1", "U2"]);
-    assert.ok(allow.telegram.has("987"));
-  } finally { await rmRoot(root); }
-});
-
-test("readAllowlist tolerates comments, quotes, and inline flow lists", async () => {
-  const root = await makeRoot();
-  try {
-    await fsp.mkdir(join(root, "config"), { recursive: true });
-    await fsp.writeFile(join(root, "config/allowlist.yaml"),
-      [
-        "# cross-channel DM allowlist",
-        "slack:",
-        "  - U1   # casey",
-        '  - "U2"',
-        "telegram: [ \"987\", 654 ]",
-        "",
-      ].join("\n"));
-    const allow = readAllowlist(root);
-    assert.deepEqual([...allow.slack].sort(), ["U1", "U2"]);
-    assert.deepEqual([...allow.telegram].sort(), ["654", "987"]);
-  } finally { await rmRoot(root); }
-});
-
-test("sweepExpiredCodes removes only expired codes", async () => {
-  const root = await makeRoot();
-  try {
-    const t0 = 1000;
-    const fresh = startPairing("telegram", { agentRoot: root, ttlMs: 100_000, now: () => t0 });
-    const stale = startPairing("slack", { agentRoot: root, ttlMs: 10, now: () => t0 });
-    const removed = sweepExpiredCodes(root, () => t0 + 5000);
-    assert.equal(removed, 1);
-    assert.ok(existsSync(join(root, "state/channels/pairing", `${fresh.code}.json`)));
-    assert.ok(!existsSync(join(root, "state/channels/pairing", `${stale.code}.json`)));
-  } finally { await rmRoot(root); }
-});

package/lib/channels/repeat-suppressor.test.mjs

@@ -1,134 +0,0 @@
-/**
- * repeat-suppressor.test.mjs — coverage for lib/channels/repeat-suppressor.mjs.
- *
- * The behaviour under test is the fix for a real incident: 478 identical
- * `email.inbox NOT_FOUND` lines in one day from a 45s poll loop. The rules that
- * must hold are "say it once", "keep saying it occasionally so it cannot fade
- * out", and "say when it stops" — the middle one being what separates this from
- * a silent catch.
- *
- * Hermetic: injected clock, no I/O.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { RepeatSuppressor, fmtDuration, TERMINAL_CODES } from "./repeat-suppressor.mjs";
-
-/** A controllable clock. */
-function clock(start = 0) {
-  const c = { t: start, now: () => c.t, advance: (ms) => { c.t += ms; } };
-  return c;
-}
-
-test("the first occurrence always emits, in full", () => {
-  const s = new RepeatSuppressor({ now: clock().now });
-  const r = s.observe("k", { code: "NOT_FOUND" });
-  assert.equal(r.emit, true);
-  assert.equal(r.first, true);
-  assert.equal(r.suppressed, 0);
-  assert.equal(r.suffix, "");
-});
-
-test("repeats inside the restate window are counted and swallowed", () => {
-  const c = clock();
-  const s = new RepeatSuppressor({ now: c.now, restateMs: 3_600_000 });
-  s.observe("k", { code: "NOT_FOUND" });
-  let emitted = 0;
-  // 45s poll for 30 minutes = 40 more ticks. The incident shape, in miniature.
-  for (let i = 0; i < 40; i += 1) {
-    c.advance(45_000);
-    if (s.observe("k", { code: "NOT_FOUND" }).emit) emitted += 1;
-  }
-  assert.equal(emitted, 0, "not one repeat may reach the log inside the window");
-});
-
-test("a standing condition is RE-STATED once per window, carrying the suppressed count", () => {
-  const c = clock();
-  const s = new RepeatSuppressor({ now: c.now, restateMs: 3_600_000 });
-  s.observe("k", { code: "NOT_FOUND" });
-  let restatement = null;
-  for (let i = 0; i < 100; i += 1) {
-    c.advance(45_000); // 100 ticks ≈ 75 minutes
-    const r = s.observe("k", { code: "NOT_FOUND" });
-    if (r.emit) { restatement = r; break; }
-  }
-  assert.ok(restatement, "a standing condition must not fade out of the log entirely");
-  assert.equal(restatement.restated, true);
-  assert.ok(restatement.suppressed > 70, `expected ~79 suppressed, got ${restatement.suppressed}`);
-  assert.match(restatement.suffix, /STILL UNRESOLVED after 1h/);
-  assert.match(restatement.suffix, /suppressed/);
-});
-
-test("over a full day the 478-line incident collapses to first + hourly re-statements", () => {
-  const c = clock();
-  const s = new RepeatSuppressor({ now: c.now, restateMs: 3_600_000 });
-  let emitted = 0;
-  const ticks = Math.round((24 * 3_600_000) / 45_000); // 1920 polls in a day
-  for (let i = 0; i < ticks; i += 1) {
-    if (s.observe("k", { code: "NOT_FOUND" }).emit) emitted += 1;
-    c.advance(45_000);
-  }
-  // 1 first line + one re-statement per elapsed hour (the 24th hour's
-  // re-statement lands just past the window, so 24 lines cover the day).
-  assert.equal(emitted, 24, `expected 24 lines a day, got ${emitted}`);
-  assert.ok(emitted < ticks / 50, "the whole point: ~2 orders of magnitude quieter than 1920 polls");
-});
-
-test("clear() reports the recovery WITH the total attempts, then forgets", () => {
-  const c = clock();
-  const s = new RepeatSuppressor({ now: c.now });
-  s.observe("k", { code: "NOT_FOUND" });
-  for (let i = 0; i < 9; i += 1) { c.advance(45_000); s.observe("k", { code: "NOT_FOUND" }); }
-  c.advance(45_000);
-  const r = s.clear("k");
-  assert.equal(r.wasActive, true);
-  assert.equal(r.count, 10);
-  assert.match(r.message, /RESOLVED after/);
-  assert.match(r.message, /10 failed attempt/);
-  // Idempotent: clearing a healthy condition says nothing at all.
-  assert.equal(s.clear("k").wasActive, false);
-});
-
-test("terminal codes are flagged so a caller can back its poll off", () => {
-  const s = new RepeatSuppressor({ now: clock().now });
-  assert.equal(s.observe("a", { code: "NOT_FOUND" }).terminal, true);
-  assert.equal(s.observe("b", { code: "FORBIDDEN_SCOPE" }).terminal, true);
-  assert.equal(s.observe("c", { code: "INTERNAL" }).terminal, false);
-  assert.equal(s.observe("d", { code: "TIMEOUT" }).terminal, false);
-  for (const code of TERMINAL_CODES) {
-    assert.equal(s.observe(`t-${code}`, { code }).terminal, true);
-  }
-});
-
-test("distinct keys are tracked independently", () => {
-  const c = clock();
-  const s = new RepeatSuppressor({ now: c.now });
-  assert.equal(s.observe("inbox", { code: "NOT_FOUND" }).emit, true);
-  assert.equal(s.observe("send", { code: "NOT_FOUND" }).emit, true);
-  c.advance(45_000);
-  assert.equal(s.observe("inbox", { code: "NOT_FOUND" }).emit, false);
-  assert.equal(s.isActive("send"), true);
-  assert.equal(s.active().length, 2);
-});
-
-test("active() snapshots standing conditions for healthCheck / state files", () => {
-  const c = clock(1_700_000_000_000);
-  const s = new RepeatSuppressor({ now: c.now });
-  s.observe("inbox", { code: "NOT_FOUND" });
-  c.advance(3 * 3_600_000);
-  const [a] = s.active();
-  assert.equal(a.key, "inbox");
-  assert.equal(a.code, "NOT_FOUND");
-  assert.equal(a.terminal, true);
-  assert.equal(a.standingMs, 3 * 3_600_000);
-  assert.match(a.firstAt, /^\d{4}-/);
-});
-
-test("fmtDuration stays short enough to live inside a log line", () => {
-  assert.equal(fmtDuration(45_000), "45s");
-  assert.equal(fmtDuration(90_000), "1m");
-  assert.equal(fmtDuration(3_600_000), "1h");
-  assert.equal(fmtDuration(3_600_000 + 720_000), "1h 12m");
-  assert.equal(fmtDuration(26 * 3_600_000), "1d 2h");
-});

package/lib/channels/slack-adapter.test.mjs

@@ -1,212 +0,0 @@
-/**
- * slack-adapter.test.mjs — node:test coverage for slack/adapter.mjs
- *
- * Proves the re-homed translation is behaviour-preserving (round-trip through
- * the writeInbox shim → MessageEvent → daemon eventToInboxItem reproduces the
- * legacy socket-mode item) and that the enrich hook closes the 3 gaps
- * (reaction kind, thread_context, channel_cc). Injects a fake socket client +
- * fake fetch — no network, no real Slack.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { SlackAdapter, parseSlackConfig } from "./slack/adapter.mjs";
-import { eventToInboxItem as daemonEventToInboxItem } from "./inbox-item.mjs";
-import { eventToInboxItem as slackLegacyItem } from "../../scripts/poller/slack-socket-mode.mjs";
-
-async function makeRoot() {
-  const p = join(tmpdir(), `slack-adapter-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(p, { recursive: true });
-  return p;
-}
-async function rmRoot(p) { try { await fsp.rm(p, { recursive: true, force: true }); } catch { /* */ } }
-
-const IDS = { firstName: "Ravi", fullName: "Jamie Lee", slackMemberId: "UAGENT0001", principalSlackId: "UCEO000001" };
-
-/**
- * A fake socket client capturing the opts the adapter passed (writeInbox,
- * enrich, reactions, ccChannels) so the test can drive the seam directly.
- */
-function fakeClientFactory(captured) {
-  return (opts) => {
-    captured.opts = opts;
-    return {
-      start: async () => { captured.started = true; },
-      stop: () => { captured.stopped = true; },
-      getStats: () => ({}),
-      getState: () => ({}),
-    };
-  };
-}
-
-function makeAdapter(root, extra = {}) {
-  const captured = {};
-  const a = new SlackAdapter({
-    agentRoot: root,
-    botToken: "xoxb-test",
-    appToken: "xapp-test",
-    createClient: fakeClientFactory(captured),
-    ...extra,
-  });
-  // Pre-seed identity/peers so _connect doesn't read config/agent.json.
-  a._identity = IDS;
-  a._peerSlackIds = new Set();
-  a._appToken = "xapp-test";
-  return { a, captured };
-}
-
-// ---------------------------------------------------------------------------
-// behaviour-preserving round-trip
-// ---------------------------------------------------------------------------
-
-test("writeInbox shim → MessageEvent → daemon item == legacy socket-mode item (DM)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, captured } = makeAdapter(root);
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    assert.ok(captured.started, "adapter started the socket client");
-    assert.equal(captured.opts.reactions, true, "reactions on by default");
-
-    // Build the legacy item exactly as the socket client would, then feed it
-    // through the adapter's writeInbox shim (what the real client calls).
-    const envelope = {
-      payload: { event: { type: "message", user: "UHUMAN0001", text: "hey, draft the memo", ts: "1735689600.001000", channel: "DABCDEF01" } },
-    };
-    const legacy = slackLegacyItem(envelope, { ownSlackId: IDS.slackMemberId, principalSlackId: IDS.principalSlackId, agentFirstName: IDS.firstName });
-
-    captured.opts.writeInbox("slack", legacy);
-    assert.equal(received.length, 1, "event reached onInbound");
-    const ev = received[0];
-    assert.equal(ev.kind, "message");
-    assert.equal(ev.source.channel, "slack");
-    assert.equal(ev.source.chatId, "DABCDEF01");
-    assert.equal(ev.source.userScope, "dm");
-
-    // The daemon re-serializes the event — must reproduce the legacy item.
-    const reserialized = daemonEventToInboxItem(ev);
-    assert.deepEqual(reserialized, legacy, "round-trip must be byte-identical");
-  } finally { await rmRoot(root); }
-});
-
-test("Slack adapter uses pairingMode 'open' so DMs are never default-denied", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, captured } = makeAdapter(root);
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    // An un-allowlisted DM sender — pairing "open" must let it through.
-    const legacy = slackLegacyItem(
-      { payload: { event: { type: "message", user: "USTRANGER", text: "hi", ts: "1735689600.001000", channel: "DZZZ" } } },
-      { ownSlackId: IDS.slackMemberId, principalSlackId: IDS.principalSlackId, agentFirstName: IDS.firstName },
-    );
-    captured.opts.writeInbox("slack", legacy);
-    assert.equal(received.length, 1, "Slack DM must not be blocked by pairing (live-path preserved)");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// enrich hook — gap (b) thread_context, gap (a) reaction target text
-// ---------------------------------------------------------------------------
-
-test("enrich fills thread_context for a thread reply via conversations.replies", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeAdapter(root, {
-      fetchFn: async (url) => {
-        const u = String(url);
-        if (u.includes("conversations.replies")) {
-          return { json: async () => ({ ok: true, messages: [
-            { ts: "1735689500.000100", user: "UHUMAN0001", text: "original question" },
-            { ts: "1735689800.003000", user: "UHUMAN0001", text: "the reply itself" },
-          ] }) };
-        }
-        return { json: async () => ({ ok: false }) };
-      },
-    });
-    const envelope = { payload: { event: { type: "message", channel: "C1", ts: "1735689800.003000", thread_ts: "1735689500.000100", text: "the reply" } } };
-    const extra = await a._enrich(envelope);
-    assert.match(extra.threadContext, /original question/);
-    // The reply itself (>= beforeTs) is excluded from the prior context.
-    assert.doesNotMatch(extra.threadContext, /the reply itself/);
-  } finally { await rmRoot(root); }
-});
-
-test("enrich fills reaction target text via conversations.history", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeAdapter(root, {
-      fetchFn: async (url) => {
-        if (String(url).includes("conversations.history")) {
-          return { json: async () => ({ ok: true, messages: [{ ts: "1735689600.001000", text: "the message they reacted to" }] }) };
-        }
-        return { json: async () => ({ ok: false }) };
-      },
-    });
-    const envelope = { payload: { event: { type: "reaction_added", user: "UHUMAN0001", reaction: "eyes", item: { type: "message", channel: "C1", ts: "1735689600.001000" } } } };
-    const extra = await a._enrich(envelope);
-    assert.match(extra.threadContext, /reacted to/);
-  } finally { await rmRoot(root); }
-});
-
-test("enrich is fail-open: a fetch throw yields {} (event still flows)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeAdapter(root, { fetchFn: async () => { throw new Error("slack 500"); } });
-    const envelope = { payload: { event: { type: "message", channel: "C1", ts: "2", thread_ts: "1", text: "x" } } };
-    const extra = await a._enrich(envelope);
-    assert.deepEqual(extra, {});
-  } finally { await rmRoot(root); }
-});
-
-test("enrich returns {} for a non-threaded message (no API call)", async () => {
-  const root = await makeRoot();
-  try {
-    let called = false;
-    const { a } = makeAdapter(root, { fetchFn: async () => { called = true; return { json: async () => ({ ok: true, messages: [] }) }; } });
-    const envelope = { payload: { event: { type: "message", channel: "C1", ts: "1735689600.001000", text: "top-level" } } };
-    const extra = await a._enrich(envelope);
-    assert.deepEqual(extra, {});
-    assert.equal(called, false, "top-level messages need no enrichment fetch");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// config parsing — cc_channels + reactions
-// ---------------------------------------------------------------------------
-
-test("parseSlackConfig reads ingest_mode, reactions, and cc_channels (list + inline)", () => {
-  const list = parseSlackConfig([
-    "ingest_mode: socket",
-    "reactions: on",
-    "cc_channels:",
-    "  - C0AAA   # eng",
-    '  - "C0BBB"',
-  ].join("\n"));
-  assert.equal(list.ingest_mode, "socket");
-  assert.equal(list.reactions, true);
-  assert.deepEqual(list.cc_channels, ["C0AAA", "C0BBB"]);
-
-  const inline = parseSlackConfig("cc_channels: [C1, \"C2\"]\nreactions: false\n");
-  assert.deepEqual(inline.cc_channels, ["C1", "C2"]);
-  assert.equal(inline.reactions, false);
-});
-
-test("cc_channels from config flow into the socket client opts", async () => {
-  const root = await makeRoot();
-  try {
-    await fsp.mkdir(join(root, "config"), { recursive: true });
-    await fsp.writeFile(join(root, "config/slack.yaml"), "ingest_mode: socket\nreactions: on\ncc_channels:\n  - C0WATCH\n");
-    const { a, captured } = makeAdapter(root, { slackConfig: undefined });
-    // slackConfig undefined → adapter loads config/slack.yaml itself.
-    const a2 = new SlackAdapter({ agentRoot: root, botToken: "x", createClient: () => ({ start: async () => {}, stop: () => {} }) });
-    assert.ok(a2._ccChannels.has("C0WATCH"));
-    assert.equal(a2._reactionsOn, true);
-    await a.start({ onInbound: () => {} });
-    void captured;
-  } finally { await rmRoot(root); }
-});