@app-vitals/agent-admin 0.0.1 → 0.1.1

package/src/agent-cron-runs.integration.test.ts

@@ -0,0 +1,1491 @@
+/**
+ * admin/src/agent-cron-runs.integration.test.ts
+ * Integration tests for AgentCronRunService — create/list run records.
+ *
+ * Requires DATABASE_URL_ADMIN_TEST to be set; skips otherwise.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import { AgentCronJobService } from "./agent-cron-jobs.ts";
+import { AgentCronRunService } from "./agent-cron-runs.ts";
+import { FixedClock } from "./clock.ts";
+import { NotFoundError } from "./errors.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+function makePrisma(): PrismaClient {
+  // TEST_DB is guaranteed set — the describe block is skipped otherwise.
+  return createAdminPrismaClient(TEST_DB as string);
+}
+
+async function createAgent(
+  prisma: PrismaClient,
+  name = "Test Agent",
+): Promise<string> {
+  const agent = await prisma.agent.create({ data: { name } });
+  return agent.id;
+}
+
+async function createCron(
+  cronJobService: AgentCronJobService,
+  agentId: string,
+): Promise<string> {
+  const job = await cronJobService.create(agentId, {
+    schedule: "0 9 * * *",
+    prompt: "Test prompt",
+    silent: true,
+  });
+  return job.id;
+}
+
+// Fixed "now" for deterministic day-boundary tests: 2026-01-15T12:00:00Z
+// setUTCHours(0,0,0,0) on this gives 2026-01-15T00:00:00.000Z
+const FIXED_NOW = new Date("2026-01-15T12:00:00Z");
+
+describeOrSkip("AgentCronRunService (integration)", () => {
+  let prisma: PrismaClient;
+  let cronJobService: AgentCronJobService;
+  let runService: AgentCronRunService;
+
+  beforeEach(async () => {
+    prisma = makePrisma();
+    await prisma.agentCronRun.deleteMany();
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+    cronJobService = new AgentCronJobService(prisma, FixedClock(FIXED_NOW));
+    runService = new AgentCronRunService(prisma);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  // ─── create ─────────────────────────────────────────────────────────────────
+
+  it("create() creates a run record and returns 201 data", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+    });
+
+    expect(run.cronId).toBe(cronId);
+    expect(run.agentId).toBe(agentId);
+    expect(run.skipped).toBe(false);
+    expect(run.outcome).toBe("success");
+    expect(run.startedAt).toEqual(startedAt);
+    expect(run.completedAt).toBeNull();
+    expect(run.error).toBeNull();
+    expect(run.skipReason).toBeNull();
+  });
+
+  it("create() supports optional completedAt, skipReason, error fields", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+    const completedAt = new Date(startedAt.getTime() + 5000);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      completedAt,
+      skipped: true,
+      skipReason: "pre-check returned false",
+      error: null,
+      outcome: null,
+    });
+
+    expect(run.completedAt).toEqual(completedAt);
+    expect(run.skipped).toBe(true);
+    expect(run.skipReason).toBe("pre-check returned false");
+  });
+
+  it("create() round-trips an optional phaseId field", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const phaseCron = await cronJobService.create(agentId, {
+      schedule: "0 9 * * *",
+      prompt: "Test prompt",
+      silent: true,
+      name: "shipwright-dev-task",
+    });
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+      phaseId: phaseCron.id,
+    });
+
+    expect(run.phaseId).toBe(phaseCron.id);
+
+    const { items } = await runService.list(cronId, agentId);
+    expect(items[0].phaseId).toBe(phaseCron.id);
+  });
+
+  it("create() leaves phaseId null when not provided (legacy behavior unchanged)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+    });
+
+    expect(run.phaseId).toBeNull();
+
+    const { items } = await runService.list(cronId, agentId);
+    expect(items[0].phaseId).toBeNull();
+  });
+
+  it("create() round-trips optional itemType/itemId fields for a task item", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+      itemType: "task",
+      itemId: "WLS-2.2",
+    });
+
+    expect(run.itemType).toBe("task");
+    expect(run.itemId).toBe("WLS-2.2");
+
+    const { items } = await runService.list(cronId, agentId);
+    expect(items[0].itemType).toBe("task");
+    expect(items[0].itemId).toBe("WLS-2.2");
+  });
+
+  it("create() round-trips optional itemType/itemId fields for a PR item", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+      itemType: "pr",
+      itemId: "acme/x#123",
+    });
+
+    expect(run.itemType).toBe("pr");
+    expect(run.itemId).toBe("acme/x#123");
+
+    const { items } = await runService.list(cronId, agentId);
+    expect(items[0].itemType).toBe("pr");
+    expect(items[0].itemId).toBe("acme/x#123");
+  });
+
+  it("create() leaves itemType/itemId null when not provided (skipped tick with no dispatch)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date();
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+      outcome: "success",
+    });
+
+    expect(run.itemType).toBeNull();
+    expect(run.itemId).toBeNull();
+
+    const { items } = await runService.list(cronId, agentId);
+    expect(items[0].itemType).toBeNull();
+    expect(items[0].itemId).toBeNull();
+  });
+
+  it("create() throws NotFoundError when cronId does not exist", async () => {
+    const agentId = await createAgent(prisma);
+
+    await expect(
+      runService.create("nonexistent-cron-id", agentId, {
+        startedAt: new Date(),
+        skipped: false,
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  it("create() throws NotFoundError when cronId belongs to a different agent", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId = await createCron(cronJobService, agentId1);
+
+    await expect(
+      runService.create(cronId, agentId2, {
+        startedAt: new Date(),
+        skipped: false,
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  // ─── list ──────────────────────────────────────────────────────────────────
+
+  it("list() returns runs sorted descending by startedAt", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const t1 = new Date("2026-01-01T08:00:00Z");
+    const t2 = new Date("2026-01-02T08:00:00Z");
+    const t3 = new Date("2026-01-03T08:00:00Z");
+
+    await runService.create(cronId, agentId, { startedAt: t1, skipped: false });
+    await runService.create(cronId, agentId, { startedAt: t2, skipped: false });
+    await runService.create(cronId, agentId, { startedAt: t3, skipped: false });
+
+    const { items, total } = await runService.list(cronId, agentId);
+
+    expect(total).toBe(3);
+    expect(items).toHaveLength(3);
+    // Descending: t3, t2, t1
+    expect(items[0].startedAt).toEqual(t3);
+    expect(items[1].startedAt).toEqual(t2);
+    expect(items[2].startedAt).toEqual(t1);
+  });
+
+  it("list() defaults to limit 20", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    // Create 25 runs
+    for (let i = 0; i < 25; i++) {
+      await runService.create(cronId, agentId, {
+        startedAt: new Date(Date.now() + i * 1000),
+        skipped: false,
+      });
+    }
+
+    const { items, total } = await runService.list(cronId, agentId);
+    expect(items).toHaveLength(20);
+    expect(total).toBe(25);
+  });
+
+  it("list() supports custom limit and offset", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    for (let i = 0; i < 5; i++) {
+      await runService.create(cronId, agentId, {
+        startedAt: new Date(Date.now() + i * 1000),
+        skipped: false,
+      });
+    }
+
+    const { items, total } = await runService.list(cronId, agentId, {
+      limit: 2,
+      offset: 1,
+    });
+    expect(items).toHaveLength(2);
+    expect(total).toBe(5);
+  });
+
+  it("list() throws NotFoundError when cronId belongs to a different agent", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId = await createCron(cronJobService, agentId1);
+
+    await expect(runService.list(cronId, agentId2)).rejects.toBeInstanceOf(
+      NotFoundError,
+    );
+  });
+
+  it("list() opts.itemId narrows results to runs dispatched against that item", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      itemType: "task",
+      itemId: "WLS-2.2",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+      itemType: "pr",
+      itemId: "acme/x#123",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.list(cronId, agentId, {
+      itemId: "WLS-2.2",
+    });
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].itemId).toBe("WLS-2.2");
+  });
+
+  it("list() opts.phaseId narrows results to runs dispatched by that phase cron", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const phaseCronReview = await cronJobService.create(agentId, {
+      schedule: "0 9 * * *",
+      prompt: "Test prompt",
+      silent: true,
+      name: "shipwright-review",
+    });
+    const phaseCronDeploy = await cronJobService.create(agentId, {
+      schedule: "0 9 * * *",
+      prompt: "Test prompt",
+      silent: true,
+      name: "shipwright-deploy",
+    });
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      phaseId: phaseCronReview.id,
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+      phaseId: phaseCronDeploy.id,
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.list(cronId, agentId, {
+      phaseId: phaseCronReview.id,
+    });
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].phaseId).toBe(phaseCronReview.id);
+  });
+
+  it("list() combines itemId and phaseId filters (AND, not OR)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const phaseCronReview = await cronJobService.create(agentId, {
+      schedule: "0 9 * * *",
+      prompt: "Test prompt",
+      silent: true,
+      name: "shipwright-review",
+    });
+    const phaseCronDeploy = await cronJobService.create(agentId, {
+      schedule: "0 9 * * *",
+      prompt: "Test prompt",
+      silent: true,
+      name: "shipwright-deploy",
+    });
+
+    // Matches both filters
+    const matching = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      itemType: "pr",
+      itemId: "acme/x#123",
+      phaseId: phaseCronReview.id,
+    });
+    // Same itemId, different phaseId — must not match
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+      itemType: "pr",
+      itemId: "acme/x#123",
+      phaseId: phaseCronDeploy.id,
+    });
+    // Same phaseId, different itemId — must not match
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+      itemType: "pr",
+      itemId: "acme/y#456",
+      phaseId: phaseCronReview.id,
+    });
+
+    const { items, total } = await runService.list(cronId, agentId, {
+      itemId: "acme/x#123",
+      phaseId: phaseCronReview.id,
+    });
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].id).toBe(matching.id);
+  });
+
+  it("list() with neither itemId nor phaseId returns unfiltered results (existing behavior unchanged)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      itemId: "WLS-2.2",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.list(cronId, agentId, {
+      limit: 10,
+      offset: 0,
+    });
+
+    expect(total).toBe(2);
+    expect(items).toHaveLength(2);
+  });
+
+  it("list() returns modelBreakdown rows for a run with multiple models", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      outcome: "success",
+      modelBreakdown: [
+        {
+          model: "claude-sonnet-4-5",
+          inputTokens: 200,
+          outputTokens: 100,
+          cacheReadTokens: 8,
+          cacheCreationTokens: 4,
+          costUsd: 0.002,
+        },
+        {
+          model: "claude-haiku-4-5",
+          inputTokens: 50,
+          outputTokens: 20,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          costUsd: 0.0005,
+        },
+      ],
+    });
+
+    const { items } = await runService.list(cronId, agentId);
+
+    expect(items).toHaveLength(1);
+    const breakdown = items[0].modelBreakdown;
+    expect(breakdown).toHaveLength(2);
+    const models = breakdown.map((b) => b.model).sort();
+    expect(models).toEqual(["claude-haiku-4-5", "claude-sonnet-4-5"]);
+    const sonnet = breakdown.find((b) => b.model === "claude-sonnet-4-5");
+    expect(sonnet?.inputTokens).toBe(200);
+    expect(sonnet?.outputTokens).toBe(100);
+    expect(sonnet?.cacheReadTokens).toBe(8);
+    expect(sonnet?.cacheCreationTokens).toBe(4);
+    expect(sonnet?.costUsd).toBeCloseTo(0.002);
+  });
+
+  it("list() returns an empty modelBreakdown array for a run with no model breakdown rows", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+
+    const { items } = await runService.list(cronId, agentId);
+
+    expect(items).toHaveLength(1);
+    expect(items[0].modelBreakdown).toEqual([]);
+  });
+
+  // ─── patch ──────────────────────────────────────────────────────────────────
+
+  it("patch() updates completion fields and ignores legacy token fields", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date("2026-01-15T10:00:00Z");
+    const completedAt = new Date("2026-01-15T10:05:00Z");
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+    });
+
+    // Legacy top-level token fields are still accepted in the input (older agent
+    // builds send them) but are no longer persisted — the columns were dropped
+    // and all token accounting flows through AgentCronRunModelBreakdown.
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      completedAt,
+      outcome: "success",
+      inputTokens: 1234,
+      outputTokens: 567,
+      cacheReadTokens: 89,
+      cacheCreationTokens: 10,
+    });
+
+    expect(updated.id).toBe(run.id);
+    expect(updated.completedAt).toEqual(completedAt);
+    expect(updated.outcome).toBe("success");
+    // Token columns no longer exist on the run; no breakdown rows were written
+    // because the payload carried no modelBreakdown.
+    expect(updated.modelBreakdown).toEqual([]);
+  });
+
+  it("patch() updates error and skipped fields", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const startedAt = new Date("2026-01-15T10:00:00Z");
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt,
+      skipped: false,
+    });
+
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      completedAt: new Date("2026-01-15T10:01:00Z"),
+      outcome: "error",
+      error: "something went wrong",
+    });
+
+    expect(updated.outcome).toBe("error");
+    expect(updated.error).toBe("something went wrong");
+  });
+
+  it("patch() throws NotFoundError when runId does not exist", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await expect(
+      runService.patch("nonexistent-run-id", agentId, cronId, {
+        outcome: "success",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  it("patch() throws NotFoundError when runId belongs to a different agent", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId = await createCron(cronJobService, agentId1);
+
+    const run = await runService.create(cronId, agentId1, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    await expect(
+      runService.patch(run.id, agentId2, cronId, {
+        outcome: "success",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  it("patch() throws NotFoundError when runId belongs to a different cron", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId1 = await createCron(cronJobService, agentId);
+    const cronId2 = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId1, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    await expect(
+      runService.patch(run.id, agentId, cronId2, {
+        outcome: "success",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  it("patch() round-trips a sessionId field", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+    expect(run.sessionId).toBeNull();
+
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      sessionId: "session-abc-123",
+    });
+
+    expect(updated.sessionId).toBe("session-abc-123");
+  });
+
+  it("patch() clears sessionId when explicitly set to null", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      sessionId: "session-to-be-cleared",
+    });
+    const cleared = await runService.patch(run.id, agentId, cronId, {
+      sessionId: null,
+    });
+
+    expect(cleared.sessionId).toBeNull();
+  });
+
+  it("patch() leaves sessionId untouched when omitted from the input", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      sessionId: "session-should-persist",
+    });
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      outcome: "success",
+    });
+
+    expect(updated.sessionId).toBe("session-should-persist");
+  });
+
+  // ─── patch — lastHeartbeatAt (CRH-1.1) ─────────────────────────────────────
+
+  it("patch() round-trips a lastHeartbeatAt field", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+    expect(run.lastHeartbeatAt).toBeNull();
+
+    const heartbeatAt = new Date("2026-01-15T10:00:05Z");
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: heartbeatAt,
+    });
+
+    expect(updated.lastHeartbeatAt).toEqual(heartbeatAt);
+  });
+
+  it("patch() clears lastHeartbeatAt when explicitly set to null", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: new Date("2026-01-15T10:00:05Z"),
+    });
+    const cleared = await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: null,
+    });
+
+    expect(cleared.lastHeartbeatAt).toBeNull();
+  });
+
+  it("patch() leaves lastHeartbeatAt untouched when omitted from the input", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+    const heartbeatAt = new Date("2026-01-15T10:00:05Z");
+
+    await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: heartbeatAt,
+    });
+    const updated = await runService.patch(run.id, agentId, cronId, {
+      outcome: "success",
+    });
+
+    expect(updated.lastHeartbeatAt).toEqual(heartbeatAt);
+  });
+
+  it("patch() updates lastHeartbeatAt repeatedly across successive progress pushes (debounced heartbeat simulation)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: new Date("2026-01-15T10:00:05Z"),
+    });
+    const secondPush = await runService.patch(run.id, agentId, cronId, {
+      lastHeartbeatAt: new Date("2026-01-15T10:00:10Z"),
+    });
+
+    expect(secondPush.lastHeartbeatAt).toEqual(
+      new Date("2026-01-15T10:00:10Z"),
+    );
+  });
+
+  // ─── listWithRunSummary ─────────────────────────────────────────────────────
+
+  it("listWithRunSummary() returns lastRun null when no runs exist", async () => {
+    const agentId = await createAgent(prisma);
+    await createCron(cronJobService, agentId);
+
+    const jobs = await cronJobService.listWithRunSummary(agentId);
+    expect(jobs).toHaveLength(1);
+    expect(jobs[0].lastRun).toBeNull();
+    expect(jobs[0].runCountToday).toBe(0);
+  });
+
+  it("listWithRunSummary() returns lastRun as the most recent run", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const t1 = new Date("2026-01-01T06:00:00Z");
+    const t2 = new Date("2026-01-01T08:00:00Z");
+
+    await runService.create(cronId, agentId, {
+      startedAt: t1,
+      completedAt: new Date(t1.getTime() + 1000),
+      skipped: false,
+      outcome: "success",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: t2,
+      completedAt: new Date(t2.getTime() + 2000),
+      skipped: false,
+      outcome: "error",
+    });
+
+    const jobs = await cronJobService.listWithRunSummary(agentId);
+    expect(jobs[0].lastRun).not.toBeNull();
+    expect(jobs[0].lastRun?.startedAt).toEqual(t2);
+    expect(jobs[0].lastRun?.outcome).toBe("error");
+  });
+
+  it("listWithRunSummary() counts runCountToday correctly", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    // Derive midnight from the fixed clock so the boundary matches what the
+    // service computes — avoids a narrow race when the real clock rolls over midnight.
+    const todayMidnightUtc = new Date(FIXED_NOW);
+    todayMidnightUtc.setUTCHours(0, 0, 0, 0);
+
+    const yesterday = new Date(todayMidnightUtc.getTime() - 1000);
+    const todayEarly = new Date(todayMidnightUtc.getTime() + 1000);
+    const todayLate = new Date(todayMidnightUtc.getTime() + 3600_000);
+
+    // 1 run yesterday (should not count)
+    await runService.create(cronId, agentId, {
+      startedAt: yesterday,
+      skipped: false,
+    });
+    // 2 runs today
+    await runService.create(cronId, agentId, {
+      startedAt: todayEarly,
+      skipped: false,
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: todayLate,
+      skipped: false,
+    });
+
+    const jobs = await cronJobService.listWithRunSummary(agentId);
+    expect(jobs[0].runCountToday).toBe(2);
+  });
+
+  // ─── listForAgent ───────────────────────────────────────────────────────────
+
+  it("listForAgent() returns runs from multiple crons under one agent, sorted descending by startedAt", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId1 = await createCron(cronJobService, agentId);
+    const cronId2 = await createCron(cronJobService, agentId);
+
+    const t1 = new Date("2026-01-01T08:00:00Z");
+    const t2 = new Date("2026-01-02T08:00:00Z");
+    const t3 = new Date("2026-01-03T08:00:00Z");
+
+    await runService.create(cronId1, agentId, {
+      startedAt: t1,
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId, {
+      startedAt: t2,
+      skipped: false,
+    });
+    await runService.create(cronId1, agentId, {
+      startedAt: t3,
+      skipped: false,
+    });
+
+    const { items, total, limit, offset } =
+      await runService.listForAgent(agentId);
+
+    expect(total).toBe(3);
+    expect(items).toHaveLength(3);
+    expect(limit).toBe(20);
+    expect(offset).toBe(0);
+    // Descending: t3, t2, t1
+    expect(items[0].startedAt).toEqual(t3);
+    expect(items[1].startedAt).toEqual(t2);
+    expect(items[2].startedAt).toEqual(t1);
+    // Cron relation is included with id/name/schedule
+    expect(items[0].cron.id).toBe(cronId1);
+    expect(items[0].cron.schedule).toBe("0 9 * * *");
+    expect(items[1].cron.id).toBe(cronId2);
+  });
+
+  it("listForAgent() opts.cronId narrows to a single cron, still scoped to agentId", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId1 = await createCron(cronJobService, agentId);
+    const cronId2 = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId1, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listForAgent(agentId, {
+      cronId: cronId1,
+    });
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].cronId).toBe(cronId1);
+  });
+
+  it("listForAgent() opts.cronId belonging to a different agent yields an empty result, not an error", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date(),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listForAgent(agentId2, {
+      cronId: cronId1,
+    });
+
+    expect(total).toBe(0);
+    expect(items).toHaveLength(0);
+  });
+
+  it("listForAgent() filters by a normal outcome value (skipped = false, outcome = value)", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      outcome: "success",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+      outcome: "error",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: true,
+      skipReason: "pre-check returned false",
+    });
+
+    const { items, total } = await runService.listForAgent(agentId, {
+      outcome: "success",
+    });
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].outcome).toBe("success");
+    expect(items[0].skipped).toBe(false);
+  });
+
+  it("listForAgent() opts.outcome === 'skipped' matches skipped rows regardless of their outcome column", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: true,
+      skipReason: "pre-check returned false",
+      outcome: null,
+    });
+    // A skipped run that (unusually) still carries a non-null outcome column
+    // must still match — "skipped" is driven purely by the boolean flag.
+    const skippedWithOutcome = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: true,
+      outcome: "success",
+    });
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+      outcome: "success",
+    });
+
+    const { items, total } = await runService.listForAgent(agentId, {
+      outcome: "skipped",
+    });
+
+    expect(total).toBe(2);
+    expect(items).toHaveLength(2);
+    expect(items.every((r) => r.skipped)).toBe(true);
+    expect(items.some((r) => r.id === skippedWithOutcome.id)).toBe(true);
+  });
+
+  it("listForAgent() never returns a second agent's runs", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId2, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listForAgent(agentId1);
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].agentId).toBe(agentId1);
+  });
+
+  it("listForAgent() supports custom limit and offset", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    for (let i = 0; i < 5; i++) {
+      await runService.create(cronId, agentId, {
+        startedAt: new Date(Date.now() + i * 1000),
+        skipped: false,
+      });
+    }
+
+    const { items, total } = await runService.listForAgent(agentId, {
+      limit: 2,
+      offset: 1,
+    });
+    expect(items).toHaveLength(2);
+    expect(total).toBe(5);
+  });
+
+  it("listForAgent() returns modelBreakdown rows alongside the cron relation", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+
+    const run = await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      outcome: "success",
+      modelBreakdown: [
+        {
+          model: "claude-sonnet-4-5",
+          inputTokens: 200,
+          outputTokens: 100,
+          cacheReadTokens: 8,
+          cacheCreationTokens: 4,
+          costUsd: 0.002,
+        },
+      ],
+    });
+
+    const { items } = await runService.listForAgent(agentId);
+
+    expect(items).toHaveLength(1);
+    expect(items[0].modelBreakdown).toHaveLength(1);
+    expect(items[0].modelBreakdown[0].model).toBe("claude-sonnet-4-5");
+    expect(items[0].cron.id).toBe(cronId);
+  });
+
+  it("listForAgent() returns an empty result when the agent has no runs", async () => {
+    const agentId = await createAgent(prisma);
+    await createCron(cronJobService, agentId);
+
+    const { items, total } = await runService.listForAgent(agentId);
+
+    expect(total).toBe(0);
+    expect(items).toHaveLength(0);
+  });
+
+  // ─── listAcrossAgents ───────────────────────────────────────────────────────
+
+  it("listAcrossAgents() returns runs across 3+ distinct agents, sorted descending by startedAt", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const agentId3 = await createAgent(prisma, "Agent 3");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+    const cronId3 = await createCron(cronJobService, agentId3);
+
+    const t1 = new Date("2026-01-01T08:00:00Z");
+    const t2 = new Date("2026-01-02T08:00:00Z");
+    const t3 = new Date("2026-01-03T08:00:00Z");
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: t1,
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId2, {
+      startedAt: t2,
+      skipped: false,
+    });
+    await runService.create(cronId3, agentId3, {
+      startedAt: t3,
+      skipped: false,
+    });
+
+    const { items, total, limit, offset } = await runService.listAcrossAgents([
+      agentId1,
+      agentId2,
+      agentId3,
+    ]);
+
+    expect(total).toBe(3);
+    expect(items).toHaveLength(3);
+    expect(limit).toBe(20);
+    expect(offset).toBe(0);
+    // Descending: t3, t2, t1
+    expect(items[0].startedAt).toEqual(t3);
+    expect(items[1].startedAt).toEqual(t2);
+    expect(items[2].startedAt).toEqual(t1);
+    // Cron relation is included with id/name/schedule, same shape as listForAgent
+    expect(items[0].cron.id).toBe(cronId3);
+    expect(items[0].cron.schedule).toBe("0 9 * * *");
+    expect(items[1].cron.id).toBe(cronId2);
+  });
+
+  it("listAcrossAgents() excludes an agent not present in the given agentIds list", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const agentId3 = await createAgent(prisma, "Agent 3 (excluded)");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+    const cronId3 = await createCron(cronJobService, agentId3);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId2, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+    });
+    await runService.create(cronId3, agentId3, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listAcrossAgents([
+      agentId1,
+      agentId2,
+    ]);
+
+    expect(total).toBe(2);
+    expect(items).toHaveLength(2);
+    expect(
+      items.every((r) => r.agentId === agentId1 || r.agentId === agentId2),
+    ).toBe(true);
+    expect(items.some((r) => r.agentId === agentId3)).toBe(false);
+  });
+
+  it("listAcrossAgents() returns an empty result for an empty agentIds list", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    await runService.create(cronId, agentId, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listAcrossAgents([]);
+
+    expect(total).toBe(0);
+    expect(items).toHaveLength(0);
+  });
+
+  it("listAcrossAgents() returns an empty result when no runs match any given agentId", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2 (no runs)");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listAcrossAgents([agentId2]);
+
+    expect(total).toBe(0);
+    expect(items).toHaveLength(0);
+  });
+
+  it("listAcrossAgents() opts.cronId narrows to a single cron across the given agents", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+    });
+    await runService.create(cronId2, agentId2, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+    });
+
+    const { items, total } = await runService.listAcrossAgents(
+      [agentId1, agentId2],
+      { cronId: cronId1 },
+    );
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].cronId).toBe(cronId1);
+  });
+
+  it("listAcrossAgents() filters by a normal outcome value (skipped = false, outcome = value)", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: false,
+      outcome: "success",
+    });
+    await runService.create(cronId2, agentId2, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: false,
+      outcome: "error",
+    });
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: true,
+      skipReason: "pre-check returned false",
+    });
+
+    const { items, total } = await runService.listAcrossAgents(
+      [agentId1, agentId2],
+      { outcome: "success" },
+    );
+
+    expect(total).toBe(1);
+    expect(items).toHaveLength(1);
+    expect(items[0].outcome).toBe("success");
+    expect(items[0].skipped).toBe(false);
+  });
+
+  it("listAcrossAgents() opts.outcome === 'skipped' matches skipped rows regardless of their outcome column", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-01T08:00:00Z"),
+      skipped: true,
+      skipReason: "pre-check returned false",
+      outcome: null,
+    });
+    const skippedWithOutcome = await runService.create(cronId2, agentId2, {
+      startedAt: new Date("2026-01-02T08:00:00Z"),
+      skipped: true,
+      outcome: "success",
+    });
+    await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-03T08:00:00Z"),
+      skipped: false,
+      outcome: "success",
+    });
+
+    const { items, total } = await runService.listAcrossAgents(
+      [agentId1, agentId2],
+      { outcome: "skipped" },
+    );
+
+    expect(total).toBe(2);
+    expect(items).toHaveLength(2);
+    expect(items.every((r) => r.skipped)).toBe(true);
+    expect(items.some((r) => r.id === skippedWithOutcome.id)).toBe(true);
+  });
+
+  it("listAcrossAgents() supports custom limit and offset", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const agentId3 = await createAgent(prisma, "Agent 3");
+    const cronId1 = await createCron(cronJobService, agentId1);
+    const cronId2 = await createCron(cronJobService, agentId2);
+    const cronId3 = await createCron(cronJobService, agentId3);
+
+    const crons = [cronId1, cronId2, cronId3];
+    const agents = [agentId1, agentId2, agentId3];
+    for (let i = 0; i < 5; i++) {
+      await runService.create(crons[i % 3], agents[i % 3], {
+        startedAt: new Date(Date.now() + i * 1000),
+        skipped: false,
+      });
+    }
+
+    const { items, total } = await runService.listAcrossAgents(agents, {
+      limit: 2,
+      offset: 1,
+    });
+    expect(items).toHaveLength(2);
+    expect(total).toBe(5);
+  });
+
+  it("listAcrossAgents() returns modelBreakdown rows alongside the cron relation", async () => {
+    const agentId1 = await createAgent(prisma, "Agent 1");
+    const agentId2 = await createAgent(prisma, "Agent 2");
+    const cronId1 = await createCron(cronJobService, agentId1);
+
+    const run = await runService.create(cronId1, agentId1, {
+      startedAt: new Date("2026-01-15T10:00:00Z"),
+      skipped: false,
+    });
+
+    await runService.patch(run.id, agentId1, cronId1, {
+      outcome: "success",
+      modelBreakdown: [
+        {
+          model: "claude-sonnet-4-5",
+          inputTokens: 200,
+          outputTokens: 100,
+          cacheReadTokens: 8,
+          cacheCreationTokens: 4,
+          costUsd: 0.002,
+        },
+      ],
+    });
+
+    const { items } = await runService.listAcrossAgents([agentId1, agentId2]);
+
+    expect(items).toHaveLength(1);
+    expect(items[0].modelBreakdown).toHaveLength(1);
+    expect(items[0].modelBreakdown[0].model).toBe("claude-sonnet-4-5");
+    expect(items[0].cron.id).toBe(cronId1);
+  });
+});
+
+// ─── run telemetry: baseline columns + skill-usage upserts (prompt-audit) ───
+
+describeOrSkip("AgentCronRunService — run telemetry (integration)", () => {
+  let prisma: PrismaClient;
+  let cronJobService: AgentCronJobService;
+  let runService: AgentCronRunService;
+
+  beforeEach(async () => {
+    prisma = makePrisma();
+    await prisma.agentCronRunSkillUsage.deleteMany();
+    await prisma.agentCronRunModelBreakdown.deleteMany();
+    await prisma.agentCronRun.deleteMany();
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+    cronJobService = new AgentCronJobService(prisma, FixedClock(FIXED_NOW));
+    runService = new AgentCronRunService(prisma);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it("patch() spreads contextBaseline onto the baseline* columns and stores counts, fingerprint, and versions", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const run = await runService.create(cronId, agentId, {
+      startedAt: FIXED_NOW,
+    });
+
+    await runService.patch(run.id, agentId, cronId, {
+      completedAt: FIXED_NOW,
+      outcome: "completed",
+      contextBaseline: {
+        model: "claude-sonnet-4-6",
+        contextTokens: 79_188,
+        inputTokens: 2,
+        cacheCreationTokens: 41_415,
+        cacheReadTokens: 37_771,
+      },
+      turns: 12,
+      toolCalls: 7,
+      contextFingerprint: "abc123def456",
+      pluginVersion: "1.363.0",
+      claudeCodeVersion: "2.1.285",
+    });
+
+    const stored = await prisma.agentCronRun.findUniqueOrThrow({
+      where: { id: run.id },
+    });
+    expect(stored.baselineModel).toBe("claude-sonnet-4-6");
+    expect(stored.baselineContextTokens).toBe(79_188);
+    expect(stored.baselineInputTokens).toBe(2);
+    expect(stored.baselineCacheCreationTokens).toBe(41_415);
+    expect(stored.baselineCacheReadTokens).toBe(37_771);
+    expect(stored.turns).toBe(12);
+    expect(stored.toolCalls).toBe(7);
+    expect(stored.contextFingerprint).toBe("abc123def456");
+    expect(stored.pluginVersion).toBe("1.363.0");
+    expect(stored.claudeCodeVersion).toBe("2.1.285");
+  });
+
+  it("patch() without telemetry leaves every telemetry column null", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const run = await runService.create(cronId, agentId, {
+      startedAt: FIXED_NOW,
+    });
+
+    await runService.patch(run.id, agentId, cronId, { outcome: "completed" });
+
+    const stored = await prisma.agentCronRun.findUniqueOrThrow({
+      where: { id: run.id },
+    });
+    expect(stored.baselineModel).toBeNull();
+    expect(stored.baselineContextTokens).toBeNull();
+    expect(stored.turns).toBeNull();
+    expect(stored.contextFingerprint).toBeNull();
+  });
+
+  it("patch() upserts skillUsage rows per [cronRunId, kind, name], alongside modelBreakdown, in one call", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const run = await runService.create(cronId, agentId, {
+      startedAt: FIXED_NOW,
+    });
+
+    const row = {
+      kind: "skill",
+      name: "shipwright:task-store",
+      invocations: 1,
+      turns: 3,
+      inputTokens: 12,
+      outputTokens: 100,
+      cacheReadTokens: 219_200,
+      cacheCreationTokens: 9_300,
+      invokeContextDelta: 103,
+    };
+    await runService.patch(run.id, agentId, cronId, {
+      modelBreakdown: [
+        {
+          model: "claude-sonnet-4-6",
+          inputTokens: 514,
+          outputTokens: 150,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          costUsd: 0.42,
+        },
+      ],
+      skillUsage: [
+        row,
+        {
+          kind: "root",
+          name: "root",
+          invocations: 0,
+          turns: 1,
+          inputTokens: 2,
+          outputTokens: 10,
+          cacheReadTokens: 30_000,
+          cacheCreationTokens: 40_000,
+          invokeContextDelta: null,
+        },
+      ],
+    });
+
+    // Second PATCH with updated numbers for the same key — must update, not duplicate.
+    await runService.patch(run.id, agentId, cronId, {
+      skillUsage: [{ ...row, turns: 4, inputTokens: 20 }],
+    });
+
+    const rows = await prisma.agentCronRunSkillUsage.findMany({
+      where: { cronRunId: run.id },
+      orderBy: { kind: "asc" },
+    });
+    expect(rows).toHaveLength(2);
+    const skill = rows.find((r) => r.kind === "skill");
+    expect(skill).toMatchObject({
+      name: "shipwright:task-store",
+      invocations: 1,
+      turns: 4,
+      inputTokens: 20,
+      invokeContextDelta: 103,
+    });
+    const root = rows.find((r) => r.kind === "root");
+    expect(root).toMatchObject({
+      name: "root",
+      turns: 1,
+      invokeContextDelta: null,
+    });
+
+    const breakdown = await prisma.agentCronRunModelBreakdown.findMany({
+      where: { cronRunId: run.id },
+    });
+    expect(breakdown).toHaveLength(1);
+  });
+
+  it("skillUsage rows cascade-delete with their run", async () => {
+    const agentId = await createAgent(prisma);
+    const cronId = await createCron(cronJobService, agentId);
+    const run = await runService.create(cronId, agentId, {
+      startedAt: FIXED_NOW,
+    });
+    await runService.patch(run.id, agentId, cronId, {
+      skillUsage: [
+        {
+          kind: "agent",
+          name: "Explore",
+          invocations: 1,
+          turns: 1,
+          inputTokens: 500,
+          outputTokens: 40,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          invokeContextDelta: null,
+        },
+      ],
+    });
+
+    await prisma.agentCronRun.delete({ where: { id: run.id } });
+    expect(
+      await prisma.agentCronRunSkillUsage.count({
+        where: { cronRunId: run.id },
+      }),
+    ).toBe(0);
+  });
+});