@cohortapp/agent-sdk 2.17.0 → 2.18.5

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

@@ -1,590 +0,0 @@
-/**
- * base-adapter.test.mjs — node:test coverage for lib/channels/base-adapter.mjs
- *
- * Uses a fake concrete adapter that records _setTyping calls and lets the test
- * drive raw frames through _connect's onRaw. Injects fake timers so the typing
- * heartbeat is deterministic and no real intervals leak. Hermetic — no network.
- */
-
-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 { BaseAdapter, CHANNEL_COUNTERS } from "./base-adapter.mjs";
-import { appendToAllowlist } from "./pairing.mjs";
-import { createHookBus } from "../hooks/bus.mjs";
-import { CONN_STATE } from "../util/reconnect.mjs";
-
-async function makeRoot() {
-  const p = join(tmpdir(), `base-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 { /* */ } }
-
-/**
- * A fake adapter: _connect stashes onRaw so the test can push frames;
- * _toEvent treats a raw frame as a partial MessageEvent; _send/_setTyping
- * record calls.
- */
-class FakeAdapter extends BaseAdapter {
-  constructor(opts) {
-    super({ name: "fake", ...opts });
-    this.sent = [];
-    this.typingCalls = [];
-    this.pushRaw = null;
-  }
-  async _connect({ onRaw }) {
-    this.pushRaw = onRaw; // test drives frames via this.pushRaw(raw)
-  }
-  _toEvent(raw) {
-    if (raw === null || raw === undefined) return null;
-    if (raw.__throw) throw new Error("boom in _toEvent");
-    return raw; // raw is already a MessageEvent-shaped object
-  }
-  async _send(out) {
-    this.sent.push(out);
-    return { ok: true, message_id: `m-${this.sent.length}` };
-  }
-  async _setTyping(source, on) {
-    this.typingCalls.push({ key: `${source.chatId}:${source.threadRef || ""}`, on });
-  }
-}
-
-/**
- * Build a FakeAdapter wired for hermetic tests: an in-memory counter capture
- * (so we assert fail-opens without touching disk), a fresh isolated HookBus (so
- * subscriptions don't leak across cases or hit the process singleton), and — by
- * default — an allow-all screenOutbound stub so a test that doesn't care about
- * the policy gate isn't blocked by the fail-closed-external default. Pass
- * `screenOutbound` to drive the real gate behaviour.
- */
-function makeFake(opts = {}) {
-  const counters = [];
-  const bus = opts.hookBus || createHookBus();
-  const a = new FakeAdapter({
-    agentRoot: opts.agentRoot,
-    hookBus: bus,
-    bump: (name, attrs) => { counters.push({ name, attrs }); return 1; },
-    screenOutbound: opts.screenOutbound || (async () => ({ allow: true, reason: "" })),
-    ...opts,
-  });
-  return { a, counters, bus, countOf: (name) => counters.filter((c) => c.name === name).length };
-}
-
-function fakeTimers() {
-  let nextId = 1;
-  const intervals = new Map();
-  return {
-    setInterval: (fn, ms) => { const id = nextId++; intervals.set(id, { fn, ms }); return id; },
-    clearInterval: (id) => { intervals.delete(id); },
-    setTimeout: () => 0,
-    clearTimeout: () => {},
-    intervals,
-    tick(id) { intervals.get(id)?.fn(); },
-  };
-}
-
-function dmEvent(channel, senderId, text = "hi") {
-  return {
-    channel,
-    text,
-    from: { id: senderId },
-    timestamp: "2026-01-01T00:00:00.000Z",
-    source: { channel, chatId: senderId, userScope: "dm", peerId: senderId },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// pairing gate in the onInbound wrapper
-// ---------------------------------------------------------------------------
-
-test("start() drops unknown DM senders (default-deny)", async () => {
-  const root = await makeRoot();
-  try {
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "U-stranger"));
-    assert.equal(received.length, 0, "unknown DM must be blocked");
-  } finally { await rmRoot(root); }
-});
-
-test("start() admits a paired DM sender", async () => {
-  const root = await makeRoot();
-  try {
-    appendToAllowlist(root, "fake", "U-known");
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "U-known", "hello there"));
-    assert.equal(received.length, 1);
-    assert.equal(received[0].from.id, "U-known");
-    assert.equal(received[0].channel, "fake");
-  } finally { await rmRoot(root); }
-});
-
-test("start() intercepts `pair <code>` before onInbound and never forwards it", async () => {
-  const root = await makeRoot();
-  try {
-    // Mint a code by writing the pairing file via startPairing.
-    const { startPairing } = await import("./pairing.mjs");
-    const { code } = startPairing("fake", { agentRoot: root, ttlMs: 60_000 });
-
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "U-new", `pair ${code}`));
-
-    // The pair command is intercepted — not forwarded to onInbound.
-    assert.equal(received.length, 0, "pair command must not reach the classifier");
-    // Give the async redeem + ack a tick.
-    await new Promise((r) => setTimeout(r, 10));
-    // The sender is now on the allowlist; a follow-up normal DM is admitted.
-    a.pushRaw(dmEvent("fake", "U-new", "now I'm in"));
-    assert.equal(received.length, 1);
-    // An acknowledgement was sent back.
-    assert.ok(a.sent.length >= 1);
-  } finally { await rmRoot(root); }
-});
-
-test("start() emits a one-time pairing prompt to an unknown DM sender", async () => {
-  const root = await makeRoot();
-  try {
-    const prompts = [];
-    const a = new FakeAdapter({ agentRoot: root, onPairingPrompt: (src) => { prompts.push(src); } });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "U-x"));
-    a.pushRaw(dmEvent("fake", "U-x")); // second message from same stranger
-    await new Promise((r) => setTimeout(r, 10));
-    assert.equal(prompts.length, 1, "prompt must fire exactly once per unknown sender");
-  } finally { await rmRoot(root); }
-});
-
-test("start() drops self-messages and peer-agent messages", async () => {
-  const root = await makeRoot();
-  try {
-    appendToAllowlist(root, "fake", "U-self");
-    appendToAllowlist(root, "fake", "U-peer");
-    const a = new FakeAdapter({ agentRoot: root, ownId: "U-self", peerAgentIds: new Set(["U-peer"]) });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "U-self", "my own echo"));
-    a.pushRaw(dmEvent("fake", "U-peer", "from another agent"));
-    assert.equal(received.length, 0, "self + peer messages must be dropped even if allowlisted");
-  } finally { await rmRoot(root); }
-});
-
-test("start() group messages bypass pairing and are forwarded", async () => {
-  const root = await makeRoot();
-  try {
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw({
-      channel: "fake",
-      text: "team chatter",
-      from: { id: "U-anyone" },
-      timestamp: "2026-01-01T00:00:00.000Z",
-      source: { channel: "fake", chatId: "G1", userScope: "group", peerId: "U-anyone" },
-    });
-    assert.equal(received.length, 1, "group traffic bypasses the pairing gate");
-  } finally { await rmRoot(root); }
-});
-
-test("_toEvent throwing drops the frame without crashing the loop", async () => {
-  const root = await makeRoot();
-  try {
-    appendToAllowlist(root, "fake", "U-known");
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    assert.doesNotThrow(() => a.pushRaw({ __throw: true }));
-    a.pushRaw(dmEvent("fake", "U-known"));
-    assert.equal(received.length, 1, "loop survives a bad frame and processes the next");
-  } finally { await rmRoot(root); }
-});
-
-test("_toEvent returning null drops the frame", async () => {
-  const root = await makeRoot();
-  try {
-    const a = new FakeAdapter({ agentRoot: root });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(null);
-    assert.equal(received.length, 0);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// typing heartbeat
-// ---------------------------------------------------------------------------
-
-test("startTypingHeartbeat fires immediately and on each tick; stop clears it", async () => {
-  const root = await makeRoot();
-  try {
-    const timers = fakeTimers();
-    const a = new FakeAdapter({ agentRoot: root, ...timers });
-    const source = { channel: "fake", chatId: "C1", userScope: "dm" };
-
-    const key = a.startTypingHeartbeat(source);
-    // Immediate fire.
-    await new Promise((r) => setTimeout(r, 5));
-    assert.equal(a.typingCalls.filter((c) => c.on).length, 1, "fires once immediately");
-    // An interval was registered.
-    assert.equal(timers.intervals.size, 1);
-
-    // Tick the interval → another typing=true call.
-    const intervalId = [...timers.intervals.keys()][0];
-    timers.tick(intervalId);
-    await new Promise((r) => setTimeout(r, 5));
-    assert.equal(a.typingCalls.filter((c) => c.on).length, 2);
-
-    // Stop clears the interval and best-effort clears the indicator (on:false).
-    a.stopTypingHeartbeat(source);
-    assert.equal(timers.intervals.size, 0, "interval cleared on stop");
-    await new Promise((r) => setTimeout(r, 5));
-    assert.ok(a.typingCalls.some((c) => c.on === false), "indicator cleared");
-
-    // Idempotent: stopping again or by key is safe.
-    a.stopTypingHeartbeat(key);
-  } finally { await rmRoot(root); }
-});
-
-test("startTypingHeartbeat is idempotent per conversation key", async () => {
-  const root = await makeRoot();
-  try {
-    const timers = fakeTimers();
-    const a = new FakeAdapter({ agentRoot: root, ...timers });
-    const source = { channel: "fake", chatId: "C1", userScope: "dm" };
-    a.startTypingHeartbeat(source);
-    a.startTypingHeartbeat(source); // second call must not register a 2nd interval
-    assert.equal(timers.intervals.size, 1);
-    a.stopAllTyping();
-    assert.equal(timers.intervals.size, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("stop() halts all typing heartbeats", async () => {
-  const root = await makeRoot();
-  try {
-    const timers = fakeTimers();
-    const a = new FakeAdapter({ agentRoot: root, ...timers });
-    a.startTypingHeartbeat({ channel: "fake", chatId: "C1" });
-    a.startTypingHeartbeat({ channel: "fake", chatId: "C2" });
-    assert.equal(timers.intervals.size, 2);
-    await a.stop();
-    assert.equal(timers.intervals.size, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("send() shapes thrown errors into a SendResult", async () => {
-  const root = await makeRoot();
-  try {
-    // This case is about TRANSPORT error shaping (the gate is exercised
-    // separately below), so the send-gate is disabled to reach _send.
-    class Boom extends FakeAdapter { async _send() { throw new Error("network down"); } }
-    const a = new Boom({ agentRoot: root, sendGate: false, supervise: false });
-    const res = await a.send({ to: "x", text: "hi" });
-    assert.equal(res.ok, false);
-    assert.equal(res.error, "network down");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// P0-3: outbound send-gate — every adapter send passes the gate before _send
-// ---------------------------------------------------------------------------
-
-test("send() blocks a banned-phrase message before _send and returns a uniform blocked SendResult", async () => {
-  const root = await makeRoot();
-  try {
-    // Drive the REAL send-gate (lib/comms/send-gate) — no stub — so a banned
-    // AI-tell phrase is caught at the shared chokepoint. Recipient is a Slack id
-    // → classified internal so the missing-policy fail-closed path doesn't fire;
-    // this isolates the banned-phrase rule.
-    const { a, countOf } = makeFake({ agentRoot: root, screenOutbound: undefined });
-    a._screenOutbound = (await import("../comms/send-gate.mjs")).screenOutbound;
-
-    const res = await a.send({
-      to: "C0123456",
-      text: "Sure — as an AI I can help with that.",
-      source: { channel: "slack", chatId: "C0123456" },
-    });
-    assert.equal(res.ok, false);
-    assert.equal(res.blocked, true, "blocked flag set");
-    assert.match(res.reason, /banned AI-tell|As an AI/i);
-    assert.equal(a.sent.length, 0, "_send must never run for a blocked message");
-    assert.equal(countOf(CHANNEL_COUNTERS.SEND_GATE_BLOCKED), 1, "the block is counted");
-  } finally { await rmRoot(root); }
-});
-
-test("send() blocks a disclosure-violating message (denies being an AI)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeFake({ agentRoot: root, screenOutbound: undefined });
-    a._screenOutbound = (await import("../comms/send-gate.mjs")).screenOutbound;
-    const res = await a.send({
-      to: "C0123456",
-      text: "No, I'm not a bot — I'm a real person.",
-      source: { channel: "slack", chatId: "C0123456" },
-    });
-    assert.equal(res.ok, false);
-    assert.equal(res.blocked, true);
-    assert.match(res.reason, /disclosure|denies AI/i);
-    assert.equal(a.sent.length, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("send() honours a hook-bus beforeSend veto (subscriber cancels the send)", async () => {
-  const root = await makeRoot();
-  try {
-    const bus = createHookBus();
-    bus.subscribe(
-      "beforeSend",
-      (ctx) => (/secret-project/i.test(ctx.text) ? { cancel: true, reason: "policy-veto" } : undefined),
-      { priority: 100 },
-    );
-    const { a } = makeFake({ agentRoot: root, hookBus: bus }); // screenOutbound allow-all
-    const res = await a.send({ to: "C1", text: "ship secret-project today", source: { channel: "slack", chatId: "C1" } });
-    assert.equal(res.ok, false);
-    assert.equal(res.blocked, true);
-    assert.equal(res.reason, "policy-veto");
-    assert.equal(a.sent.length, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("send() lets a clean message through the gate to _send", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeFake({ agentRoot: root }); // allow-all stub gate
-    const res = await a.send({ to: "C1", text: "the memo is ready for your review", source: { channel: "slack", chatId: "C1" } });
-    assert.equal(res.ok, true);
-    assert.equal(a.sent.length, 1, "_send ran exactly once for a clean message");
-  } finally { await rmRoot(root); }
-});
-
-test("a buggy send-gate fails OPEN but is counted (never silently wedges all sends)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, countOf } = makeFake({
-      agentRoot: root,
-      screenOutbound: async () => { throw new Error("gate exploded"); },
-    });
-    const res = await a.send({ to: "C1", text: "hi", source: { channel: "slack", chatId: "C1" } });
-    assert.equal(res.ok, true, "fail-open: a thrown gate must not block the send");
-    assert.equal(a.sent.length, 1);
-    assert.equal(countOf(CHANNEL_COUNTERS.SEND_GATE_FAILOPEN), 1, "fail-open is counted (loud)");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// P0-5: ownership / bot-loop guard
-// ---------------------------------------------------------------------------
-
-test("a peer-agent inbound is dropped (no auto-reply) in deny mode", async () => {
-  const root = await makeRoot();
-  try {
-    appendToAllowlist(root, "fake", "A-peer"); // even allowlisted, a peer is dropped
-    const { a, countOf } = makeFake({ agentRoot: root, peerAgentIds: new Set(["A-peer"]) });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw(dmEvent("fake", "A-peer", "ack"));
-    assert.equal(received.length, 0, "a known peer-agent message must never be auto-replied");
-    assert.equal(countOf(CHANNEL_COUNTERS.PEER_AGENT_DROPPED), 1);
-  } finally { await rmRoot(root); }
-});
-
-test("a peer-agent inbound is dropped even in 'open' pairing mode (Slack-style)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, countOf } = makeFake({
-      agentRoot: root,
-      pairingMode: "open",
-      peerAgentIds: ["A-peer"],
-    });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    // group/open event from a peer agent: directed-gate alone wouldn't stop the loop.
-    a.pushRaw({
-      channel: "fake",
-      text: "your turn",
-      from: { id: "A-peer" },
-      timestamp: "2026-01-01T00:00:00.000Z",
-      source: { channel: "fake", chatId: "G1", userScope: "group", peerId: "A-peer" },
-    });
-    assert.equal(received.length, 0, "peer-agent dropped in open mode too");
-    assert.equal(countOf(CHANNEL_COUNTERS.PEER_AGENT_DROPPED), 1);
-  } finally { await rmRoot(root); }
-});
-
-test("a non-peer inbound still flows in open mode (no over-blocking)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeFake({ agentRoot: root, pairingMode: "open", peerAgentIds: ["A-peer"] });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    a.pushRaw({
-      channel: "fake", text: "hi from a human", from: { id: "U-human" },
-      timestamp: "2026-01-01T00:00:00.000Z",
-      source: { channel: "fake", chatId: "G1", userScope: "group", peerId: "U-human" },
-    });
-    assert.equal(received.length, 1, "a human in an open channel is not blocked by the peer guard");
-  } finally { await rmRoot(root); }
-});
-
-test("the sliding-window pair guard suppresses a reply-storm to one conversation", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, countOf } = makeFake({ agentRoot: root }); // allow-all gate
-    const out = { to: "C1", text: "ping", source: { channel: "fake", chatId: "C1" } };
-    // The guard ceiling is 6 replies / 60s window; the 7th to the SAME convo trips.
-    const results = [];
-    for (let i = 0; i < 8; i++) results.push(await a.send(out));
-    const blocked = results.filter((r) => r.blocked && r.reason === "reply-storm-guard");
-    assert.ok(blocked.length >= 1, "a sustained reply-storm to one conversation is suppressed");
-    assert.ok(a.sent.length <= 6, "no more than the window ceiling reaches _send");
-    assert.ok(countOf(CHANNEL_COUNTERS.PAIR_GUARD_TRIPPED) >= 1);
-  } finally { await rmRoot(root); }
-});
-
-test("the pair guard is per-conversation — a different chat is unaffected", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeFake({ agentRoot: root });
-    for (let i = 0; i < 6; i++) await a.send({ to: "C1", text: "x", source: { channel: "fake", chatId: "C1" } });
-    // C1 is now at the ceiling; a send to C2 must still go through.
-    const res = await a.send({ to: "C2", text: "fresh convo", source: { channel: "fake", chatId: "C2" } });
-    assert.equal(res.ok, true, "a different conversation is not penalised by C1's storm");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// P0-5/P0-6: supervised reconnect + dead-channel health
-// ---------------------------------------------------------------------------
-
-test("a dropped connection triggers a supervised reconnect (injected supervisor)", async () => {
-  const root = await makeRoot();
-  try {
-    // Inject a fake supervisor so we can drive the reconnect lifecycle without
-    // real timers. It records the connect attempts and exposes onState so the
-    // adapter's state/counters wiring is exercised deterministically.
-    const connects = [];
-    let captured = null;
-    const fakeSupervise = (cfg) => {
-      captured = cfg;
-      // Run the first connect synchronously-ish (start() awaits .started).
-      const started = Promise.resolve().then(() => cfg.connect()).then(() => {
-        connects.push("up");
-        cfg.onState(CONN_STATE.UP, { attempt: 1, reconnected: false });
-      });
-      return {
-        notifyDown: (reason) => {
-          // Simulate the supervisor's drop → backoff → reconnect cycle.
-          cfg.onState(CONN_STATE.DOWN, { attempt: 2, delayMs: 500, reason });
-          return Promise.resolve().then(() => cfg.connect()).then(() => {
-            connects.push("reconnect");
-            cfg.onState(CONN_STATE.UP, { attempt: 2, reconnected: true });
-          });
-        },
-        stop: () => {},
-        get state() { return CONN_STATE.UP; },
-        get connection() { return null; },
-        get attempts() { return 0; },
-        started,
-      };
-    };
-
-    const { a, countOf } = makeFake({ agentRoot: root, superviseConnection: fakeSupervise });
-    await a.start({ onInbound: () => {} });
-    assert.ok(captured, "supervisor was constructed in start()");
-    assert.equal(connects.filter((c) => c === "up").length, 1, "initial connect happened");
-
-    // The provider observes a socket close → adapter reports it to the supervisor.
-    await a.notifyConnectionDown("socket-closed");
-    await new Promise((r) => setTimeout(r, 5));
-    assert.ok(connects.includes("reconnect"), "a drop triggered a reconnect attempt");
-    assert.equal(countOf(CHANNEL_COUNTERS.RECONNECT_DOWN), 1, "the drop was counted");
-    assert.equal(countOf(CHANNEL_COUNTERS.RECONNECT_RECOVERED), 1, "the recovery was counted");
-  } finally { await rmRoot(root); }
-});
-
-test("a dead channel turns healthCheck() red (supervisor gave up)", async () => {
-  const root = await makeRoot();
-  try {
-    let cfgRef = null;
-    const fakeSupervise = (cfg) => {
-      cfgRef = cfg;
-      return {
-        notifyDown: () => {}, stop: () => {},
-        get state() { return CONN_STATE.GIVING_UP; },
-        get connection() { return null; }, get attempts() { return 8; },
-        started: Promise.resolve().then(() => cfg.connect()),
-      };
-    };
-    const { a, countOf } = makeFake({ agentRoot: root, superviseConnection: fakeSupervise });
-    await a.start({ onInbound: () => {} });
-
-    // Healthy at first.
-    cfgRef.onState(CONN_STATE.UP, { attempt: 1, reconnected: false });
-    assert.equal((await a.healthCheck()).ok, true);
-
-    // The supervisor exhausts its budget → giving-up.
-    cfgRef.onState(CONN_STATE.GIVING_UP, { attempts: 8, reason: "exhausted" });
-    const hc = await a.healthCheck();
-    assert.equal(hc.ok, false, "a dead channel must report unhealthy");
-    assert.equal(hc.state, CONN_STATE.GIVING_UP);
-    assert.match(hc.detail, /DEAD/);
-    assert.equal(countOf(CHANNEL_COUNTERS.RECONNECT_GAVE_UP), 1);
-  } finally { await rmRoot(root); }
-});
-
-test("unsupervised adapter keeps the prior always-green healthCheck", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeFake({ agentRoot: root, supervise: false });
-    await a.start({ onInbound: () => {} });
-    const hc = await a.healthCheck();
-    assert.equal(hc.ok, true);
-  } finally { await rmRoot(root); }
-});
-
-test("the real supervisor reconnects a flapping connection with bounded backoff (injected timers)", async () => {
-  const root = await makeRoot();
-  try {
-    // Use the REAL superviseConnection with injected timers so the backoff loop
-    // is exercised end-to-end without real time. The first connect fails, then
-    // the second succeeds — proving start() doesn't die on a one-shot failure.
-    const queued = [];
-    const setT = (fn, ms) => { queued.push({ fn, ms }); return queued.length; };
-    const clearT = () => {};
-    let n = 0;
-    class Flap extends FakeAdapter {
-      async _connect({ onRaw }) {
-        n += 1;
-        if (n === 1) throw new Error("first connect fails");
-        this.pushRaw = onRaw;
-      }
-    }
-    const a = new Flap({
-      agentRoot: root,
-      bump: () => 1,
-      screenOutbound: async () => ({ allow: true }),
-      hookBus: createHookBus(),
-      setTimeout: setT,
-      clearTimeout: clearT,
-      rng: () => 0, // deterministic: pick the floor of every backoff window
-    });
-    await a.start({ onInbound: () => {} });
-    // First connect threw → a backoff timer was queued (DOWN, not dead).
-    assert.equal(queued.length, 1, "a failed first connect schedules a bounded-backoff retry");
-    assert.equal(a._connState, CONN_STATE.DOWN);
-    // Fire the backoff → the retry connects successfully → UP.
-    await queued[0].fn();
-    await new Promise((r) => setTimeout(r, 5));
-    assert.equal(a._connState, CONN_STATE.UP, "the supervised retry recovered the connection");
-    await a.stop();
-  } finally { await rmRoot(root); }
-});