alvin-bot 4.18.0 → 4.18.2

package/test/claude-sdk-provider.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// Mock child_process BEFORE importing the provider, so the provider's
-// top-level `promisify(execFile)` binds to our mock.
-const execFileMock = vi.fn();
-vi.mock("child_process", () => ({
-  execFile: (
-    path: string,
-    args: string[],
-    opts: unknown,
-    cb: (err: Error | null, stdout: { stdout: string; stderr: string }) => void,
-  ) => {
-    execFileMock(path, args, opts, cb);
-  },
-}));
-
-// Stub findClaudeBinary to return a fake path — we don't want real FS
-vi.mock("../src/find-claude-binary.js", () => ({
-  findClaudeBinary: () => "/fake/claude",
-}));
-
-describe("ClaudeSDKProvider.isAvailable", () => {
-  beforeEach(() => {
-    execFileMock.mockReset();
-    vi.resetModules();
-  });
-
-  it("returns true when `claude auth status` reports loggedIn: true", async () => {
-    // Sequence: --version then auth status (JSON)
-    execFileMock
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "1.0.0\n", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, {
-          stdout: JSON.stringify({
-            loggedIn: true,
-            authMethod: "claude.ai",
-            subscriptionType: "max",
-          }),
-          stderr: "",
-        }),
-      );
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const p = new ClaudeSDKProvider();
-    const result = await p.isAvailable();
-    expect(result).toBe(true);
-  });
-
-  it("returns false when `claude auth status` reports loggedIn: false", async () => {
-    execFileMock
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "1.0.0\n", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, {
-          stdout: JSON.stringify({ loggedIn: false }),
-          stderr: "",
-        }),
-      );
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const p = new ClaudeSDKProvider();
-    const result = await p.isAvailable();
-    expect(result).toBe(false);
-  });
-
-  it("falls back to `claude -p` probe when `auth status` fails (older CLI)", async () => {
-    // Sequence: --version → auth status rejects → -p ping succeeds
-    execFileMock
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "1.0.0\n", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(new Error("unknown command: auth status"), { stdout: "", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "pong", stderr: "" }),
-      );
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const p = new ClaudeSDKProvider();
-    const result = await p.isAvailable();
-    expect(result).toBe(true);
-  });
-
-  it("falls back to `claude -p` probe and detects 'Not logged in' text", async () => {
-    execFileMock
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "1.0.0\n", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(new Error("auth status not supported"), { stdout: "", stderr: "" }),
-      )
-      .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "Not logged in · Please run /login", stderr: "" }),
-      );
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const p = new ClaudeSDKProvider();
-    const result = await p.isAvailable();
-    expect(result).toBe(false);
-  });
-});
-
-describe("ClaudeSDKProvider — isAuthErrorOutput helper", () => {
-  it("detects 'Not logged in' text as auth error", async () => {
-    const { isAuthErrorOutput } = await import("../src/providers/claude-sdk-provider.js");
-    expect(isAuthErrorOutput("Not logged in · Please run /login")).toBe(true);
-    expect(isAuthErrorOutput("   not logged in · Please run /login  ")).toBe(true);
-    expect(isAuthErrorOutput("Hello! Here is the result")).toBe(false);
-    expect(isAuthErrorOutput("")).toBe(false);
-  });
-});

package/test/claude-sdk-tool-use-id.test.ts

@@ -1,180 +0,0 @@
-/**
- * v4.12.1 — Contract test for claude-sdk-provider's tool_use chunk shape.
- *
- * The task-aware stuck timer depends on tool_use chunks carrying:
- *   - toolUseId (matches the tool_result that arrives later)
- *   - runInBackground (boolean extracted from block.input.run_in_background)
- *
- * Both are must-have, not nice-to-have. Pin the contract so an SDK
- * upgrade or an accidental regression can't silently break it.
- *
- * See src/handlers/stuck-timer.ts for the consumer side and
- * src/handlers/message.ts for the wiring.
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { StreamChunk } from "../src/providers/types.js";
-
-beforeEach(() => vi.resetModules());
-
-// Helper: mock the Claude Agent SDK with a scripted async generator so we
-// control the tool_use block the provider sees.
-function mockSDKWithToolUse(toolUseBlock: Record<string, unknown>): void {
-  const asyncIterable = {
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "system",
-        subtype: "init",
-        session_id: "s1",
-      };
-      yield {
-        type: "assistant",
-        session_id: "s1",
-        message: {
-          content: [toolUseBlock],
-        },
-      };
-      yield {
-        type: "result",
-        session_id: "s1",
-        total_cost_usd: 0,
-        usage: null,
-      };
-    },
-  };
-
-  vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({
-    query: () => asyncIterable,
-  }));
-}
-
-// Helper: find the claude binary. The provider calls findClaudeBinary() and
-// passes the path to the SDK — since the SDK is mocked, the path doesn't
-// matter, but findClaudeBinary itself must not throw.
-function mockFindClaudeBinary(): void {
-  vi.doMock("../src/find-claude-binary.js", () => ({
-    findClaudeBinary: () => "/usr/bin/false",
-  }));
-}
-
-describe("claude-sdk-provider tool_use chunk contract (v4.12.1)", () => {
-  it("emits toolUseId AND runInBackground=true when the flag is set", async () => {
-    mockFindClaudeBinary();
-    mockSDKWithToolUse({
-      type: "tool_use",
-      id: "toolu_ABC123",
-      name: "Task",
-      input: {
-        description: "full site audit",
-        run_in_background: true,
-        prompt: "audit example.com",
-      },
-    });
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const provider = new ClaudeSDKProvider();
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of provider.query({
-      prompt: "do the audit",
-      systemPrompt: "test",
-    })) {
-      chunks.push(c);
-    }
-
-    const toolUse = chunks.find(c => c.type === "tool_use");
-    expect(toolUse).toBeDefined();
-    expect(toolUse!.toolUseId).toBe("toolu_ABC123");
-    expect(toolUse!.runInBackground).toBe(true);
-    expect(toolUse!.toolName).toBe("Task");
-  });
-
-  it("extracts runInBackground=undefined when the flag is omitted", async () => {
-    mockFindClaudeBinary();
-    mockSDKWithToolUse({
-      type: "tool_use",
-      id: "toolu_XYZ",
-      name: "Task",
-      input: {
-        description: "sync task",
-        prompt: "do it",
-      },
-    });
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const provider = new ClaudeSDKProvider();
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of provider.query({
-      prompt: "test",
-      systemPrompt: "test",
-    })) {
-      chunks.push(c);
-    }
-
-    const toolUse = chunks.find(c => c.type === "tool_use");
-    expect(toolUse).toBeDefined();
-    expect(toolUse!.toolUseId).toBe("toolu_XYZ");
-    expect(toolUse!.runInBackground).toBeUndefined();
-  });
-
-  it("extracts runInBackground=false when the flag is explicitly false", async () => {
-    mockFindClaudeBinary();
-    mockSDKWithToolUse({
-      type: "tool_use",
-      id: "toolu_EXPLICIT",
-      name: "Agent",
-      input: {
-        description: "explicit sync",
-        run_in_background: false,
-        prompt: "do it synchronously",
-      },
-    });
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const provider = new ClaudeSDKProvider();
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of provider.query({
-      prompt: "test",
-      systemPrompt: "test",
-    })) {
-      chunks.push(c);
-    }
-
-    const toolUse = chunks.find(c => c.type === "tool_use");
-    expect(toolUse!.runInBackground).toBe(false);
-  });
-
-  it("toolInput is still serialized (for display in status line), but truncated at 500 chars", async () => {
-    mockFindClaudeBinary();
-    const longPrompt = "x".repeat(1000);
-    mockSDKWithToolUse({
-      type: "tool_use",
-      id: "toolu_LONG",
-      name: "Task",
-      input: {
-        description: "long prompt task",
-        run_in_background: true,
-        prompt: longPrompt,
-      },
-    });
-
-    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
-    const provider = new ClaudeSDKProvider();
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of provider.query({
-      prompt: "test",
-      systemPrompt: "test",
-    })) {
-      chunks.push(c);
-    }
-
-    const toolUse = chunks.find(c => c.type === "tool_use");
-    // runInBackground is extracted cleanly EVEN THOUGH toolInput is truncated
-    expect(toolUse!.runInBackground).toBe(true);
-    // toolInput is the display-truncated serialization (max ~501 chars)
-    expect(toolUse!.toolInput).toBeDefined();
-    expect(toolUse!.toolInput!.length).toBeLessThanOrEqual(501);
-  });
-});

package/test/console-timestamps.test.ts

@@ -1,98 +0,0 @@
-/**
- * Fix #10 — console output must carry ISO timestamps so out.log / err.log
- * are actually debuggable. Also: silence libsignal's "Closing session"
- * SessionEntry dumps which were pushing tens of KB per day into the logs
- * and making forensic work painful.
- *
- * Contract: `installConsoleFormatter(console)` wraps console.log /
- * console.warn / console.error so every line is prefixed with the
- * current ISO timestamp (zero-padded, UTC), and certain noise patterns
- * (libsignal session dumps) are dropped entirely.
- *
- * The wrapper is idempotent — calling it twice is a no-op.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import {
-  installConsoleFormatter,
-  uninstallConsoleFormatter,
-  isNoisyLine,
-} from "../src/util/console-formatter.js";
-
-describe("installConsoleFormatter (Fix #10)", () => {
-  let stdoutWrites: string[];
-  let stderrWrites: string[];
-  let origStdout: typeof process.stdout.write;
-  let origStderr: typeof process.stderr.write;
-
-  beforeEach(() => {
-    stdoutWrites = [];
-    stderrWrites = [];
-    origStdout = process.stdout.write.bind(process.stdout);
-    origStderr = process.stderr.write.bind(process.stderr);
-    process.stdout.write = ((chunk: unknown) => {
-      stdoutWrites.push(String(chunk));
-      return true;
-    }) as typeof process.stdout.write;
-    process.stderr.write = ((chunk: unknown) => {
-      stderrWrites.push(String(chunk));
-      return true;
-    }) as typeof process.stderr.write;
-  });
-
-  afterEach(() => {
-    uninstallConsoleFormatter();
-    process.stdout.write = origStdout;
-    process.stderr.write = origStderr;
-  });
-
-  it("prefixes console.log output with an ISO timestamp", () => {
-    installConsoleFormatter();
-    console.log("hello world");
-    const line = stdoutWrites.join("");
-    // ISO format like 2026-04-11T14:00:00.000Z
-    expect(line).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\s+hello world/);
-  });
-
-  it("prefixes console.error output with an ISO timestamp", () => {
-    installConsoleFormatter();
-    console.error("boom");
-    const line = stderrWrites.join("");
-    expect(line).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\s+boom/);
-  });
-
-  it("is idempotent — second install call does not double-prefix", () => {
-    installConsoleFormatter();
-    installConsoleFormatter();
-    console.log("once");
-    const line = stdoutWrites.join("");
-    // Exactly one ISO timestamp, not two
-    const matches = line.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z/g);
-    expect(matches).not.toBeNull();
-    expect(matches!.length).toBe(1);
-  });
-});
-
-describe("isNoisyLine (Fix #10)", () => {
-  it("treats libsignal session dumps as noise", () => {
-    const dump = `Closing session: SessionEntry {
-  _chains: {
-    'BUQxzJlwgVTCxCL5C4rTbZP/7a0ciMPnyo47Pwr4flJt': { chainKey: [Object], chainType: 1, messageKeys: {} }
-  },
-  registrationId: 1446528770`;
-    expect(isNoisyLine(dump)).toBe(true);
-  });
-
-  it("treats the one-line 'Closing open session' as noise", () => {
-    expect(isNoisyLine("Closing open session in favor of incoming prekey bundle")).toBe(true);
-  });
-
-  it("treats the repetitive claude native binary banner as noise", () => {
-    expect(isNoisyLine("[claude] Native binary: /Users/foo/.local/share/claude/versions/2.1.101")).toBe(true);
-  });
-
-  it("does NOT silence normal log output", () => {
-    expect(isNoisyLine("⏰ Cron scheduler started (30s interval)")).toBe(false);
-    expect(isNoisyLine("[watchdog] started — beacon every 30s")).toBe(false);
-    expect(isNoisyLine("Cron: Running job \"Daily Job Alert\"")).toBe(false);
-  });
-});

package/test/cron-progress-ticker.test.ts

@@ -1,76 +0,0 @@
-/**
- * Fix #15 (B) — /cron run must give visible feedback during long runs.
- *
- * Regression from production: a 13-minute Daily Job Alert run showed
- * the user ZERO feedback between trigger time and completion. The
- * sub-agent was actually working (and eventually succeeded), but the
- * Telegram chat was silent for the whole duration.
- *
- * This test doesn't exercise grammy directly — it tests the pure
- * helper that drives the live progress message so we can verify the
- * formatting, cadence math, and safety edges in isolation.
- */
-import { describe, it, expect } from "vitest";
-import { formatElapsed, buildTickerText, buildDoneText } from "../src/handlers/cron-progress.js";
-
-describe("formatElapsed (Fix #15B)", () => {
-  it("formats seconds under a minute", () => {
-    expect(formatElapsed(0)).toBe("0s");
-    expect(formatElapsed(45)).toBe("45s");
-    expect(formatElapsed(59)).toBe("59s");
-  });
-
-  it("formats minutes+seconds above a minute", () => {
-    expect(formatElapsed(60)).toBe("1m 0s");
-    expect(formatElapsed(61)).toBe("1m 1s");
-    expect(formatElapsed(125)).toBe("2m 5s");
-    expect(formatElapsed(797)).toBe("13m 17s"); // real prod duration
-  });
-
-  it("formats hours+minutes above 60m", () => {
-    expect(formatElapsed(3600)).toBe("1h 0m");
-    expect(formatElapsed(3660)).toBe("1h 1m");
-  });
-});
-
-describe("buildTickerText (Fix #15B)", () => {
-  it("shows job name and elapsed time in the running state", () => {
-    const text = buildTickerText("Daily Job Alert", 125);
-    expect(text).toContain("Daily Job Alert");
-    expect(text).toContain("2m 5s");
-    expect(text).toMatch(/🔄|running/i);
-  });
-
-  it("escapes markdown-breaking characters in the job name", () => {
-    // Underscores and asterisks in job names would otherwise break
-    // the Markdown edit and trigger "can't parse entities".
-    const text = buildTickerText("weird_job*name", 10);
-    expect(text).not.toContain("_job*"); // no raw unescaped asterisk
-    // We expect some form of escaping — back-slashes are fine
-    expect(text).toMatch(/weird/);
-  });
-});
-
-describe("buildDoneText (Fix #15B)", () => {
-  it("shows green check for a clean completion", () => {
-    const text = buildDoneText("Daily Job Alert", 797, { ok: true });
-    expect(text).toContain("✅");
-    expect(text).toContain("Daily Job Alert");
-    expect(text).toContain("13m 17s");
-  });
-
-  it("shows red cross and error excerpt for a failure", () => {
-    const text = buildDoneText("Daily Job Alert", 10, {
-      ok: false,
-      error: "Sub-agent cancelled: timeout",
-    });
-    expect(text).toContain("❌");
-    expect(text).toContain("timeout");
-  });
-
-  it("shows warning for an already-running skip", () => {
-    const text = buildDoneText("Daily Job Alert", 0, { ok: true, skipped: true });
-    expect(text).toContain("⏳");
-    expect(text).toMatch(/already running|in progress/i);
-  });
-});

package/test/cron-restart-resilience.test.ts

@@ -1,191 +0,0 @@
-/**
- * Fix #3 — Cron scheduler must survive a bot restart during job execution.
- *
- * Background: the old scheduler set `nextRunAt = null` immediately before
- * `await executeJob(job)` and only re-calculated it after completion. A
- * crash mid-execution (EADDRINUSE, unhandled rejection, launchd restart)
- * left `nextRunAt = null`, so the next boot called `calculateNextRun()`
- * from the current time — which for a cron expression always yields a
- * FUTURE trigger (e.g. tomorrow 08:00). Today's run was lost forever.
- *
- * New contract (pure-function pair):
- *
- *   prepareForExecution(job, now)
- *     - updates lastAttemptAt = now
- *     - updates nextRunAt = <next regular trigger from `now`>
- *     - returns the mutated job
- *
- *   handleStartupCatchup(jobs, now, graceMs)
- *     - for every enabled job where `lastAttemptAt > lastRunAt`
- *       (i.e. the last attempt never completed) AND the attempt is
- *       within `graceMs`, rewinds `nextRunAt` to `now` so the next
- *       scheduler tick picks it up immediately
- *     - for every enabled job where `lastAttemptAt > lastRunAt` but
- *       the attempt is older than `graceMs`, gives up and recalculates
- *       `nextRunAt` normally
- *     - never touches disabled jobs
- *     - returns a NEW array of jobs (pure, no mutation of input)
- */
-import { describe, it, expect } from "vitest";
-import {
-  prepareForExecution,
-  handleStartupCatchup,
-} from "../src/services/cron-scheduling.js";
-import type { CronJob } from "../src/services/cron.js";
-
-function makeJob(overrides: Partial<CronJob> = {}): CronJob {
-  return {
-    id: "job-1",
-    name: "Daily Job Alert",
-    type: "ai-query",
-    schedule: "00 08 * * *",
-    oneShot: false,
-    payload: { prompt: "x" },
-    target: { platform: "telegram", chatId: "1" },
-    enabled: true,
-    createdAt: 1_700_000_000_000,
-    lastRunAt: null,
-    lastResult: null,
-    lastError: null,
-    nextRunAt: null,
-    runCount: 0,
-    createdBy: "test",
-    ...overrides,
-  };
-}
-
-describe("prepareForExecution (Fix #3)", () => {
-  it("sets lastAttemptAt to now", () => {
-    const job = makeJob();
-    const now = 1_775_887_200_000; // 2026-04-11 08:00 Berlin
-    const updated = prepareForExecution(job, now);
-    expect(updated.lastAttemptAt).toBe(now);
-  });
-
-  it("advances nextRunAt to the NEXT regular trigger, not null", () => {
-    const job = makeJob({ schedule: "00 08 * * *" });
-    const now = 1_775_887_200_000; // today 08:00
-    const updated = prepareForExecution(job, now);
-    // nextRunAt must be a future timestamp, not null, not zero
-    expect(updated.nextRunAt).not.toBeNull();
-    expect(updated.nextRunAt!).toBeGreaterThan(now);
-  });
-
-  it("works with interval schedules — base = now, not lastRunAt", () => {
-    const job = makeJob({ schedule: "5m", lastRunAt: 1_000_000_000_000 });
-    const now = 1_775_887_200_000;
-    const updated = prepareForExecution(job, now);
-    expect(updated.nextRunAt).toBe(now + 5 * 60_000);
-  });
-
-  it("does not touch lastRunAt", () => {
-    const job = makeJob({ lastRunAt: 123 });
-    const updated = prepareForExecution(job, 9999);
-    expect(updated.lastRunAt).toBe(123);
-  });
-
-  it("is pure — returns a new object, leaves the input alone", () => {
-    const job = makeJob();
-    const before = JSON.stringify(job);
-    prepareForExecution(job, 42);
-    expect(JSON.stringify(job)).toBe(before);
-  });
-});
-
-describe("handleStartupCatchup (Fix #3)", () => {
-  const GRACE = 6 * 60 * 60 * 1000; // 6 h
-
-  it("rewinds nextRunAt to now when a recent attempt never completed", () => {
-    // Scenario: 08:00 triggered, 08:05 bot crashed, 10:30 bot restarts.
-    const job = makeJob({
-      lastRunAt: null,                              // never completed
-      lastAttemptAt: 1_775_887_200_000,             // 08:00
-      nextRunAt: 1_775_973_600_000,                 // tomorrow 08:00 (set pre-execution)
-    });
-    const now = 1_775_896_200_000;                  // 10:30
-    const [out] = handleStartupCatchup([job], now, GRACE);
-    expect(out.nextRunAt).toBe(now); // rewind → picked up on next tick
-  });
-
-  it("does not rewind when attempt completed (lastRunAt >= lastAttemptAt)", () => {
-    const tomorrow8am = 1_775_973_600_000;
-    const job = makeJob({
-      lastRunAt: 1_775_896_200_000,                 // completed at 10:30
-      lastAttemptAt: 1_775_887_200_000,             // started at 08:00
-      nextRunAt: tomorrow8am,
-    });
-    const now = 1_775_900_000_000;
-    const [out] = handleStartupCatchup([job], now, GRACE);
-    expect(out.nextRunAt).toBe(tomorrow8am); // unchanged
-  });
-
-  it("gives up when the attempt is older than the grace window", () => {
-    // Scenario: attempt was 7h ago, never completed, bot only now back up.
-    const sevenHoursAgo = 1_775_887_200_000 - 60_000;
-    const now = sevenHoursAgo + 7 * 60 * 60 * 1000 + 60_000;
-    const job = makeJob({
-      lastRunAt: null,
-      lastAttemptAt: sevenHoursAgo,
-      nextRunAt: now + 86_400_000, // whatever — scheduler will replace
-    });
-    const [out] = handleStartupCatchup([job], now, GRACE);
-    // Must NOT rewind to `now`. Must either keep the future value or
-    // recompute — either way it has to stay strictly greater than now.
-    expect(out.nextRunAt).not.toBe(now);
-    expect(out.nextRunAt!).toBeGreaterThan(now);
-  });
-
-  it("ignores disabled jobs", () => {
-    const job = makeJob({
-      enabled: false,
-      lastRunAt: null,
-      lastAttemptAt: 1_775_887_200_000,
-      nextRunAt: 1_775_973_600_000,
-    });
-    const now = 1_775_896_200_000;
-    const [out] = handleStartupCatchup([job], now, GRACE);
-    expect(out).toEqual(job); // untouched
-  });
-
-  it("handles jobs without any attempt history (no-op)", () => {
-    const job = makeJob({
-      lastRunAt: null,
-      lastAttemptAt: null,
-      nextRunAt: 1_775_973_600_000,
-    });
-    const now = 1_775_896_200_000;
-    const [out] = handleStartupCatchup([job], now, GRACE);
-    expect(out).toEqual(job);
-  });
-
-  it("is pure — does not mutate the input array", () => {
-    const job = makeJob({
-      lastRunAt: null,
-      lastAttemptAt: 1_775_887_200_000,
-      nextRunAt: 1_775_973_600_000,
-    });
-    const input = [job];
-    const snapshot = JSON.stringify(input);
-    handleStartupCatchup(input, 1_775_896_200_000, GRACE);
-    expect(JSON.stringify(input)).toBe(snapshot);
-  });
-
-  it("processes multiple jobs independently", () => {
-    const now = 1_775_896_200_000;
-    const recent = makeJob({
-      id: "a",
-      lastRunAt: null,
-      lastAttemptAt: 1_775_887_200_000, // within grace
-      nextRunAt: 1_775_973_600_000,
-    });
-    const completed = makeJob({
-      id: "b",
-      lastRunAt: 1_775_887_500_000,
-      lastAttemptAt: 1_775_887_200_000,
-      nextRunAt: 1_775_973_600_000,
-    });
-    const out = handleStartupCatchup([recent, completed], now, GRACE);
-    expect(out[0].nextRunAt).toBe(now);            // caught up
-    expect(out[1].nextRunAt).toBe(1_775_973_600_000); // untouched
-  });
-});