@cohortapp/agent-sdk 2.3.0

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

@@ -0,0 +1,753 @@
+/**
+ * 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: 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); }
+});