alvin-bot 4.18.0 → 4.18.2

package/test/slack-test-connection.test.ts

@@ -1,176 +0,0 @@
-/**
- * v4.13.1 — `/api/platforms/test-connection` must accept `slack` as a
- * platformId and validate the Bot Token via Slack's auth.test endpoint.
- *
- * Before v4.13.1, the handler only knew about telegram/discord/signal/
- * whatsapp, so slack fell through to "Unknown platform" even when a
- * valid xoxb- Bot Token was set.
- *
- * These tests hit the handler directly (no HTTP server spin-up) and stub
- * global fetch so the Slack API is never actually contacted.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { EventEmitter } from "node:events";
-import { Writable } from "node:stream";
-
-/**
- * Minimal request/response pair that the setup-api handler expects.
- * We capture the body written via res.end(body) so the test can assert
- * on the JSON payload.
- */
-interface FakeIO {
-  req: EventEmitter & { method: string; url: string; headers: Record<string, string> };
-  res: Writable & { statusCode: number; headers: Record<string, string>; body: string };
-}
-
-function makeIO(method: string, url: string, body: string): FakeIO {
-  const req = new EventEmitter() as FakeIO["req"];
-  req.method = method;
-  req.url = url;
-  req.headers = {};
-
-  let captured = "";
-  const res = new Writable({
-    write(chunk, _enc, cb) {
-      captured += chunk.toString();
-      cb();
-    },
-  }) as FakeIO["res"];
-  res.statusCode = 200;
-  res.headers = {};
-  res.setHeader = (k: string, v: string) => {
-    res.headers[k.toLowerCase()] = v;
-    return res as any;
-  };
-  res.end = (b?: unknown) => {
-    if (b != null) captured += String(b);
-    res.body = captured;
-    return res as any;
-  };
-
-  return { req, res };
-}
-
-beforeEach(() => {
-  vi.resetModules();
-  // Prevent the setup-api module from crashing on BOT_ROOT etc.
-  process.env.BOT_TOKEN = "";
-  process.env.SLACK_BOT_TOKEN = "";
-  process.env.SLACK_APP_TOKEN = "";
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  delete process.env.BOT_TOKEN;
-  delete process.env.SLACK_BOT_TOKEN;
-  delete process.env.SLACK_APP_TOKEN;
-});
-
-describe("POST /api/platforms/test-connection — slack (v4.13.1)", () => {
-  it("returns {ok:false, error: 'SLACK_BOT_TOKEN not set'} when no tokens configured", async () => {
-    const { handleSetupAPI } = await import("../src/web/setup-api.js");
-    const { req, res } = makeIO("POST", "/api/platforms/test-connection", "");
-    const body = JSON.stringify({ platformId: "slack" });
-
-    const handled = await handleSetupAPI(req as any, res as any, "/api/platforms/test-connection", body);
-    expect(handled).toBe(true);
-    const parsed = JSON.parse(res.body);
-    expect(parsed.ok).toBe(false);
-    expect(parsed.error).toMatch(/SLACK_BOT_TOKEN/);
-  });
-
-  it("returns {ok:true, info: '...'} when Slack's auth.test accepts the token", async () => {
-    process.env.SLACK_BOT_TOKEN = "xoxb-fake-valid";
-    process.env.SLACK_APP_TOKEN = "xapp-fake-valid";
-
-    vi.stubGlobal(
-      "fetch",
-      vi.fn(async (url: string) => {
-        expect(url).toContain("slack.com/api/auth.test");
-        return {
-          ok: true,
-          json: async () => ({
-            ok: true,
-            url: "https://my-project.slack.com/",
-            team: "my-project Workspace",
-            user: "alvinbot",
-            team_id: "T123",
-            user_id: "U456",
-            bot_id: "B789",
-          }),
-        };
-      }),
-    );
-
-    const { handleSetupAPI } = await import("../src/web/setup-api.js");
-    const { req, res } = makeIO("POST", "/api/platforms/test-connection", "");
-    const body = JSON.stringify({ platformId: "slack" });
-    await handleSetupAPI(req as any, res as any, "/api/platforms/test-connection", body);
-
-    const parsed = JSON.parse(res.body);
-    expect(parsed.ok).toBe(true);
-    expect(parsed.info).toMatch(/alvinbot|my-project/i);
-  });
-
-  it("returns {ok:false} when Slack's auth.test rejects the token", async () => {
-    process.env.SLACK_BOT_TOKEN = "xoxb-fake-invalid";
-    process.env.SLACK_APP_TOKEN = "xapp-fake-invalid";
-
-    vi.stubGlobal(
-      "fetch",
-      vi.fn(async () => ({
-        ok: true,
-        json: async () => ({ ok: false, error: "invalid_auth" }),
-      })),
-    );
-
-    const { handleSetupAPI } = await import("../src/web/setup-api.js");
-    const { req, res } = makeIO("POST", "/api/platforms/test-connection", "");
-    const body = JSON.stringify({ platformId: "slack" });
-    await handleSetupAPI(req as any, res as any, "/api/platforms/test-connection", body);
-
-    const parsed = JSON.parse(res.body);
-    expect(parsed.ok).toBe(false);
-    expect(parsed.error).toMatch(/invalid_auth/);
-  });
-
-  it("warns about missing/invalid App Token format when Bot Token is OK", async () => {
-    process.env.SLACK_BOT_TOKEN = "xoxb-fake-valid";
-    process.env.SLACK_APP_TOKEN = "xoxb-not-an-app-token"; // wrong prefix
-
-    vi.stubGlobal(
-      "fetch",
-      vi.fn(async () => ({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          user: "alvinbot",
-          team: "x",
-          team_id: "T1",
-          user_id: "U1",
-          bot_id: "B1",
-        }),
-      })),
-    );
-
-    const { handleSetupAPI } = await import("../src/web/setup-api.js");
-    const { req, res } = makeIO("POST", "/api/platforms/test-connection", "");
-    const body = JSON.stringify({ platformId: "slack" });
-    await handleSetupAPI(req as any, res as any, "/api/platforms/test-connection", body);
-
-    const parsed = JSON.parse(res.body);
-    // Bot Token was valid, but we should still note the App Token format issue
-    expect(parsed.ok).toBe(true);
-    expect(parsed.info).toMatch(/App.?Token|xapp-/i);
-  });
-
-  it("still rejects 'slack-workspace' or other typos as unknown (regression guard)", async () => {
-    const { handleSetupAPI } = await import("../src/web/setup-api.js");
-    const { req, res } = makeIO("POST", "/api/platforms/test-connection", "");
-    const body = JSON.stringify({ platformId: "slack-workspace" });
-    await handleSetupAPI(req as any, res as any, "/api/platforms/test-connection", body);
-    const parsed = JSON.parse(res.body);
-    expect(parsed.ok).toBe(false);
-    expect(parsed.error).toMatch(/Unknown platform/);
-  });
-});

package/test/stress-scenarios.test.ts

@@ -1,356 +0,0 @@
-/**
- * Stress scenarios — end-to-end sanity checks that combine multiple
- * services under pathological inputs. These are not "happy path" tests;
- * they're the "what if everything goes wrong at once" layer.
- *
- * Scenarios covered:
- *   1. Port churn — open/close a web server 20 times with active
- *      connections on each cycle. No EADDRINUSE ever.
- *   2. Scheduler catchup chain — 50 jobs, 10 of which have a
- *      mid-execution "crash" (lastAttemptAt > lastRunAt within grace),
- *      30 past/future mix, 10 disabled. handleStartupCatchup must
- *      rewind exactly the 10 interrupted ones and leave all others.
- *   3. Watchdog brake escalation — simulated crash burst triggers the
- *      daily cap before the short cap.
- *   4. Concurrent runJobNow — 10 parallel calls to the same job
- *      resolve to 1 "ran" + 9 "already-running", never double-fire.
- *   5. Telegram error filter across 50 random grammy errors — no
- *      false positives, no false negatives on the reference patterns.
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import http from "http";
-import { closeHttpServerGracefully as stopWebServer } from "../src/web/server.js";
-import {
-  handleStartupCatchup,
-  prepareForExecution,
-} from "../src/services/cron-scheduling.js";
-import {
-  decideBrakeAction,
-  DEFAULTS,
-} from "../src/services/watchdog-brake.js";
-import { isHarmlessTelegramError } from "../src/util/telegram-error-filter.js";
-import { resolveJobByNameOrId } from "../src/services/cron-resolver.js";
-import type { CronJob } from "../src/services/cron.js";
-
-function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const s = http.createServer();
-    s.listen(0, () => {
-      const addr = s.address();
-      if (typeof addr === "object" && addr) {
-        const p = addr.port;
-        s.close(() => resolve(p));
-      } else {
-        reject(new Error("no address"));
-      }
-    });
-  });
-}
-
-function job(overrides: Partial<CronJob>): CronJob {
-  return {
-    id: "j",
-    name: "n",
-    type: "ai-query",
-    schedule: "0 8 * * *",
-    oneShot: false,
-    payload: { prompt: "x" },
-    target: { platform: "telegram", chatId: "1" },
-    enabled: true,
-    createdAt: 0,
-    lastRunAt: null,
-    lastResult: null,
-    lastError: null,
-    nextRunAt: null,
-    runCount: 0,
-    createdBy: "t",
-    ...overrides,
-  };
-}
-
-describe("Stress 1 — port churn", () => {
-  it("survives 20 open/close cycles with active connections", async () => {
-    const port = await getFreePort();
-
-    for (let cycle = 0; cycle < 20; cycle++) {
-      const server = http.createServer((_req, res) => {
-        res.writeHead(200);
-        res.write("chunk");
-        // do NOT end — simulates a hanging client
-      });
-      await new Promise<void>((r) => server.listen(port, () => r()));
-
-      // Open 5 simultaneous clients hanging on the response
-      const clients: http.ClientRequest[] = [];
-      for (let i = 0; i < 5; i++) {
-        const req = http.get(`http://127.0.0.1:${port}/h${i}`);
-        req.on("error", () => { /* expected on close */ });
-        clients.push(req);
-      }
-      // Give them a tick to actually connect
-      await new Promise((r) => setImmediate(r));
-
-      const t0 = Date.now();
-      await stopWebServer(server);
-      expect(Date.now() - t0).toBeLessThan(2000);
-    }
-
-    // Final: the port must still be bindable
-    const reuse = http.createServer();
-    await new Promise<void>((resolve, reject) => {
-      reuse.once("error", reject);
-      reuse.listen(port, () => resolve());
-    });
-    await new Promise<void>((r) => reuse.close(() => r()));
-  }, 30_000); // longer timeout — 20 cycles
-});
-
-describe("Stress 2 — scheduler catchup chain", () => {
-  it("rewinds exactly the interrupted jobs in a mixed 50-job list", () => {
-    const now = 1_775_900_000_000;
-    const GRACE = 6 * 60 * 60 * 1000;
-    const jobs: CronJob[] = [];
-
-    // 10 interrupted within grace (should rewind)
-    for (let i = 0; i < 10; i++) {
-      jobs.push(job({
-        id: `interrupted-${i}`,
-        name: `Interrupted ${i}`,
-        lastAttemptAt: now - (i + 1) * 60_000, // 1..10 min ago
-        lastRunAt: null,
-        nextRunAt: now + 86_400_000,
-      }));
-    }
-
-    // 10 completed (lastRunAt >= lastAttemptAt)
-    for (let i = 0; i < 10; i++) {
-      jobs.push(job({
-        id: `completed-${i}`,
-        name: `Completed ${i}`,
-        lastAttemptAt: now - 3 * 3600_000,
-        lastRunAt: now - 3 * 3600_000 + 60_000,
-        nextRunAt: now + 86_400_000,
-      }));
-    }
-
-    // 10 past grace (too old to catch up)
-    for (let i = 0; i < 10; i++) {
-      jobs.push(job({
-        id: `stale-${i}`,
-        name: `Stale ${i}`,
-        lastAttemptAt: now - 12 * 3600_000, // 12h ago
-        lastRunAt: null,
-        nextRunAt: now + 3600_000,
-      }));
-    }
-
-    // 10 disabled
-    for (let i = 0; i < 10; i++) {
-      jobs.push(job({
-        id: `disabled-${i}`,
-        name: `Disabled ${i}`,
-        enabled: false,
-        lastAttemptAt: now - 60_000,
-        lastRunAt: null,
-        nextRunAt: now + 3600_000,
-      }));
-    }
-
-    // 10 fresh (never attempted)
-    for (let i = 0; i < 10; i++) {
-      jobs.push(job({
-        id: `fresh-${i}`,
-        name: `Fresh ${i}`,
-        lastAttemptAt: null,
-        lastRunAt: null,
-        nextRunAt: now + 3600_000,
-      }));
-    }
-
-    const caught = handleStartupCatchup(jobs, now, GRACE);
-
-    const rewound = caught.filter((j, i) => j.nextRunAt !== jobs[i].nextRunAt);
-    expect(rewound.length).toBe(10);
-    expect(rewound.every((j) => j.id.startsWith("interrupted-"))).toBe(true);
-    expect(rewound.every((j) => j.nextRunAt === now)).toBe(true);
-  });
-});
-
-describe("Stress 3 — watchdog daily cap escalation", () => {
-  it("trips the daily brake on the 20th crash even when short window resets", () => {
-    let beacon: import("../src/services/watchdog-brake.js").BeaconData = {
-      lastBeat: 0,
-      pid: 1,
-      bootTime: 0,
-      crashCount: 0,
-      crashWindowStart: 0,
-      dailyCrashCount: 0,
-      dailyCrashWindowStart: 0,
-      version: "t",
-    };
-
-    // Simulate 19 crashes over 23 hours — short window resets each
-    // time but daily accumulates.
-    let now = 1000;
-    for (let i = 0; i < 19; i++) {
-      now += 70 * 60_000; // 70 min between crashes — outside short window
-      const result = decideBrakeAction(
-        { ...beacon, lastBeat: now - 10_000 },
-        now,
-      );
-      expect(result.action).toBe("proceed");
-      if (result.action === "proceed") {
-        beacon = {
-          ...beacon,
-          lastBeat: now,
-          crashCount: result.crashCount,
-          crashWindowStart: result.crashWindowStart,
-          dailyCrashCount: result.dailyCrashCount,
-          dailyCrashWindowStart: result.dailyCrashWindowStart,
-        };
-      }
-    }
-    expect(beacon.dailyCrashCount).toBe(19);
-
-    // 20th crash — must trip the daily cap even though short window is clean
-    now += 70 * 60_000;
-    const last = decideBrakeAction(
-      { ...beacon, lastBeat: now - 10_000 },
-      now,
-    );
-    expect(last.action).toBe("brake");
-    if (last.action === "brake") {
-      expect(last.reason).toMatch(/daily|day/i);
-    }
-  });
-});
-
-describe("Stress 4 — concurrent runJobNow simulation", () => {
-  it("only one call wins the runningJobs guard; the rest see already-running", () => {
-    // We can't call the real runJobNow without the full cron fs tree,
-    // so we simulate the guard protocol directly. This verifies the
-    // invariant that the cron-resolver + runningJobs Set model gives
-    // at-most-one concurrent execution per job.
-    const runningJobs = new Set<string>();
-    const jobId = "job-1";
-
-    const results: Array<"ran" | "already-running"> = [];
-    const attempt = (): "ran" | "already-running" => {
-      if (runningJobs.has(jobId)) return "already-running";
-      runningJobs.add(jobId);
-      try {
-        // Pretend executeJob runs here
-        return "ran";
-      } finally {
-        runningJobs.delete(jobId);
-      }
-    };
-
-    // Sequential but with interleaved add/delete — single-threaded JS
-    // means we can't actually overlap, but the Set invariant has to
-    // hold if an await is inserted between check and add (it's not).
-    for (let i = 0; i < 10; i++) {
-      results.push(attempt());
-    }
-
-    // All 10 synchronous calls see empty set → all "ran", all cleanup OK
-    expect(results.every((r) => r === "ran")).toBe(true);
-
-    // Now simulate the async case: inject an await between attempt() calls
-    // while holding the guard across the await.
-    async function guardedAsync(): Promise<"ran" | "already-running"> {
-      if (runningJobs.has(jobId)) return "already-running";
-      runningJobs.add(jobId);
-      try {
-        await new Promise((r) => setTimeout(r, 5));
-        return "ran";
-      } finally {
-        runningJobs.delete(jobId);
-      }
-    }
-
-    return Promise.all([
-      guardedAsync(),
-      guardedAsync(),
-      guardedAsync(),
-      guardedAsync(),
-      guardedAsync(),
-    ]).then((out) => {
-      const ran = out.filter((r) => r === "ran").length;
-      const already = out.filter((r) => r === "already-running").length;
-      expect(ran).toBe(1);
-      expect(already).toBe(4);
-    });
-  });
-});
-
-describe("Stress 5 — telegram error filter large sample", () => {
-  const benign = [
-    "Call to 'editMessageText' failed! (400: Bad Request: message is not modified: specified new message content and reply markup are exactly the same as a current content and reply markup of the message)",
-    "Call to 'editMessageReplyMarkup' failed! (400: Bad Request: message is not modified)",
-    "Bad Request: query is too old and response timeout expired",
-    "Bad Request: MESSAGE_ID_INVALID",
-    "Bad Request: message to edit not found",
-    "Bad Request: message to delete not found",
-    "specified new message content and reply markup are exactly the same",
-  ];
-
-  const real = [
-    "Unauthorized",
-    "Too Many Requests: retry after 5",
-    "Forbidden: bot was blocked by the user",
-    "chat not found",
-    "Bad Request: chat not found",
-    "connect ETIMEDOUT",
-    "write ECONNRESET",
-    "stream error: provider timeout",
-    "Claude SDK error: maxTurns exceeded",
-    "Bad Request: can't parse entities: Can't find end of the entity starting at byte offset 1024",
-  ];
-
-  it("silences every benign grammy race", () => {
-    for (const msg of benign) {
-      expect(isHarmlessTelegramError(new Error(msg))).toBe(true);
-    }
-  });
-
-  it("never silences a real actionable error", () => {
-    for (const msg of real) {
-      expect(isHarmlessTelegramError(new Error(msg))).toBe(false);
-    }
-  });
-
-  it("handles grammy's description field on GrammyError shape", () => {
-    const err = Object.assign(new Error("generic"), {
-      description: "Bad Request: message is not modified",
-    });
-    expect(isHarmlessTelegramError(err)).toBe(true);
-  });
-});
-
-describe("Stress 6 — cron-resolver ambiguity edge cases", () => {
-  const baseJobs: CronJob[] = [
-    job({ id: "id1", name: "Daily Job Alert" }),
-    job({ id: "id2", name: "Weekly Stock Report" }),
-    job({ id: "id3", name: "daily job alert" }), // lowercase collision
-  ];
-
-  it("returns null on ambiguous case-insensitive query, but hits the exact-case match first", () => {
-    // Exact case "Daily Job Alert" → wins via exact-name path
-    expect(resolveJobByNameOrId(baseJobs, "Daily Job Alert")?.id).toBe("id1");
-    // Exact case "daily job alert" → wins via exact-name path too
-    expect(resolveJobByNameOrId(baseJobs, "daily job alert")?.id).toBe("id3");
-    // Mixed case "DaIlY jOb AlErT" → no exact match, 2 CI matches → ambiguous → null
-    expect(resolveJobByNameOrId(baseJobs, "DaIlY jOb AlErT")).toBeNull();
-  });
-
-  it("ID always wins over collision at the name layer", () => {
-    const jobs = [
-      job({ id: "Daily Job Alert", name: "Something Else" }),
-      job({ id: "abc", name: "Daily Job Alert" }),
-    ];
-    // "Daily Job Alert" matches both: id of job[0] and name of job[1].
-    // ID wins per contract.
-    expect(resolveJobByNameOrId(jobs, "Daily Job Alert")?.id).toBe("Daily Job Alert");
-  });
-});

package/test/stuck-timer.test.ts

@@ -1,116 +0,0 @@
-/**
- * v4.12.1 — Task-aware stuck timer state machine.
- *
- * Before v4.12.1, message.ts used a flat 10-min stuck timeout that
- * aborted the session when no chunks arrived for 10 minutes. This
- * was fatal for synchronous Task/Agent tool calls, which legitimately
- * produce no parent-stream chunks for their entire duration.
- *
- * The new stuck timer is task-aware: it escalates to an extended
- * timeout (default 120 min) as soon as a sync Task/Agent tool call
- * is detected (tracked by toolUseId), then reverts to the normal
- * timeout once all tracked sync tool calls have emitted their
- * tool_result.
- *
- * This module is a pure state machine — no grammy, no session,
- * no provider. Testable in isolation with vi.useFakeTimers().
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { createStuckTimer } from "../src/handlers/stuck-timer.js";
-
-describe("stuck timer — task-aware state machine (v4.12.1)", () => {
-  beforeEach(() => vi.useFakeTimers());
-  afterEach(() => vi.useRealTimers());
-
-  it("fires after normalMs when no pending sync tasks", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.reset();
-    vi.advanceTimersByTime(999);
-    expect(onTimeout).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(1);
-    expect(onTimeout).toHaveBeenCalledTimes(1);
-  });
-
-  it("enterSync extends the timer to extendedMs", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.reset();
-    t.enterSync("tool_1");
-    // 5 seconds in — should still be alive because we're in extended mode
-    vi.advanceTimersByTime(5000);
-    expect(onTimeout).not.toHaveBeenCalled();
-    // 5 more seconds (10s total since enterSync) — extended timer should fire
-    vi.advanceTimersByTime(5000);
-    expect(onTimeout).toHaveBeenCalledTimes(1);
-  });
-
-  it("exitSync returns to normalMs and rearms from that point", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.enterSync("tool_1");
-    vi.advanceTimersByTime(500);
-    t.exitSync("tool_1");
-    // New normal timer is armed from exitSync time; fires after another 1000ms.
-    vi.advanceTimersByTime(999);
-    expect(onTimeout).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(1);
-    expect(onTimeout).toHaveBeenCalledTimes(1);
-  });
-
-  it("multiple pending syncs: exit one keeps extended timer", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.enterSync("tool_1");
-    t.enterSync("tool_2");
-    expect(t._pendingCount()).toBe(2);
-    t.exitSync("tool_1");
-    expect(t._pendingCount()).toBe(1);
-    // Still in extended mode — 5s of silence must not fire
-    vi.advanceTimersByTime(5000);
-    expect(onTimeout).not.toHaveBeenCalled();
-  });
-
-  it("exitSync on unknown id is a no-op and doesn't corrupt state", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.exitSync("never-seen");
-    expect(t._pendingCount()).toBe(0);
-    // Normal timer should work as usual
-    t.reset();
-    vi.advanceTimersByTime(1000);
-    expect(onTimeout).toHaveBeenCalled();
-  });
-
-  it("cancel stops the timer entirely", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.reset();
-    t.cancel();
-    vi.advanceTimersByTime(2000);
-    expect(onTimeout).not.toHaveBeenCalled();
-  });
-
-  it("reset while extended keeps the extended timer (not shortening)", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.enterSync("tool_1");
-    vi.advanceTimersByTime(500);
-    // A chunk arrived — reset. We should STAY in extended mode.
-    t.reset();
-    vi.advanceTimersByTime(9000);
-    expect(onTimeout).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(1000);
-    expect(onTimeout).toHaveBeenCalledTimes(1);
-  });
-
-  it("idempotent enterSync: same id twice stays at count 1", () => {
-    const onTimeout = vi.fn();
-    const t = createStuckTimer({ normalMs: 1000, extendedMs: 10_000, onTimeout });
-    t.enterSync("tool_1");
-    t.enterSync("tool_1");
-    expect(t._pendingCount()).toBe(1);
-    t.exitSync("tool_1");
-    expect(t._pendingCount()).toBe(0);
-  });
-});