@app-vitals/agent-runtime 0.0.0-stage → 0.1.0

package/cron-handler.integration.test.ts

@@ -0,0 +1,614 @@
+/**
+ * Integration tests for cron-handler.ts's progress push + partial-usage-on-
+ * failure wiring (CSU-3.2 — the generic cron-dispatch-path port of CSU-3.1's
+ * loop-orchestrator.ts wiring).
+ *
+ * Strategy: inject all deps (Clock, CronRunReporter, runner) — no
+ * mock.module(), no real Slack/Claude calls. Mirrors
+ * loop-orchestrator.integration.test.ts's CSU-3.1 suite.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { WebClient } from "@slack/web-api";
+import {
+  ClaudeRunError,
+  type ClaudeRunResult,
+  ClaudeTimeoutError,
+  type ModelUsage,
+  type ProgressCallback,
+} from "./claude.ts";
+import type { Clock } from "./clock.ts";
+import { handleCronRequest } from "./cron-handler.ts";
+import type {
+  CronRunReporter,
+  ModelBreakdownEntry,
+} from "./cron-run-reporter.ts";
+
+// ─── Shared fakes ─────────────────────────────────────────────────────────────
+
+const mockSlack = {
+  chat: { postMessage: async () => ({ ok: true, ts: "1234567890.000001" }) },
+  conversations: { open: async () => ({ channel: { id: "D_DM" } }) },
+} as unknown as WebClient;
+
+function makeUsage(overrides: Partial<ModelBreakdownEntry> = {}): ModelUsage {
+  return {
+    "claude-opus-4": {
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      costUSD: 0.42,
+      ...overrides,
+    },
+  };
+}
+
+/** A mutable clock — lets debounce tests advance "now" between calls. */
+function makeMutableClock(start: Date): Clock & { advance(ms: number): void } {
+  let current = start;
+  return {
+    now: () => current,
+    advance(ms: number) {
+      current = new Date(current.getTime() + ms);
+    },
+  };
+}
+
+function makeRecordingReporter(): {
+  reporter: CronRunReporter;
+  completeCalls: Array<{
+    outcome: "completed" | "failed";
+    opts?: {
+      error?: string;
+      modelBreakdown?: ModelBreakdownEntry[];
+      sessionId?: string;
+    };
+  }>;
+  progressCalls: Array<{
+    runId: string | null;
+    modelBreakdown: ModelBreakdownEntry[];
+    lastHeartbeatAt: Date;
+  }>;
+} {
+  const completeCalls: Array<{
+    outcome: "completed" | "failed";
+    opts?: {
+      error?: string;
+      modelBreakdown?: ModelBreakdownEntry[];
+      sessionId?: string;
+    };
+  }> = [];
+  const progressCalls: Array<{
+    runId: string | null;
+    modelBreakdown: ModelBreakdownEntry[];
+    lastHeartbeatAt: Date;
+  }> = [];
+  const reporter: CronRunReporter = {
+    async createRun() {
+      return "run-1";
+    },
+    async completeRun(_cronId, _runId, _completedAt, outcome, opts) {
+      completeCalls.push({ outcome, opts });
+    },
+    async skipRun() {},
+    async recordProgress(_cronId, runId, modelBreakdown, lastHeartbeatAt) {
+      progressCalls.push({ runId, modelBreakdown, lastHeartbeatAt });
+    },
+    async recordSessionId() {},
+  };
+  return { reporter, completeCalls, progressCalls };
+}
+
+// ─── Progress push + partial-usage-on-failure (CSU-3.2) ─────────────────────
+
+describe("handleCronRequest + progress push / partial-usage-on-failure (CSU-3.2)", () => {
+  test("a runner that emits progress via onProgress before resolving triggers recordProgress mid-dispatch, before completeRun", async () => {
+    const { reporter, completeCalls, progressCalls } = makeRecordingReporter();
+    const callOrder: string[] = [];
+
+    const trackedReporter: CronRunReporter = {
+      ...reporter,
+      async recordProgress(cronId, runId, modelBreakdown, lastHeartbeatAt) {
+        callOrder.push("recordProgress");
+        await reporter.recordProgress(
+          cronId,
+          runId,
+          modelBreakdown,
+          lastHeartbeatAt,
+        );
+      },
+      async completeRun(
+        cronId,
+        runId,
+        completedAt,
+        outcome,
+        opts,
+        phaseId,
+        itemType,
+        itemId,
+      ) {
+        callOrder.push("completeRun");
+        await reporter.completeRun(
+          cronId,
+          runId,
+          completedAt,
+          outcome,
+          opts,
+          phaseId,
+          itemType,
+          itemId,
+        );
+      },
+    };
+
+    const runner = async (
+      _message: string,
+      onProgress?: ProgressCallback,
+    ): Promise<ClaudeRunResult> => {
+      onProgress?.(makeUsage());
+      return { result: "done", sessionId: "s1", modelUsage: makeUsage() };
+    };
+
+    await handleCronRequest(
+      { jobId: "progress-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: trackedReporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(progressCalls).toHaveLength(1);
+    expect(progressCalls[0]?.modelBreakdown).toEqual([
+      {
+        model: "claude-opus-4",
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0.42,
+      },
+    ]);
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+
+    // recordProgress fired before completeRun for this dispatch.
+    expect(callOrder).toEqual(["recordProgress", "completeRun"]);
+  });
+
+  test("a thrown ClaudeTimeoutError with partial usage results in completeRun's failed call carrying modelBreakdown", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const partialUsage = makeUsage({ inputTokens: 10, outputTokens: 5 });
+    const runner = async (): Promise<ClaudeRunResult> => {
+      throw new ClaudeTimeoutError(600_000, "ceiling", partialUsage);
+    };
+
+    await expect(
+      handleCronRequest(
+        { jobId: "timeout-job", prompt: "hello", channel: "C-X" },
+        {
+          slack: mockSlack,
+          runner,
+          cronRunReporter: reporter,
+          clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+        },
+      ),
+    ).rejects.toThrow(ClaudeTimeoutError);
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("failed");
+    expect(completeCalls[0]?.opts?.error).toContain("timed out");
+    expect(completeCalls[0]?.opts?.modelBreakdown).toEqual([
+      {
+        model: "claude-opus-4",
+        inputTokens: 10,
+        outputTokens: 5,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0.42,
+      },
+    ]);
+  });
+
+  test("two rapid onProgress calls (<5s apart) only trigger one recordProgress call (debounced)", async () => {
+    const { reporter, progressCalls } = makeRecordingReporter();
+    const clock = makeMutableClock(new Date("2026-07-20T00:00:00Z"));
+
+    const runner = async (
+      _message: string,
+      onProgress?: ProgressCallback,
+    ): Promise<ClaudeRunResult> => {
+      onProgress?.(makeUsage({ inputTokens: 10 }));
+      // Advance less than the 5s debounce window before the second push.
+      clock.advance(1000);
+      onProgress?.(makeUsage({ inputTokens: 20 }));
+      return {
+        result: "done",
+        sessionId: "s1",
+        modelUsage: makeUsage({ inputTokens: 20 }),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "debounce-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock,
+      },
+    );
+
+    expect(progressCalls).toHaveLength(1);
+    expect(progressCalls[0]?.modelBreakdown?.[0]?.inputTokens).toBe(10);
+  });
+
+  // ─── lastHeartbeatAt sourced from the injected Clock (CRH-1.1) ────────────
+
+  test("recordProgress's lastHeartbeatAt is sourced from the injected Clock at push time, not wall-clock", async () => {
+    const { reporter, progressCalls } = makeRecordingReporter();
+    // A clock fixed far from the real wall clock — if the implementation ever
+    // reached for new Date()/Date.now() instead of clock.now(), the pushed
+    // timestamp would not equal this fixed instant.
+    const clock = makeMutableClock(new Date("2020-01-01T00:00:00Z"));
+
+    const runner = async (
+      _message: string,
+      onProgress?: ProgressCallback,
+    ): Promise<ClaudeRunResult> => {
+      onProgress?.(makeUsage());
+      return { result: "done", sessionId: "s1", modelUsage: makeUsage() };
+    };
+
+    await handleCronRequest(
+      { jobId: "heartbeat-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock,
+      },
+    );
+
+    expect(progressCalls).toHaveLength(1);
+    expect(progressCalls[0]?.lastHeartbeatAt).toEqual(
+      new Date("2020-01-01T00:00:00Z"),
+    );
+  });
+
+  test("two debounced progress pushes at different clock ticks each carry their own lastHeartbeatAt", async () => {
+    const { reporter, progressCalls } = makeRecordingReporter();
+    const clock = makeMutableClock(new Date("2026-07-20T00:00:00Z"));
+
+    const runner = async (
+      _message: string,
+      onProgress?: ProgressCallback,
+    ): Promise<ClaudeRunResult> => {
+      onProgress?.(makeUsage({ inputTokens: 10 }));
+      // Advance past the 5s debounce window before the second push.
+      clock.advance(6000);
+      onProgress?.(makeUsage({ inputTokens: 20 }));
+      return {
+        result: "done",
+        sessionId: "s1",
+        modelUsage: makeUsage({ inputTokens: 20 }),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "heartbeat-debounce-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock,
+      },
+    );
+
+    expect(progressCalls).toHaveLength(2);
+    expect(progressCalls[0]?.lastHeartbeatAt).toEqual(
+      new Date("2026-07-20T00:00:00Z"),
+    );
+    expect(progressCalls[1]?.lastHeartbeatAt).toEqual(
+      new Date("2026-07-20T00:00:06Z"),
+    );
+  });
+});
+
+// ─── sessionId wired into completeRun (CSI-2.2) ─────────────────────────────
+
+describe("handleCronRequest + sessionId wiring into completeRun (CSI-2.2)", () => {
+  test("a completed non-silent channel-post run's completeRun opts include the runResult's sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      return {
+        result: "done",
+        sessionId: "session-channel-1",
+        modelUsage: makeUsage(),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "channel-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-channel-1");
+  });
+
+  test("a completed DM-post run's completeRun opts include the runResult's sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      return {
+        result: "done",
+        sessionId: "session-dm-1",
+        modelUsage: makeUsage(),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "dm-job", prompt: "hello", user: "U-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-dm-1");
+  });
+
+  test("a silent (req.silent) run's completeRun opts include the runResult's sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      return {
+        result: "done",
+        sessionId: "session-silent-1",
+        modelUsage: makeUsage(),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "silent-job", prompt: "hello", silent: true },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-silent-1");
+  });
+
+  test("a run whose result carries a [silent] marker (isSilentMarker && !isDmOnly) has completeRun opts include the runResult's sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      return {
+        result: "done [silent]",
+        sessionId: "session-silent-marker-1",
+        modelUsage: makeUsage(),
+      };
+    };
+
+    await handleCronRequest(
+      { jobId: "silent-marker-job", prompt: "hello", channel: "C-X" },
+      {
+        slack: mockSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-silent-marker-1");
+  });
+
+  test("a thrown ClaudeTimeoutError carrying a sessionId results in completeRun's failed call carrying that sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      throw new ClaudeTimeoutError(
+        600_000,
+        "ceiling",
+        makeUsage(),
+        "session-timeout-1",
+      );
+    };
+
+    await expect(
+      handleCronRequest(
+        { jobId: "timeout-job", prompt: "hello", channel: "C-X" },
+        {
+          slack: mockSlack,
+          runner,
+          cronRunReporter: reporter,
+          clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+        },
+      ),
+    ).rejects.toThrow(ClaudeTimeoutError);
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("failed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-timeout-1");
+  });
+
+  test("a thrown ClaudeRunError carrying a sessionId results in completeRun's failed call carrying that sessionId", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      throw new ClaudeRunError(
+        "boom",
+        undefined,
+        "resultMessage detail",
+        "session-run-error-1",
+      );
+    };
+
+    await expect(
+      handleCronRequest(
+        { jobId: "run-error-job", prompt: "hello", channel: "C-X" },
+        {
+          slack: mockSlack,
+          runner,
+          cronRunReporter: reporter,
+          clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+        },
+      ),
+    ).rejects.toThrow(ClaudeRunError);
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("failed");
+    expect(completeCalls[0]?.opts?.sessionId).toBe("session-run-error-1");
+  });
+
+  test("a thrown plain Error (no sessionId field) results in completeRun's failed call with sessionId undefined", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+
+    const runner = async (): Promise<ClaudeRunResult> => {
+      throw new Error("generic failure");
+    };
+
+    await expect(
+      handleCronRequest(
+        { jobId: "generic-error-job", prompt: "hello", channel: "C-X" },
+        {
+          slack: mockSlack,
+          runner,
+          cronRunReporter: reporter,
+          clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+        },
+      ),
+    ).rejects.toThrow("generic failure");
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("failed");
+    expect(completeCalls[0]?.opts?.sessionId).toBeUndefined();
+  });
+});
+
+// ─── Chat-only agent (no Slack client) ────────────────────────────────────────
+
+describe("cron dispatch on an agent with no Slack credentials", () => {
+  /**
+   * A chat-only agent gets `slack: undefined` from index.ts rather than a
+   * WebClient wrapped around an empty token. The job must still run and be
+   * recorded as completed — only the delivery step is skipped.
+   */
+  test("a channel-targeted job completes and posts nothing", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+    let posted = false;
+    const runner = async (): Promise<ClaudeRunResult> => {
+      posted = false;
+      return { result: "work happened", sessionId: "s1" };
+    };
+
+    await handleCronRequest(
+      { jobId: "chat-only-channel", prompt: "hello", channel: "C-X" },
+      {
+        slack: undefined,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+    expect(posted).toBe(false);
+  });
+
+  test("a DM-targeted job completes and opens no conversation", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+    const runner = async (): Promise<ClaudeRunResult> => ({
+      result: "work happened",
+      sessionId: "s1",
+    });
+
+    await handleCronRequest(
+      { jobId: "chat-only-dm", prompt: "hello", user: "U-X" },
+      {
+        slack: undefined,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+  });
+
+  test("a silent job is unaffected — it never reached delivery anyway", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+    const runner = async (): Promise<ClaudeRunResult> => ({
+      result: "quiet work",
+      sessionId: "s1",
+    });
+
+    await handleCronRequest(
+      { jobId: "chat-only-silent", prompt: "hello", silent: true },
+      {
+        slack: undefined,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(completeCalls).toHaveLength(1);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+  });
+
+  test("with a Slack client present, a channel job still delivers", async () => {
+    const { reporter, completeCalls } = makeRecordingReporter();
+    const channels: string[] = [];
+    const recordingSlack = {
+      chat: {
+        postMessage: async (args: { channel: string }) => {
+          channels.push(args.channel);
+          return { ok: true, ts: "1234567890.000001" };
+        },
+      },
+      conversations: { open: async () => ({ channel: { id: "D_DM" } }) },
+    } as unknown as WebClient;
+    const runner = async (): Promise<ClaudeRunResult> => ({
+      result: "work happened",
+      sessionId: "s1",
+    });
+
+    await handleCronRequest(
+      { jobId: "slack-present", prompt: "hello", channel: "C-X" },
+      {
+        slack: recordingSlack,
+        runner,
+        cronRunReporter: reporter,
+        clock: makeMutableClock(new Date("2026-07-20T00:00:00Z")),
+      },
+    );
+
+    expect(channels).toEqual(["C-X"]);
+    expect(completeCalls[0]?.outcome).toBe("completed");
+  });
+});