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

package/cron-run-reporter.integration.test.ts

@@ -0,0 +1,806 @@
+/**
+ * Integration tests for HttpCronRunReporter (new two-step interface).
+ *
+ * Strategy: spin up a real Bun.serve stub admin API, inject its URL, and verify
+ * the reporter POSTs / PATCHes the correct payloads — no global.fetch overrides,
+ * no mock.module().
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  HttpCronRunReporter,
+  NoopCronRunReporter,
+} from "./cron-run-reporter.ts";
+
+// ─── Shared helpers ───────────────────────────────────────────────────────────
+
+interface CapturedRequest {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: unknown;
+}
+
+interface StubState {
+  captured: CapturedRequest[];
+  postStatusToReturn: number;
+  patchStatusToReturn: number;
+}
+
+function startStubServer(
+  port: number,
+  state: StubState,
+  // biome-ignore lint/suspicious/noExplicitAny: Server type param varies by bun version
+): ReturnType<typeof Bun.serve<any>> {
+  return Bun.serve({
+    port,
+    fetch: async (req) => {
+      const body = await req.json().catch(() => null);
+      state.captured.push({
+        url: req.url,
+        method: req.method,
+        headers: Object.fromEntries(req.headers.entries()),
+        body,
+      });
+
+      if (req.method === "POST") {
+        if (state.postStatusToReturn >= 400) {
+          return new Response(JSON.stringify({ error: "stub error" }), {
+            status: state.postStatusToReturn,
+            headers: { "Content-Type": "application/json" },
+          });
+        }
+        return new Response(JSON.stringify({ run: { id: "run-stub-1" } }), {
+          status: 201,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      // PATCH
+      if (state.patchStatusToReturn >= 400) {
+        return new Response(JSON.stringify({ error: "stub error" }), {
+          status: state.patchStatusToReturn,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      return new Response(JSON.stringify({ run: { id: "run-stub-1" } }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    },
+  });
+}
+
+// ─── HttpCronRunReporter ──────────────────────────────────────────────────────
+
+describe("HttpCronRunReporter", () => {
+  // biome-ignore lint/suspicious/noExplicitAny: Server type param varies by bun version
+  let server: ReturnType<typeof Bun.serve<any>>;
+  let state: StubState;
+  let baseUrl: string;
+  const AGENT_ID = "agent-abc";
+  const API_KEY = "test-api-key";
+
+  beforeEach(() => {
+    state = {
+      captured: [],
+      postStatusToReturn: 201,
+      patchStatusToReturn: 200,
+    };
+    server = startStubServer(0, state);
+    baseUrl = `http://localhost:${server.port}`;
+  });
+
+  afterEach(async () => {
+    await server.stop(true);
+  });
+
+  function makeReporter() {
+    return new HttpCronRunReporter({
+      apiUrl: baseUrl,
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+  }
+
+  // ─── createRun ─────────────────────────────────────────────────────────────
+
+  test("createRun POSTs to correct URL: /agents/:agentId/crons/:cronId/runs", async () => {
+    const reporter = makeReporter();
+    const startedAt = new Date("2026-01-01T08:00:00.000Z");
+
+    await reporter.createRun("cron-123", startedAt);
+
+    expect(state.captured).toHaveLength(1);
+    expect(state.captured[0].method).toBe("POST");
+    expect(state.captured[0].url).toContain(
+      `/agents/${AGENT_ID}/crons/cron-123/runs`,
+    );
+  });
+
+  test("createRun sends only startedAt in body", async () => {
+    const reporter = makeReporter();
+    const startedAt = new Date("2026-01-01T08:00:00.000Z");
+
+    await reporter.createRun("cron-123", startedAt);
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.startedAt).toBe(startedAt.toISOString());
+    expect(Object.keys(body)).toEqual(["startedAt"]);
+  });
+
+  test("createRun returns run.id from response", async () => {
+    const reporter = makeReporter();
+    const runId = await reporter.createRun(
+      "cron-123",
+      new Date("2026-01-01T08:00:00.000Z"),
+    );
+
+    expect(runId).toBe("run-stub-1");
+  });
+
+  test("createRun sends Authorization header with api key", async () => {
+    const reporter = makeReporter();
+    await reporter.createRun("cron-auth", new Date());
+
+    expect(state.captured[0].headers.authorization).toBe(`Bearer ${API_KEY}`);
+  });
+
+  test("createRun returns null on network error (does not throw)", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: "http://localhost:19999", // nothing listening
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+
+    const result = await reporter.createRun("cron-net-err", new Date());
+    expect(result).toBeNull();
+  });
+
+  test("createRun returns null on HTTP error (does not throw)", async () => {
+    state.postStatusToReturn = 500;
+    const reporter = makeReporter();
+
+    const result = await reporter.createRun("cron-http-err", new Date());
+    expect(result).toBeNull();
+  });
+
+  // ─── completeRun ───────────────────────────────────────────────────────────
+
+  test("completeRun PATCHes to correct URL: /agents/:agentId/crons/:cronId/runs/:runId", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun("cron-123", "run-abc", completedAt, "completed");
+
+    expect(state.captured).toHaveLength(1);
+    expect(state.captured[0].method).toBe("PATCH");
+    expect(state.captured[0].url).toContain(
+      `/agents/${AGENT_ID}/crons/cron-123/runs/run-abc`,
+    );
+  });
+
+  test("completeRun sends completedAt + outcome in body", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun("cron-123", "run-abc", completedAt, "completed");
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.completedAt).toBe(completedAt.toISOString());
+    expect(body.outcome).toBe("completed");
+  });
+
+  test("completeRun sends token data when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "completed",
+      {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadTokens: 20,
+        cacheCreationTokens: 10,
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.inputTokens).toBe(100);
+    expect(body.outputTokens).toBe(50);
+    expect(body.cacheReadTokens).toBe(20);
+    expect(body.cacheCreationTokens).toBe(10);
+  });
+
+  test("completeRun sends error when provided (failed outcome)", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun("cron-123", "run-abc", completedAt, "failed", {
+      error: "something went wrong",
+    });
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.outcome).toBe("failed");
+    expect(body.error).toBe("something went wrong");
+  });
+
+  test("completeRun does nothing when runId is null", async () => {
+    const reporter = makeReporter();
+    await reporter.completeRun("cron-123", null, new Date(), "completed");
+
+    expect(state.captured).toHaveLength(0);
+  });
+
+  test("completeRun swallows network errors (does not throw)", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: "http://localhost:19999", // nothing listening
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+
+    await expect(
+      reporter.completeRun("cron-net-err", "run-1", new Date(), "completed"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("completeRun swallows HTTP error responses (does not throw)", async () => {
+    state.patchStatusToReturn = 500;
+    const reporter = makeReporter();
+
+    await expect(
+      reporter.completeRun("cron-http-err", "run-1", new Date(), "completed"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("completeRun sends modelBreakdown when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "completed",
+      {
+        inputTokens: 300,
+        outputTokens: 150,
+        modelBreakdown: [
+          {
+            model: "claude-sonnet-4-5",
+            inputTokens: 200,
+            outputTokens: 100,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            costUsd: 0.002,
+          },
+          {
+            model: "claude-haiku-4-5",
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            costUsd: 0.001,
+          },
+        ],
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(Array.isArray(body.modelBreakdown)).toBe(true);
+    const breakdown = body.modelBreakdown as Array<Record<string, unknown>>;
+    expect(breakdown).toHaveLength(2);
+    expect(breakdown[0].model).toBe("claude-sonnet-4-5");
+    expect(breakdown[0].inputTokens).toBe(200);
+    expect(breakdown[1].model).toBe("claude-haiku-4-5");
+    expect(breakdown[1].inputTokens).toBe(100);
+  });
+
+  test("completeRun sends sessionId when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "completed",
+      { sessionId: "session-abc-123" },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.sessionId).toBe("session-abc-123");
+  });
+
+  test("completeRun omits sessionId when not provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.completeRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "completed",
+      {
+        inputTokens: 100,
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.sessionId).toBeUndefined();
+  });
+
+  // ─── recordProgress ────────────────────────────────────────────────────────
+
+  test("recordProgress PATCHes to correct URL with modelBreakdown and lastHeartbeatAt in body", async () => {
+    const reporter = makeReporter();
+    const modelBreakdown = [
+      {
+        model: "claude-sonnet-4-5",
+        inputTokens: 200,
+        outputTokens: 100,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0.002,
+      },
+    ];
+    const lastHeartbeatAt = new Date("2026-01-01T08:00:03.000Z");
+
+    await reporter.recordProgress(
+      "cron-123",
+      "run-abc",
+      modelBreakdown,
+      lastHeartbeatAt,
+    );
+
+    expect(state.captured).toHaveLength(1);
+    expect(state.captured[0].method).toBe("PATCH");
+    expect(state.captured[0].url).toContain(
+      `/agents/${AGENT_ID}/crons/cron-123/runs/run-abc`,
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(new Set(Object.keys(body))).toEqual(
+      new Set(["modelBreakdown", "lastHeartbeatAt"]),
+    );
+    expect(body.completedAt).toBeUndefined();
+    expect(body.outcome).toBeUndefined();
+    expect(body.lastHeartbeatAt).toBe(lastHeartbeatAt.toISOString());
+    const breakdown = body.modelBreakdown as Array<Record<string, unknown>>;
+    expect(breakdown).toHaveLength(1);
+    expect(breakdown[0].model).toBe("claude-sonnet-4-5");
+    expect(breakdown[0].inputTokens).toBe(200);
+  });
+
+  test("recordProgress does nothing when runId is null", async () => {
+    const reporter = makeReporter();
+    await reporter.recordProgress("cron-123", null, [], new Date());
+
+    expect(state.captured).toHaveLength(0);
+  });
+
+  test("recordProgress swallows network errors (does not throw)", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: "http://localhost:19999", // nothing listening
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+
+    await expect(
+      reporter.recordProgress("cron-net-err", "run-1", [], new Date()),
+    ).resolves.toBeUndefined();
+  });
+
+  test("recordProgress swallows HTTP error responses (does not throw)", async () => {
+    state.patchStatusToReturn = 500;
+    const reporter = makeReporter();
+
+    await expect(
+      reporter.recordProgress("cron-http-err", "run-1", [], new Date()),
+    ).resolves.toBeUndefined();
+  });
+
+  // ─── recordSessionId (DTW-1.3) ─────────────────────────────────────────────
+
+  test("recordSessionId PATCHes to correct URL with only sessionId in body", async () => {
+    const reporter = makeReporter();
+
+    await reporter.recordSessionId("cron-123", "run-abc", "sess-early-1");
+
+    expect(state.captured).toHaveLength(1);
+    expect(state.captured[0].method).toBe("PATCH");
+    expect(state.captured[0].url).toContain(
+      `/agents/${AGENT_ID}/crons/cron-123/runs/run-abc`,
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(Object.keys(body)).toEqual(["sessionId"]);
+    expect(body.sessionId).toBe("sess-early-1");
+    expect(body.completedAt).toBeUndefined();
+    expect(body.outcome).toBeUndefined();
+  });
+
+  test("recordSessionId does nothing when runId is null", async () => {
+    const reporter = makeReporter();
+    await reporter.recordSessionId("cron-123", null, "sess-early-1");
+
+    expect(state.captured).toHaveLength(0);
+  });
+
+  test("recordSessionId swallows network errors (does not throw)", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: "http://localhost:19999", // nothing listening
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+
+    await expect(
+      reporter.recordSessionId("cron-net-err", "run-1", "sess-early-1"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("recordSessionId swallows HTTP error responses (does not throw)", async () => {
+    state.patchStatusToReturn = 500;
+    const reporter = makeReporter();
+
+    await expect(
+      reporter.recordSessionId("cron-http-err", "run-1", "sess-early-1"),
+    ).resolves.toBeUndefined();
+  });
+
+  // ─── skipRun ───────────────────────────────────────────────────────────────
+
+  test("skipRun PATCHes to correct URL with skipped:true and skipReason", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "preCheck:not-found",
+    );
+
+    expect(state.captured).toHaveLength(1);
+    expect(state.captured[0].method).toBe("PATCH");
+    expect(state.captured[0].url).toContain(
+      `/agents/${AGENT_ID}/crons/cron-123/runs/run-abc`,
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.skipped).toBe(true);
+    expect(body.skipReason).toBe("preCheck:not-found");
+    expect(body.completedAt).toBe(completedAt.toISOString());
+  });
+
+  test("skipRun sends error when provided", async () => {
+    const reporter = makeReporter();
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      new Date(),
+      "preCheck:crash",
+      { error: "stderr output" },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.error).toBe("stderr output");
+  });
+
+  test("skipRun does nothing when runId is null", async () => {
+    const reporter = makeReporter();
+    await reporter.skipRun("cron-123", null, new Date(), "preCheck:not-found");
+
+    expect(state.captured).toHaveLength(0);
+  });
+
+  test("skipRun swallows network errors (does not throw)", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: "http://localhost:19999",
+      agentId: AGENT_ID,
+      apiKey: API_KEY,
+    });
+
+    await expect(
+      reporter.skipRun("cron-net-err", "run-1", new Date(), "preCheck:crash"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("skipRun swallows HTTP error responses (does not throw)", async () => {
+    state.patchStatusToReturn = 500;
+    const reporter = makeReporter();
+
+    await expect(
+      reporter.skipRun("cron-http-err", "run-1", new Date(), "preCheck:crash"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("skipRun sends token data when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "command:no-work",
+      {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadTokens: 20,
+        cacheCreationTokens: 10,
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.skipped).toBe(true);
+    expect(body.skipReason).toBe("command:no-work");
+    expect(body.inputTokens).toBe(100);
+    expect(body.outputTokens).toBe(50);
+    expect(body.cacheReadTokens).toBe(20);
+    expect(body.cacheCreationTokens).toBe(10);
+  });
+
+  test("skipRun sends modelBreakdown when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "command:no-work",
+      {
+        inputTokens: 300,
+        outputTokens: 150,
+        modelBreakdown: [
+          {
+            model: "claude-sonnet-4-5",
+            inputTokens: 200,
+            outputTokens: 100,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            costUsd: 0.002,
+          },
+          {
+            model: "claude-haiku-4-5",
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            costUsd: 0.001,
+          },
+        ],
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(Array.isArray(body.modelBreakdown)).toBe(true);
+    const breakdown = body.modelBreakdown as Array<Record<string, unknown>>;
+    expect(breakdown).toHaveLength(2);
+    expect(breakdown[0].model).toBe("claude-sonnet-4-5");
+    expect(breakdown[0].inputTokens).toBe(200);
+    expect(breakdown[1].model).toBe("claude-haiku-4-5");
+    expect(breakdown[1].inputTokens).toBe(100);
+  });
+
+  test("skipRun sends both error and token data together when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "command:no-work",
+      { error: "partial run before skip", inputTokens: 42 },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.error).toBe("partial run before skip");
+    expect(body.inputTokens).toBe(42);
+  });
+
+  test("skipRun sends sessionId when provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "command:no-work",
+      { sessionId: "session-xyz-789" },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.sessionId).toBe("session-xyz-789");
+  });
+
+  test("skipRun omits sessionId when not provided", async () => {
+    const reporter = makeReporter();
+    const completedAt = new Date("2026-01-01T08:00:05.000Z");
+
+    await reporter.skipRun(
+      "cron-123",
+      "run-abc",
+      completedAt,
+      "command:no-work",
+      { inputTokens: 50 },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.sessionId).toBeUndefined();
+  });
+});
+
+// ─── NoopCronRunReporter ──────────────────────────────────────────────────────
+
+describe("NoopCronRunReporter", () => {
+  test("createRun returns null and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    const result = await reporter.createRun("any", new Date());
+    expect(result).toBeNull();
+  });
+
+  test("completeRun resolves immediately and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    await expect(
+      reporter.completeRun("any", null, new Date(), "completed"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("skipRun resolves immediately and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    await expect(
+      reporter.skipRun("any", null, new Date(), "preCheck:not-found"),
+    ).resolves.toBeUndefined();
+  });
+
+  test("skipRun accepts token fields in opts and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    await expect(
+      reporter.skipRun("any", null, new Date(), "command:no-work", {
+        inputTokens: 10,
+        outputTokens: 5,
+        cacheReadTokens: 1,
+        cacheCreationTokens: 1,
+        modelBreakdown: [
+          {
+            model: "claude-sonnet-4-5",
+            inputTokens: 10,
+            outputTokens: 5,
+            cacheReadTokens: 1,
+            cacheCreationTokens: 1,
+            costUsd: 0.001,
+          },
+        ],
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("recordProgress resolves immediately and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    await expect(
+      reporter.recordProgress("any", null, [], new Date()),
+    ).resolves.toBeUndefined();
+  });
+
+  test("recordSessionId resolves immediately and does not throw", async () => {
+    const reporter = new NoopCronRunReporter();
+    await expect(
+      reporter.recordSessionId("any", null, "sess-1"),
+    ).resolves.toBeUndefined();
+  });
+});
+
+// ─── run telemetry + context stamp fields (prompt-audit metrics) ─────────────
+
+describe("HttpCronRunReporter — telemetry and context-stamp fields", () => {
+  // biome-ignore lint/suspicious/noExplicitAny: Server type param varies by bun version
+  let server: ReturnType<typeof Bun.serve<any>>;
+  let state: StubState;
+  let baseUrl: string;
+
+  beforeEach(() => {
+    state = { captured: [], postStatusToReturn: 201, patchStatusToReturn: 200 };
+    server = startStubServer(0, state);
+    baseUrl = `http://localhost:${server.port}`;
+  });
+
+  afterEach(async () => {
+    await server.stop(true);
+  });
+
+  test("completeRun forwards contextBaseline, turns, toolCalls, skillUsage, and stamp fields verbatim", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: baseUrl,
+      agentId: "agent-abc",
+      apiKey: "k",
+    });
+
+    await reporter.completeRun(
+      "cron-1",
+      "run-1",
+      new Date("2026-01-01T08:00:05.000Z"),
+      "completed",
+      {
+        contextBaseline: {
+          model: "claude-sonnet-4-6",
+          contextTokens: 79_188,
+          inputTokens: 2,
+          cacheCreationTokens: 41_415,
+          cacheReadTokens: 37_771,
+        },
+        turns: 12,
+        toolCalls: 7,
+        skillUsage: [
+          {
+            kind: "skill",
+            name: "shipwright:task-store",
+            invocations: 1,
+            turns: 3,
+            inputTokens: 12,
+            outputTokens: 100,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 9_300,
+            invokeContextDelta: 103,
+          },
+        ],
+        contextFingerprint: "abc123def456",
+        pluginVersion: "1.363.0",
+        claudeCodeVersion: "2.1.285",
+      },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    expect(body.contextBaseline).toEqual({
+      model: "claude-sonnet-4-6",
+      contextTokens: 79_188,
+      inputTokens: 2,
+      cacheCreationTokens: 41_415,
+      cacheReadTokens: 37_771,
+    });
+    expect(body.turns).toBe(12);
+    expect(body.toolCalls).toBe(7);
+    expect(body.skillUsage).toEqual([
+      expect.objectContaining({ name: "shipwright:task-store", turns: 3 }),
+    ]);
+    expect(body.contextFingerprint).toBe("abc123def456");
+    expect(body.pluginVersion).toBe("1.363.0");
+    expect(body.claudeCodeVersion).toBe("2.1.285");
+  });
+
+  test("skipRun omits every telemetry/stamp field when none is provided", async () => {
+    const reporter = new HttpCronRunReporter({
+      apiUrl: baseUrl,
+      agentId: "agent-abc",
+      apiKey: "k",
+    });
+
+    await reporter.skipRun(
+      "cron-1",
+      "run-1",
+      new Date("2026-01-01T08:00:05.000Z"),
+      "command:no-work",
+      { sessionId: "s" },
+    );
+
+    const body = state.captured[0].body as Record<string, unknown>;
+    for (const key of [
+      "contextBaseline",
+      "turns",
+      "toolCalls",
+      "skillUsage",
+      "contextFingerprint",
+      "pluginVersion",
+      "claudeCodeVersion",
+    ]) {
+      expect(key in body).toBe(false);
+    }
+  });
+});