@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/scripts/poller/slack-socket-mode.test.mjs

@@ -1,805 +0,0 @@
-/**
- * slack-socket-mode.test.mjs — node:test coverage for slack-socket-mode.mjs
- *
- * Strategy: dependency-inject WebSocket, fetch, and writeInbox so every
- * test runs end-to-end without touching the network or persisting to disk.
- * The mock WebSocket exposes hooks for "Slack sent this envelope" and
- * captures every message the client sends back (for ack assertions).
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  shouldKeepEvent,
-  eventToInboxItem,
-  openSocketConnection,
-  nextBackoffMs,
-  createSocketModeClient,
-  loadAgentIdentity,
-  loadPeerSlackIds,
-  resolveSocketModeEnhancements,
-  RECONNECT_INITIAL_MS,
-  RECONNECT_MAX_MS,
-} from "./slack-socket-mode.mjs";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const AGENT_SLACK_ID = "UAGENT0001";
-const PEER_SOPHIE = "USOPHIE001";
-const PEER_LUCAS = "ULUCAS0001";
-const PRINCIPAL_SLACK_ID = "UCEO000001";
-const HUMAN_SLACK_ID = "UHUMAN0001";
-
-/**
- * Build a Socket Mode envelope mimicking what Slack actually sends.
- * Defaults are sensible enough that each test just overrides the fields
- * it cares about.
- */
-function makeEnvelope(overrides = {}) {
-  const event = {
-    type: "message",
-    user: HUMAN_SLACK_ID,
-    text: "hello",
-    ts: "1735689600.001000",
-    channel: "DCHANNEL01", // DM by default — prefix "D"
-    ...overrides.event,
-  };
-  return {
-    envelope_id: overrides.envelope_id || "envelope-abc-123",
-    type: overrides.type || "events_api",
-    accepts_response_payload: false,
-    payload: {
-      type: "event_callback",
-      event,
-      event_id: overrides.event_id || "Ev0001",
-      event_time: 1735689600,
-    },
-    ...(overrides.extra || {}),
-  };
-}
-
-/**
- * Create a fresh tmpdir for each test that needs one. Caller is
- * responsible for cleaning it up.
- */
-async function makeTmpRoot() {
-  const path = join(
-    tmpdir(),
-    `slack-socket-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-  );
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-
-async function rmRoot(path) {
-  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
-}
-
-// ---------------------------------------------------------------------------
-// shouldKeepEvent — filter tests
-// ---------------------------------------------------------------------------
-
-test("shouldKeepEvent keeps DM messages from humans", () => {
-  const envelope = makeEnvelope({
-    event: { user: HUMAN_SLACK_ID, channel: "DABCDEF01", text: "hey, can you help?" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set([PEER_SOPHIE]),
-  });
-  assert.equal(res.keep, true, res.reason);
-  assert.equal(res.reason, "dm");
-});
-
-test("shouldKeepEvent keeps channel @mentions of the agent", () => {
-  const envelope = makeEnvelope({
-    event: {
-      user: HUMAN_SLACK_ID,
-      channel: "C0CHANNEL1",
-      text: `hey <@${AGENT_SLACK_ID}> can you look at this`,
-    },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set(),
-  });
-  assert.equal(res.keep, true);
-  assert.equal(res.reason, "mention");
-});
-
-test("shouldKeepEvent drops channel messages without @mention", () => {
-  const envelope = makeEnvelope({
-    event: { user: HUMAN_SLACK_ID, channel: "C0CHANNEL1", text: "general chitchat" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set(),
-  });
-  assert.equal(res.keep, false);
-  assert.equal(res.reason, "no-mention-no-dm");
-});
-
-test("shouldKeepEvent drops the agent's own messages even in DMs", () => {
-  const envelope = makeEnvelope({
-    event: { user: AGENT_SLACK_ID, channel: "DABCDEF01", text: "I sent this myself" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set(),
-  });
-  assert.equal(res.keep, false);
-  assert.equal(res.reason, "self-message");
-});
-
-test("shouldKeepEvent drops peer-agent messages even in DMs", () => {
-  // Robin DMing Ravi about something — Ravi should not auto-respond.
-  const envelope = makeEnvelope({
-    event: { user: PEER_SOPHIE, channel: "DPEER00001", text: "hey ravi, status?" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set([PEER_SOPHIE, PEER_LUCAS]),
-  });
-  assert.equal(res.keep, false);
-  assert.equal(res.reason, "peer-agent");
-});
-
-test("shouldKeepEvent drops bot messages", () => {
-  const envelope = makeEnvelope({
-    event: { user: "", bot_id: "B12345", channel: "C0CHANNEL1", text: "deploy completed" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set(),
-  });
-  assert.equal(res.keep, false);
-  assert.equal(res.reason, "bot-message");
-});
-
-test("shouldKeepEvent allows thread_broadcast and file_share subtypes", () => {
-  for (const subtype of ["thread_broadcast", "file_share"]) {
-    const envelope = makeEnvelope({
-      event: {
-        user: HUMAN_SLACK_ID,
-        channel: "DABCDEF01",
-        text: "thread reply also broadcast",
-        subtype,
-        thread_ts: "1735689500.000100",
-      },
-    });
-    const res = shouldKeepEvent(envelope, {
-      ownSlackId: AGENT_SLACK_ID,
-      peerSlackIds: new Set(),
-    });
-    assert.equal(res.keep, true, `subtype ${subtype} should be kept: ${res.reason}`);
-  }
-});
-
-test("shouldKeepEvent drops channel_join and other system subtypes", () => {
-  const envelope = makeEnvelope({
-    event: { user: HUMAN_SLACK_ID, channel: "DABCDEF01", text: "joined", subtype: "channel_join" },
-  });
-  const res = shouldKeepEvent(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    peerSlackIds: new Set(),
-  });
-  assert.equal(res.keep, false);
-  assert.match(res.reason, /event-subtype-channel_join/);
-});
-
-test("shouldKeepEvent rejects non-events_api envelopes", () => {
-  const envelope = { envelope_id: "x", type: "slash_commands", payload: {} };
-  const res = shouldKeepEvent(envelope, { ownSlackId: AGENT_SLACK_ID, peerSlackIds: new Set() });
-  assert.equal(res.keep, false);
-  assert.match(res.reason, /envelope-type-slash_commands/);
-});
-
-test("shouldKeepEvent handles malformed envelopes safely", () => {
-  assert.equal(shouldKeepEvent(null, { ownSlackId: AGENT_SLACK_ID, peerSlackIds: new Set() }).keep, false);
-  assert.equal(shouldKeepEvent({}, { ownSlackId: AGENT_SLACK_ID, peerSlackIds: new Set() }).keep, false);
-  const noEvent = { type: "events_api", payload: {} };
-  assert.equal(shouldKeepEvent(noEvent, { ownSlackId: AGENT_SLACK_ID, peerSlackIds: new Set() }).keep, false);
-});
-
-// ---------------------------------------------------------------------------
-// eventToInboxItem — translation tests
-// ---------------------------------------------------------------------------
-
-test("eventToInboxItem: DM event → poller-compatible inbox item", () => {
-  const envelope = makeEnvelope({
-    event: {
-      user: HUMAN_SLACK_ID,
-      channel: "DABCDEF01",
-      text: "hey, can you draft the board memo?",
-      ts: "1735689600.001000",
-    },
-  });
-  const item = eventToInboxItem(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    principalSlackId: PRINCIPAL_SLACK_ID,
-    agentFirstName: "Ravi",
-  });
-  assert.equal(item.id, "1735689600-001000");
-  assert.equal(item.service, "slack");
-  assert.equal(item.channel_id, "DABCDEF01");
-  assert.match(item.channel, /^dm\//);
-  assert.match(item.subject, /^DM from /);
-  assert.equal(item.content, "hey, can you draft the board memo?");
-  assert.equal(item.priority_signals.mentions_agent, true, "DM always mentions agent");
-  assert.equal(item.priority_signals.from_ceo, false);
-  assert.equal(item.is_reply, false);
-  assert.equal(item.raw_ref, "slack:DABCDEF01:1735689600.001000");
-  assert.equal(item.source, "socket-mode");
-});
-
-test("eventToInboxItem: channel @mention sets the right priority signals", () => {
-  const envelope = makeEnvelope({
-    event: {
-      user: PRINCIPAL_SLACK_ID,
-      channel: "C0CHANNEL1",
-      text: `<@${AGENT_SLACK_ID}> urgent — please review the deck`,
-      ts: "1735689700.002000",
-    },
-  });
-  const item = eventToInboxItem(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    principalSlackId: PRINCIPAL_SLACK_ID,
-    agentFirstName: "Ravi",
-  });
-  assert.equal(item.priority_signals.from_ceo, true);
-  assert.equal(item.priority_signals.tagged_urgent, true);
-  assert.equal(item.priority_signals.mentions_agent, true);
-  assert.equal(item.channel, "C0CHANNEL1");
-  assert.match(item.subject, /^#C0CHANNEL1/);
-});
-
-test("eventToInboxItem: thread reply preserves thread_id + is_reply", () => {
-  const envelope = makeEnvelope({
-    event: {
-      user: HUMAN_SLACK_ID,
-      channel: "C0CHANNEL1",
-      text: `<@${AGENT_SLACK_ID}> following up on this`,
-      ts: "1735689800.003000",
-      thread_ts: "1735689500.000100",
-    },
-  });
-  const item = eventToInboxItem(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    principalSlackId: PRINCIPAL_SLACK_ID,
-    agentFirstName: "Ravi",
-  });
-  assert.equal(item.is_reply, true);
-  assert.equal(item.thread_id, "1735689500.000100");
-});
-
-test("eventToInboxItem: carries Slack's channel_type as the privacy signal", () => {
-  // CONFIDENTIALITY. The listener used to drop `event.channel_type` entirely and
-  // derive privacy from the id prefix alone — but Slack mints `C…` ids for
-  // PRIVATE channels too, so downstream (the daemon's fail-closed outcome gate)
-  // had nothing dependable to admit on. Every kept event now carries the type,
-  // and the booleans it implies, verbatim off the envelope.
-  const mk = (channel, channelType) => eventToInboxItem(
-    makeEnvelope({
-      event: {
-        user: HUMAN_SLACK_ID,
-        channel,
-        ...(channelType === undefined ? {} : { channel_type: channelType }),
-        text: `<@${AGENT_SLACK_ID}> noted`,
-        ts: "1735689700.002000",
-      },
-    }),
-    { ownSlackId: AGENT_SLACK_ID, principalSlackId: PRINCIPAL_SLACK_ID, agentFirstName: "Ravi" }
-  );
-
-  const pub = mk("C0CHANNEL1", "channel");
-  assert.equal(pub.channel_type, "channel");
-  assert.equal(pub.is_private, false);
-  assert.equal(pub.is_dm, false);
-
-  // A private channel WITH a public-looking `C…` id — the leak vector.
-  const priv = mk("C0PRIVATE1", "group");
-  assert.equal(priv.channel_type, "group");
-  assert.equal(priv.is_private, true);
-
-  const mpim = mk("C0MPIM0001", "mpim");
-  assert.equal(mpim.channel_type, "mpim");
-  assert.equal(mpim.is_private, true);
-  assert.equal(mpim.is_dm, true);
-  assert.equal(mpim.channel, "C0MPIM0001", "an mpim is still routed as a channel, not promoted to a DM");
-
-  const im = mk("DABCDEF01", "im");
-  assert.equal(im.channel_type, "im");
-  assert.equal(im.is_private, true);
-  assert.equal(im.is_dm, true);
-
-  // No type on the envelope ⇒ assert NOTHING (a defaulted `is_private:false`
-  // would forge a public verdict the gate then admits on).
-  const unknown = mk("C0CHANNEL1", undefined);
-  assert.equal("channel_type" in unknown, false);
-  assert.equal("is_private" in unknown, false);
-  assert.equal("is_dm" in unknown, false);
-
-  // An unrecognised type is likewise not decoded into a verdict.
-  const weird = mk("C0CHANNEL1", "external_shared");
-  assert.equal("is_private" in weird, false);
-});
-
-test("eventToInboxItem: first-name mention (no @) still flips mentions_agent", () => {
-  // "Hey Ravi, can you …" in a channel — no explicit @-mention but the
-  // agent's first name appears. The poller uses this same heuristic.
-  const envelope = makeEnvelope({
-    event: {
-      user: HUMAN_SLACK_ID,
-      channel: "C0CHANNEL1",
-      text: "hey Ravi, what's the latest on the model registry?",
-      ts: "1735689900.004000",
-    },
-  });
-  const item = eventToInboxItem(envelope, {
-    ownSlackId: AGENT_SLACK_ID,
-    principalSlackId: PRINCIPAL_SLACK_ID,
-    agentFirstName: "Ravi",
-  });
-  assert.equal(item.priority_signals.mentions_agent, true);
-});
-
-// ---------------------------------------------------------------------------
-// openSocketConnection — fetch wrapper tests
-// ---------------------------------------------------------------------------
-
-test("openSocketConnection returns the URL on success", async () => {
-  const fakeFetch = async () => ({
-    json: async () => ({ ok: true, url: "wss://wss-primary.slack.com/link/?ticket=abc" }),
-  });
-  const res = await openSocketConnection({ appToken: "xapp-1-abc", fetchFn: fakeFetch });
-  assert.equal(res.url, "wss://wss-primary.slack.com/link/?ticket=abc");
-});
-
-test("openSocketConnection surfaces Slack errors verbatim", async () => {
-  const fakeFetch = async () => ({
-    json: async () => ({ ok: false, error: "invalid_auth" }),
-  });
-  const res = await openSocketConnection({ appToken: "xapp-1-abc", fetchFn: fakeFetch });
-  assert.equal(res.error, "invalid_auth");
-});
-
-test("openSocketConnection rejects when token missing", async () => {
-  const res = await openSocketConnection({ appToken: "", fetchFn: async () => ({}) });
-  assert.equal(res.error, "missing-app-token");
-});
-
-// ---------------------------------------------------------------------------
-// nextBackoffMs — exponential back-off with jitter
-// ---------------------------------------------------------------------------
-
-test("nextBackoffMs doubles up to RECONNECT_MAX_MS", () => {
-  let cur = RECONNECT_INITIAL_MS;
-  let prev = cur;
-  for (let i = 0; i < 8; i++) {
-    cur = nextBackoffMs(cur);
-    assert.ok(cur >= prev, `backoff should not decrease: ${prev} → ${cur}`);
-    assert.ok(cur <= RECONNECT_MAX_MS * 1.5, `backoff capped near max: ${cur}`);
-    prev = cur;
-  }
-  // After many doublings, we're at or near the cap.
-  assert.ok(cur >= RECONNECT_MAX_MS * 0.9, `eventually approaches max: ${cur}`);
-});
-
-// ---------------------------------------------------------------------------
-// MockWebSocket — used by client integration tests
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal WebSocket polyfill that captures every send and lets the test
- * synthesise inbound frames. Mirrors the global WebSocket API surface
- * the client uses: readyState (constant 1 = OPEN), addEventListener,
- * send, close.
- */
-class MockWebSocket {
-  static instances = [];
-  constructor(url) {
-    this.url = url;
-    this.readyState = 1; // OPEN
-    this.sent = [];
-    this.listeners = { open: [], message: [], error: [], close: [] };
-    MockWebSocket.instances.push(this);
-    // Fire `open` on the next tick so the client gets a chance to attach
-    // its listeners.
-    queueMicrotask(() => this.dispatch("open", {}));
-  }
-  addEventListener(type, fn) {
-    if (!this.listeners[type]) this.listeners[type] = [];
-    this.listeners[type].push(fn);
-  }
-  dispatch(type, event) {
-    for (const fn of this.listeners[type] || []) {
-      try { fn(event); } catch (err) { /* swallow */ }
-    }
-  }
-  send(data) {
-    this.sent.push(data);
-  }
-  close(code = 1000, reason = "") {
-    this.readyState = 3; // CLOSED
-    this.dispatch("close", { code, reason });
-  }
-  /** test helper: simulate Slack pushing an envelope. */
-  push(envelope) {
-    const raw = typeof envelope === "string" ? envelope : JSON.stringify(envelope);
-    this.dispatch("message", { data: raw });
-  }
-}
-
-/**
- * Wait for a predicate to become truthy, polling every 5ms.
- */
-async function waitFor(predicate, { timeoutMs = 2000 } = {}) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await predicate()) return true;
-    await new Promise((r) => setTimeout(r, 5));
-  }
-  return false;
-}
-
-// ---------------------------------------------------------------------------
-// Client integration tests
-// ---------------------------------------------------------------------------
-
-test("client acks every envelope and writes inbox for DM events", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-  let client;
-  try {
-    const writes = [];
-    client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi",
-        fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set([PEER_SOPHIE]),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: (service, item) => writes.push({ service, item }),
-    });
-    await client.start();
-    await waitFor(() => MockWebSocket.instances.length > 0);
-    const ws = MockWebSocket.instances[0];
-
-    ws.push({ type: "hello", num_connections: 1, debug_info: {} });
-    ws.push(makeEnvelope({
-      envelope_id: "env-1",
-      event: { user: HUMAN_SLACK_ID, channel: "DABC", text: "hey, draft the memo" },
-    }));
-
-    await waitFor(() => writes.length === 1);
-    assert.equal(writes.length, 1);
-    assert.equal(writes[0].service, "slack");
-    assert.equal(writes[0].item.channel_id, "DABC");
-    assert.equal(writes[0].item.priority_signals.mentions_agent, true);
-
-    // One ack for the events_api envelope. The `hello` envelope has no
-    // envelope_id so it isn't acked.
-    assert.equal(ws.sent.length, 1);
-    const ackPayload = JSON.parse(ws.sent[0]);
-    assert.equal(ackPayload.envelope_id, "env-1");
-  } finally {
-    client?.stop();
-    await rmRoot(root);
-  }
-});
-
-test("client skips bot messages and the agent's own messages without writing inbox", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-  let client;
-  try {
-    const writes = [];
-    client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi",
-        fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set(),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: (service, item) => writes.push({ service, item }),
-    });
-    await client.start();
-    await waitFor(() => MockWebSocket.instances.length > 0);
-    const ws = MockWebSocket.instances[0];
-
-    ws.push(makeEnvelope({
-      envelope_id: "env-bot",
-      event: { user: "", bot_id: "B1", channel: "C1", text: "auto deploy" },
-    }));
-    ws.push(makeEnvelope({
-      envelope_id: "env-self",
-      event: { user: AGENT_SLACK_ID, channel: "DSELF", text: "I sent this" },
-    }));
-
-    // Both get acked but neither hits writeInbox.
-    await waitFor(() => ws.sent.length === 2);
-    assert.equal(writes.length, 0, "no inbox writes for bot/self messages");
-    const ackIds = ws.sent.map((m) => JSON.parse(m).envelope_id).sort();
-    assert.deepEqual(ackIds, ["env-bot", "env-self"]);
-  } finally {
-    client?.stop();
-    await rmRoot(root);
-  }
-});
-
-test("client skips messages from peer agents", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-  let client;
-  try {
-    const writes = [];
-    client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi",
-        fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set([PEER_SOPHIE, PEER_LUCAS]),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: (service, item) => writes.push({ service, item }),
-    });
-    await client.start();
-    await waitFor(() => MockWebSocket.instances.length > 0);
-    const ws = MockWebSocket.instances[0];
-
-    // Peer agent DMs Ravi — drop, but ack so Slack doesn't redeliver.
-    ws.push(makeEnvelope({
-      envelope_id: "env-peer",
-      event: { user: PEER_SOPHIE, channel: "DPEER", text: "fyi from robin" },
-    }));
-
-    await waitFor(() => ws.sent.length === 1);
-    assert.equal(writes.length, 0);
-    assert.equal(JSON.parse(ws.sent[0]).envelope_id, "env-peer");
-  } finally {
-    client?.stop();
-    await rmRoot(root);
-  }
-});
-
-test("client schedules a reconnect on socket close", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-
-  // Capture setTimeout calls so we can assert the reconnect was scheduled.
-  const scheduled = [];
-  const fakeSetTimeout = (fn, ms) => {
-    scheduled.push({ fn, ms });
-    return { _id: scheduled.length - 1 };
-  };
-  const fakeClearTimeout = () => { /* noop */ };
-
-  try {
-    const client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi",
-        fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set(),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: () => {},
-      setTimeout: fakeSetTimeout,
-      clearTimeout: fakeClearTimeout,
-    });
-    await client.start();
-    await waitFor(() => MockWebSocket.instances.length > 0);
-    const ws = MockWebSocket.instances[0];
-
-    // Simulate Slack closing the socket.
-    ws.dispatch("close", { code: 1006, reason: "server-restart" });
-
-    // A reconnect must have been scheduled with the initial backoff.
-    const reconnect = scheduled.find((s) => s.ms >= RECONNECT_INITIAL_MS && s.ms <= RECONNECT_MAX_MS * 2);
-    assert.ok(reconnect, `expected reconnect scheduled, got: ${JSON.stringify(scheduled.map((s) => s.ms))}`);
-  } finally {
-    await rmRoot(root);
-  }
-});
-
-test("client handles 'disconnect' envelope by closing + scheduling reconnect", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-  let client;
-  try {
-    client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi",
-        fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set(),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: () => {},
-    });
-    await client.start();
-    await waitFor(() => MockWebSocket.instances.length > 0);
-    const ws = MockWebSocket.instances[0];
-
-    // Slack's polite "please reconnect" message.
-    ws.push({ type: "disconnect", reason: "refresh_requested" });
-
-    // Socket should now be closed.
-    await waitFor(() => ws.readyState === 3, { timeoutMs: 1000 });
-    assert.equal(ws.readyState, 3);
-  } finally {
-    client?.stop();
-    await rmRoot(root);
-  }
-});
-
-test("client refuses to connect when .emergency-stop present", async () => {
-  MockWebSocket.instances = [];
-  const root = await makeTmpRoot();
-  writeFileSync(join(root, ".emergency-stop"), "");
-  try {
-    const client = createSocketModeClient({
-      agentRoot: root,
-      appToken: "xapp-test-token",
-      identity: {
-        firstName: "Ravi", fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID, principalSlackId: PRINCIPAL_SLACK_ID,
-      },
-      peerSlackIds: new Set(),
-      fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://example/ws" }) }),
-      WebSocketCtor: MockWebSocket,
-      writeInbox: () => {},
-    });
-    await client.start();
-    // Give it a couple of ticks; no socket should be constructed.
-    await new Promise((r) => setTimeout(r, 50));
-    assert.equal(MockWebSocket.instances.length, 0, "no socket should open under emergency stop");
-    client.stop();
-  } finally {
-    await rmRoot(root);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// loadAgentIdentity / loadPeerSlackIds — config readers
-// ---------------------------------------------------------------------------
-
-test("loadAgentIdentity returns safe defaults for missing config", () => {
-  const id = loadAgentIdentity("/no/such/path");
-  assert.equal(id.firstName, "Agent");
-  assert.equal(id.slackMemberId, "");
-});
-
-test("loadAgentIdentity reads firstName + slackMemberId from agent.json", async () => {
-  const root = await makeTmpRoot();
-  try {
-    mkdirSync(join(root, "config"), { recursive: true });
-    writeFileSync(
-      join(root, "config/agent.json"),
-      JSON.stringify({
-        firstName: "Ravi", fullName: "Jamie Lee",
-        slackMemberId: AGENT_SLACK_ID,
-        principal: { slackMemberId: PRINCIPAL_SLACK_ID },
-      }),
-    );
-    const id = loadAgentIdentity(root);
-    assert.equal(id.firstName, "Ravi");
-    assert.equal(id.slackMemberId, AGENT_SLACK_ID);
-    assert.equal(id.principalSlackId, PRINCIPAL_SLACK_ID);
-  } finally { await rmRoot(root); }
-});
-
-test("loadPeerSlackIds excludes the agent's own slack id", async () => {
-  const root = await makeTmpRoot();
-  try {
-    mkdirSync(join(root, "config"), { recursive: true });
-    writeFileSync(
-      join(root, "config/known-agents.json"),
-      JSON.stringify({
-        agents: [
-          { name: "Ravi", slackId: AGENT_SLACK_ID, repo: "ravi-ai" },
-          { name: "Robin", slackId: PEER_SOPHIE, repo: "robin-ai" },
-          { name: "Lucas", slackId: PEER_LUCAS, repo: "lucas-ai" },
-        ],
-      }),
-    );
-    const ids = loadPeerSlackIds(root, AGENT_SLACK_ID);
-    assert.equal(ids.size, 2);
-    assert.ok(ids.has(PEER_SOPHIE));
-    assert.ok(ids.has(PEER_LUCAS));
-    assert.ok(!ids.has(AGENT_SLACK_ID));
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Single-owner rule (H2 part b) — enabling config/slack.yaml ENHANCES this one
-// connection (reactions / cc / enrich) instead of spawning a second one. The
-// daemon's generic loop already excludes Slack (contract.test.mjs); these tests
-// prove the SOLE owner picks up the slack.yaml opts and threads them into the
-// single createSocketModeClient.
-// ---------------------------------------------------------------------------
-
-const IDENTITY = { firstName: "Ravi", slackMemberId: AGENT_SLACK_ID, principalSlackId: "UCEO000001" };
-
-test("H2: with no config/slack.yaml, enhancements default to reactions-on, no cc", async () => {
-  const root = await makeTmpRoot();
-  try {
-    const { reactions, ccChannels, enrich } = await resolveSocketModeEnhancements(root, IDENTITY, { botToken: "xoxb-x" });
-    assert.equal(reactions, true, "reactions default on (mirrors the adapter default)");
-    assert.equal(ccChannels, null, "no cc channels without config");
-    assert.equal(typeof enrich, "function", "an enrich hook is still wired (fail-open Web-API enrichment)");
-  } finally { await rmRoot(root); }
-});
-
-test("H2: config/slack.yaml reactions/cc flow into the single listener's client opts", async () => {
-  const root = await makeTmpRoot();
-  try {
-    await fsp.mkdir(join(root, "config"), { recursive: true });
-    await fsp.writeFile(join(root, "config/slack.yaml"), "ingest_mode: socket\nreactions: false\ncc_channels:\n  - C0WATCH\n  - C0AUDIT\n");
-
-    const enh = await resolveSocketModeEnhancements(root, IDENTITY, { botToken: "xoxb-x" });
-    assert.equal(enh.reactions, false, "reactions:false in config disables them on the single connection");
-    assert.ok(enh.ccChannels instanceof Set);
-    assert.deepEqual([...enh.ccChannels].sort(), ["C0AUDIT", "C0WATCH"]);
-
-    // End-to-end at the client boundary: the SAME opts reach the one client,
-    // proving enhancement-not-duplication. Inject WebSocket/fetch so nothing
-    // touches the network; capture what the single client ingests.
-    MockWebSocket.instances = [];
-    const seen = [];
-    let client;
-    try {
-      client = createSocketModeClient({
-        agentRoot: root,
-        appToken: "xapp-x",
-        identity: IDENTITY,
-        peerSlackIds: new Set(),
-        reactions: enh.reactions,
-        ccChannels: enh.ccChannels,
-        // No enrich here: a channel_cc message isn't a thread reply, so the
-        // sync path is exercised; enrich wiring is covered by the adapter tests.
-        WebSocketCtor: MockWebSocket,
-        fetchFn: async () => ({ json: async () => ({ ok: true, url: "wss://x" }) }),
-        writeInbox: (_svc, item) => seen.push(item),
-      });
-      await client.start();
-      await waitFor(() => MockWebSocket.instances.length > 0);
-      const ws = MockWebSocket.instances[0];
-      // A cc-channel message (non-@mention) must be KEPT now that cc is wired —
-      // proving the config opt reached the live client.
-      ws.push(makeEnvelope({ event: { user: HUMAN_SLACK_ID, text: "fyi team", channel: "C0WATCH" } }));
-      await waitFor(() => seen.length >= 1);
-      assert.equal(seen.length, 1, "cc-channel message ingested via the single connection");
-      assert.equal(seen[0].kind, "channel_cc", "kept as channel_cc per the wired cc_channels");
-    } finally { client?.stop(); }
-  } finally { await rmRoot(root); }
-});