switchroom 0.5.0

package/telegram-plugin/tests/active-pins-sweep.test.ts

@@ -0,0 +1,309 @@
+/**
+ * Tests for sweepActivePins — the shared helper called by both the
+ * startup failsafe and the /restart, /reconcile --restart, and /update
+ * command handlers to unpin any still-pinned progress cards and clear
+ * the sidecar.
+ *
+ * The real unpin path goes through `lockedBot.api.unpinChatMessage`.
+ * These tests inject a fake unpin callback so behavior is verified
+ * without a Telegram stub — the shape under test is:
+ *
+ *   1. Reads the sidecar
+ *   2. Calls unpinFn(chatId, messageId) for each entry
+ *   3. Swallows unpin errors (best-effort — the message may already be
+ *      gone, or the bot may have lost admin rights)
+ *   4. Clears the sidecar regardless of success/failure
+ *   5. Bounded by timeoutMs so a hung Telegram API can't block a
+ *      restart indefinitely
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { addActivePin, readActivePins, ACTIVE_PINS_FILENAME, type ActivePin } from "../active-pins.js";
+import {
+  sweepActivePins,
+  sweepBotAuthoredPins,
+  type PinnedMessageInfo,
+} from "../active-pins-sweep.js";
+
+describe("sweepActivePins", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "active-pins-sweep-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const makePin = (overrides: Partial<ActivePin> = {}): ActivePin => ({
+    chatId: "100",
+    messageId: 42,
+    turnKey: "100:0:1",
+    pinnedAt: 1_700_000_000_000,
+    ...overrides,
+  });
+
+  it("is a no-op when the sidecar is empty", async () => {
+    const calls: Array<[string, number]> = [];
+    const result = await sweepActivePins(tmp, async (chatId, messageId) => {
+      calls.push([chatId, messageId]);
+    });
+    expect(calls).toEqual([]);
+    expect(result.swept).toEqual([]);
+    expect(result.timedOut).toBe(false);
+  });
+
+  it("calls unpin for each sidecar entry and clears the file", async () => {
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 1, turnKey: "A:0:1" }));
+    addActivePin(tmp, makePin({ chatId: "B", messageId: 2, turnKey: "B:0:1" }));
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 3, turnKey: "A:0:2" }));
+
+    const calls: Array<[string, number]> = [];
+    const result = await sweepActivePins(tmp, async (chatId, messageId) => {
+      calls.push([chatId, messageId]);
+    });
+
+    expect(calls.sort()).toEqual([
+      ["A", 1],
+      ["A", 3],
+      ["B", 2],
+    ]);
+    expect(result.swept).toHaveLength(3);
+    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    expect(readActivePins(tmp)).toEqual([]);
+  });
+
+  it("still clears the sidecar when unpin throws for every entry", async () => {
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
+    addActivePin(tmp, makePin({ chatId: "B", messageId: 2, turnKey: "B:0:1" }));
+
+    const errors: string[] = [];
+    await sweepActivePins(
+      tmp,
+      async () => {
+        throw new Error("message to unpin not found");
+      },
+      { log: (msg) => errors.push(msg) },
+    );
+
+    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    expect(readActivePins(tmp)).toEqual([]);
+    // Each failure is logged — log receives one "sweeping N" line plus
+    // one "unpin failed" line per entry.
+    expect(errors.some((e) => e.includes("sweeping 2"))).toBe(true);
+    expect(errors.filter((e) => e.includes("unpin failed"))).toHaveLength(2);
+  });
+
+  it("tolerates a mix of successful and failing unpins", async () => {
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 2, turnKey: "A:0:2" }));
+
+    const unpinned: Array<[string, number]> = [];
+    await sweepActivePins(tmp, async (chatId, messageId) => {
+      if (messageId === 2) throw new Error("nope");
+      unpinned.push([chatId, messageId]);
+    });
+
+    expect(unpinned).toEqual([["A", 1]]);
+    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+  });
+
+  it("returns after timeoutMs even if unpin never resolves", async () => {
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
+
+    const start = Date.now();
+    const result = await sweepActivePins(
+      tmp,
+      () => new Promise(() => { /* never resolves */ }),
+      { timeoutMs: 50 },
+    );
+    const elapsed = Date.now() - start;
+
+    expect(result.timedOut).toBe(true);
+    expect(elapsed).toBeLessThan(500);
+    // Sidecar is cleared even though the unpin never landed — stale
+    // entries get retried from Telegram's side on next boot but we
+    // don't want the sweep to keep re-firing them forever.
+    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+  });
+
+  it("passes the caller-provided log hook", async () => {
+    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
+    const lines: string[] = [];
+    await sweepActivePins(
+      tmp,
+      async () => { /* succeed silently */ },
+      { log: (msg) => lines.push(msg) },
+    );
+    expect(lines).toContain("sweeping 1 active pin(s)");
+  });
+});
+
+describe("sweepBotAuthoredPins", () => {
+  const BOT_ID = 1000;
+
+  /**
+   * Build a fake getTopPin backed by a map of { chatId: queue }.
+   * Each unpin pops the head of the queue — which mimics Telegram's
+   * "unpinning the top reveals the next most recent pin" behavior.
+   */
+  function fakeChats(
+    state: Record<string, Array<{ messageId: number; fromId: number | null }>>,
+  ) {
+    const getTopPin = async (chatId: string): Promise<PinnedMessageInfo | null> => {
+      const q = state[chatId] ?? [];
+      return q.length === 0 ? null : { ...q[0] };
+    };
+    const unpinCalls: Array<[string, number]> = [];
+    const unpin = async (chatId: string, messageId: number): Promise<void> => {
+      unpinCalls.push([chatId, messageId]);
+      const q = state[chatId] ?? [];
+      if (q[0]?.messageId === messageId) q.shift();
+    };
+    return { getTopPin, unpin, unpinCalls };
+  }
+
+  it("is a no-op when no chats are provided", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({});
+    const result = await sweepBotAuthoredPins([], BOT_ID, getTopPin, unpin);
+    expect(unpinCalls).toEqual([]);
+    expect(result.total).toBe(0);
+    expect(result.perChat).toEqual({});
+  });
+
+  it("is a no-op when a chat has no pinned message", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({ A: [] });
+    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
+    expect(unpinCalls).toEqual([]);
+    expect(result.total).toBe(0);
+  });
+
+  it("unpins consecutive bot-authored pins until a foreign pin is reached", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({
+      A: [
+        { messageId: 10, fromId: BOT_ID },
+        { messageId: 9, fromId: BOT_ID },
+        { messageId: 8, fromId: 42 }, // user pin — barrier
+        { messageId: 7, fromId: BOT_ID }, // would be unpinned if barrier weren't there
+      ],
+    });
+    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
+    expect(unpinCalls).toEqual([
+      ["A", 10],
+      ["A", 9],
+    ]);
+    expect(result.total).toBe(2);
+    expect(result.perChat).toEqual({ A: 2 });
+  });
+
+  it("stops immediately when the top pin belongs to someone else", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({
+      A: [
+        { messageId: 5, fromId: 999 },
+        { messageId: 4, fromId: BOT_ID },
+      ],
+    });
+    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
+    expect(unpinCalls).toEqual([]);
+    expect(result.total).toBe(0);
+  });
+
+  it("treats pins with no from.id as foreign (anonymous channel post)", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({
+      A: [
+        { messageId: 5, fromId: null },
+        { messageId: 4, fromId: BOT_ID },
+      ],
+    });
+    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
+    expect(unpinCalls).toEqual([]);
+    expect(result.total).toBe(0);
+  });
+
+  it("iterates across multiple chats independently", async () => {
+    const { getTopPin, unpin, unpinCalls } = fakeChats({
+      A: [
+        { messageId: 1, fromId: BOT_ID },
+        { messageId: 2, fromId: BOT_ID },
+      ],
+      B: [{ messageId: 3, fromId: 777 }],
+      C: [{ messageId: 4, fromId: BOT_ID }],
+    });
+    const result = await sweepBotAuthoredPins(
+      ["A", "B", "C"],
+      BOT_ID,
+      getTopPin,
+      unpin,
+    );
+    expect(unpinCalls).toEqual([
+      ["A", 1],
+      ["A", 2],
+      ["C", 4],
+    ]);
+    expect(result.total).toBe(3);
+    expect(result.perChat).toEqual({ A: 2, C: 1 });
+  });
+
+  it("advances to the next chat when getTopPin throws", async () => {
+    const unpinCalls: Array<[string, number]> = [];
+    const errors: string[] = [];
+    const result = await sweepBotAuthoredPins(
+      ["A", "B"],
+      BOT_ID,
+      async (chatId) => {
+        if (chatId === "A") throw new Error("boom");
+        return { messageId: 7, fromId: BOT_ID };
+      },
+      async (chatId, messageId) => {
+        unpinCalls.push([chatId, messageId]);
+        // Simulate "pin is gone after unpin" so the B loop terminates
+        throw new Error("already gone");
+      },
+      { log: (msg) => errors.push(msg) },
+    );
+    // A errored on getChat; B attempted one unpin (which threw) then stopped
+    expect(unpinCalls).toEqual([["B", 7]]);
+    expect(result.total).toBe(0);
+    expect(errors.some((e) => e.includes("getChat failed for A"))).toBe(true);
+    expect(errors.some((e) => e.includes("unpin failed for B/7"))).toBe(true);
+  });
+
+  it("breaks out of a chat on unpin failure to avoid infinite loops", async () => {
+    const calls: Array<[string, number]> = [];
+    const result = await sweepBotAuthoredPins(
+      ["A"],
+      BOT_ID,
+      async () => ({ messageId: 1, fromId: BOT_ID }),
+      async (chatId, messageId) => {
+        calls.push([chatId, messageId]);
+        throw new Error("permission denied");
+      },
+    );
+    // Without the break, the fake getTopPin would keep returning the same
+    // pin and we'd loop until maxPerChat. With the break, we see exactly
+    // one call and the sweep moves on.
+    expect(calls).toEqual([["A", 1]]);
+    expect(result.total).toBe(0);
+  });
+
+  it("is bounded by maxPerChat when pins keep re-appearing", async () => {
+    // A pathological case: getTopPin always returns a bot-authored pin,
+    // and unpin silently "succeeds" without removing it. Without the
+    // maxPerChat bound the loop would be infinite.
+    let calls = 0;
+    await sweepBotAuthoredPins(
+      ["A"],
+      BOT_ID,
+      async () => ({ messageId: 1, fromId: BOT_ID }),
+      async () => {
+        calls++;
+      },
+      { maxPerChat: 5 },
+    );
+    expect(calls).toBe(5);
+  });
+});

package/telegram-plugin/tests/active-pins.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  readActivePins,
+  writeActivePins,
+  addActivePin,
+  removeActivePin,
+  clearActivePins,
+  ACTIVE_PINS_FILENAME,
+  type ActivePin,
+} from "../active-pins.js";
+
+describe("active-pins sidecar", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "active-pins-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const makePin = (overrides: Partial<ActivePin> = {}): ActivePin => ({
+    chatId: "100",
+    messageId: 42,
+    turnKey: "100:0:1",
+    pinnedAt: 1_700_000_000_000,
+    ...overrides,
+  });
+
+  describe("readActivePins", () => {
+    it("returns [] when the file is missing", () => {
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+
+    it("returns [] when the file is empty", () => {
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), "");
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+
+    it("returns [] when the file is not valid JSON", () => {
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), "{not json");
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+
+    it("returns [] when the JSON root is not an array", () => {
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), '{"oops": true}');
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+
+    it("round-trips valid pin entries", () => {
+      const pin = makePin();
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify([pin]));
+      expect(readActivePins(tmp)).toEqual([pin]);
+    });
+
+    it("drops entries with missing or wrong-typed fields", () => {
+      const good = makePin({ messageId: 7 });
+      const bad = [
+        good,
+        { chatId: "x", messageId: "not-a-number", turnKey: "k", pinnedAt: 1 },
+        { chatId: "y", messageId: 1, turnKey: "k" }, // missing pinnedAt
+        null,
+        "nope",
+      ];
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify(bad));
+      expect(readActivePins(tmp)).toEqual([good]);
+    });
+  });
+
+  describe("writeActivePins", () => {
+    it("creates the sidecar with JSON content", () => {
+      const pins = [makePin(), makePin({ messageId: 43, turnKey: "100:0:2" })];
+      writeActivePins(tmp, pins);
+      const raw = readFileSync(join(tmp, ACTIVE_PINS_FILENAME), "utf-8");
+      expect(JSON.parse(raw)).toEqual(pins);
+    });
+
+    it("deletes the sidecar when writing an empty list", () => {
+      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify([makePin()]));
+      writeActivePins(tmp, []);
+      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    });
+
+    it("is idempotent — deleting an already-missing file is a no-op", () => {
+      writeActivePins(tmp, []);
+      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    });
+  });
+
+  describe("addActivePin", () => {
+    it("creates the sidecar on first add", () => {
+      addActivePin(tmp, makePin());
+      expect(readActivePins(tmp)).toHaveLength(1);
+    });
+
+    it("appends distinct pins", () => {
+      addActivePin(tmp, makePin({ messageId: 1, turnKey: "a" }));
+      addActivePin(tmp, makePin({ messageId: 2, turnKey: "b" }));
+      const pins = readActivePins(tmp);
+      expect(pins).toHaveLength(2);
+      expect(pins.map((p) => p.messageId).sort()).toEqual([1, 2]);
+    });
+
+    it("replaces an existing entry with the same (chatId, messageId)", () => {
+      addActivePin(tmp, makePin({ pinnedAt: 100 }));
+      addActivePin(tmp, makePin({ pinnedAt: 200 }));
+      const pins = readActivePins(tmp);
+      expect(pins).toHaveLength(1);
+      expect(pins[0].pinnedAt).toBe(200);
+    });
+
+    it("treats different chatIds as distinct even with matching messageIds", () => {
+      addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
+      addActivePin(tmp, makePin({ chatId: "B", messageId: 1 }));
+      expect(readActivePins(tmp)).toHaveLength(2);
+    });
+  });
+
+  describe("removeActivePin", () => {
+    it("removes the matching entry", () => {
+      addActivePin(tmp, makePin({ messageId: 1, turnKey: "a" }));
+      addActivePin(tmp, makePin({ messageId: 2, turnKey: "b" }));
+      removeActivePin(tmp, "100", 1);
+      const pins = readActivePins(tmp);
+      expect(pins).toHaveLength(1);
+      expect(pins[0].messageId).toBe(2);
+    });
+
+    it("deletes the sidecar when the last entry is removed", () => {
+      addActivePin(tmp, makePin());
+      removeActivePin(tmp, "100", 42);
+      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    });
+
+    it("is a no-op when the file is missing", () => {
+      removeActivePin(tmp, "100", 42);
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+
+    it("is a no-op when no entry matches", () => {
+      addActivePin(tmp, makePin({ messageId: 1 }));
+      removeActivePin(tmp, "100", 999);
+      expect(readActivePins(tmp)).toHaveLength(1);
+    });
+
+    it("only matches on (chatId, messageId) — turnKey/pinnedAt are ignored", () => {
+      addActivePin(tmp, makePin({ chatId: "A", messageId: 1, turnKey: "x" }));
+      removeActivePin(tmp, "A", 1);
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+  });
+
+  describe("clearActivePins", () => {
+    it("deletes the sidecar outright", () => {
+      addActivePin(tmp, makePin());
+      addActivePin(tmp, makePin({ messageId: 43, turnKey: "b" }));
+      clearActivePins(tmp);
+      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    });
+
+    it("is a no-op when the file is missing", () => {
+      clearActivePins(tmp);
+      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
+    });
+  });
+
+  describe("crash → restart simulation", () => {
+    it("sidecar survives to be read by a fresh process", () => {
+      addActivePin(tmp, makePin({ chatId: "C1", messageId: 10, turnKey: "C1:0:1" }));
+      addActivePin(tmp, makePin({ chatId: "C2", messageId: 20, turnKey: "C2:0:1" }));
+      // simulated restart — only thing a fresh process has is agentDir
+      const recovered = readActivePins(tmp);
+      expect(recovered).toHaveLength(2);
+      expect(recovered.map((p) => `${p.chatId}/${p.messageId}`).sort()).toEqual([
+        "C1/10",
+        "C2/20",
+      ]);
+      // sweep: unpin each then clear
+      clearActivePins(tmp);
+      expect(readActivePins(tmp)).toEqual([]);
+    });
+  });
+});

package/telegram-plugin/tests/active-reactions-sweep.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { addActiveReaction, readActiveReactions, ACTIVE_REACTIONS_FILENAME, type ActiveReaction } from "../active-reactions.js";
+import { sweepActiveReactions } from "../active-reactions-sweep.js";
+
+describe("sweepActiveReactions", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "active-reactions-sweep-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const makeReaction = (overrides: Partial<ActiveReaction> = {}): ActiveReaction => ({
+    chatId: "100",
+    messageId: 42,
+    threadId: null,
+    reactedAt: 1_700_000_000_000,
+    ...overrides,
+  });
+
+  it("is a no-op when the sidecar is empty", async () => {
+    const calls: Array<[string, number]> = [];
+    const result = await sweepActiveReactions(tmp, async (chatId, messageId) => {
+      calls.push([chatId, messageId]);
+    });
+    expect(calls).toEqual([]);
+    expect(result.swept).toEqual([]);
+    expect(result.timedOut).toBe(false);
+  });
+
+  it("calls setDone for each sidecar entry and clears the file", async () => {
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 1 }));
+    addActiveReaction(tmp, makeReaction({ chatId: "B", messageId: 2, threadId: 5 }));
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 3 }));
+
+    const calls: Array<[string, number]> = [];
+    const result = await sweepActiveReactions(tmp, async (chatId, messageId) => {
+      calls.push([chatId, messageId]);
+    });
+
+    expect(calls.sort()).toEqual([
+      ["A", 1],
+      ["A", 3],
+      ["B", 2],
+    ]);
+    expect(result.swept).toHaveLength(3);
+    expect(existsSync(join(tmp, ACTIVE_REACTIONS_FILENAME))).toBe(false);
+    expect(readActiveReactions(tmp)).toEqual([]);
+  });
+
+  it("still clears the sidecar when setDone throws for every entry", async () => {
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 1 }));
+    addActiveReaction(tmp, makeReaction({ chatId: "B", messageId: 2 }));
+
+    const errors: string[] = [];
+    await sweepActiveReactions(
+      tmp,
+      async () => {
+        throw new Error("Bad Request: message not found");
+      },
+      { log: (msg) => errors.push(msg) },
+    );
+
+    expect(existsSync(join(tmp, ACTIVE_REACTIONS_FILENAME))).toBe(false);
+    expect(readActiveReactions(tmp)).toEqual([]);
+    expect(errors.some((e) => e.includes("sweeping 2"))).toBe(true);
+    expect(errors.filter((e) => e.includes("reaction sweep failed"))).toHaveLength(2);
+  });
+
+  it("tolerates a mix of successful and failing setDone calls", async () => {
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 1 }));
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 2 }));
+
+    const resolved: Array<[string, number]> = [];
+    await sweepActiveReactions(tmp, async (chatId, messageId) => {
+      if (messageId === 2) throw new Error("nope");
+      resolved.push([chatId, messageId]);
+    });
+
+    expect(resolved).toEqual([["A", 1]]);
+    expect(existsSync(join(tmp, ACTIVE_REACTIONS_FILENAME))).toBe(false);
+  });
+
+  it("returns after timeoutMs even if setDone never resolves", async () => {
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 1 }));
+
+    const start = Date.now();
+    const result = await sweepActiveReactions(
+      tmp,
+      () => new Promise(() => { /* never resolves */ }),
+      { timeoutMs: 50 },
+    );
+    const elapsed = Date.now() - start;
+
+    expect(result.timedOut).toBe(true);
+    expect(elapsed).toBeLessThan(500);
+    expect(existsSync(join(tmp, ACTIVE_REACTIONS_FILENAME))).toBe(false);
+  });
+
+  it("passes the caller-provided log hook", async () => {
+    addActiveReaction(tmp, makeReaction({ chatId: "A", messageId: 1 }));
+    const lines: string[] = [];
+    await sweepActiveReactions(
+      tmp,
+      async () => { /* succeed silently */ },
+      { log: (msg) => lines.push(msg) },
+    );
+    expect(lines).toContain("sweeping 1 stale reaction(s)");
+  });
+});