@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/ui/client/__tests__/useJobList.test.ts

@@ -1,40 +1,215 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import "../../components/__tests__/test-dom";
 
-import { extractJobList, fetchJobList } from "../hooks/useJobList";
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import { act, renderHook, waitFor } from "@testing-library/react";
 
-const originalFetch = globalThis.fetch;
+import { adaptJobSummary } from "../adapters/job-adapter";
+import { fetchJobList, useJobList } from "../hooks/useJobList";
+import type { NormalizedJobSummary } from "../types";
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status });
+}
+
+function makeJob(jobId: string): NormalizedJobSummary {
+  return {
+    id: jobId,
+    jobId,
+    name: jobId,
+    status: "pending",
+    progress: 0,
+    taskCount: 0,
+    doneCount: 0,
+    location: "current",
+    tasks: {},
+    current: null,
+    costsSummary: {
+      totalTokens: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      totalInputCost: 0,
+      totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
+    },
+    totalCost: 0,
+    totalTokens: 0,
+    __warnings: [],
+    displayCategory: "current",
+  };
+}
+
+describe("fetchJobList", () => {
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, "fetch");
+  });
 
-describe("useJobList helpers", () => {
   afterEach(() => {
-    globalThis.fetch = originalFetch;
-    vi.restoreAllMocks();
+    fetchSpy.mockRestore();
   });
 
-  it("extracts wrapped responses", () => {
-    expect(extractJobList({ ok: true, data: [{ jobId: "job-1" }] })).toEqual([{ jobId: "job-1" }]);
+  it("returns adapted jobs on a valid envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({
+      ok: true,
+      data: [{ jobId: "job-1", tasks: {} }],
+    }));
+
+    const jobs = await fetchJobList();
+
+    expect(jobs).toHaveLength(1);
+    expect(jobs[0]?.jobId).toBe("job-1");
   });
 
-  it("extracts bare arrays", () => {
-    expect(extractJobList([{ jobId: "job-1" }])).toEqual([{ jobId: "job-1" }]);
+  it("propagates the abort signal to fetch", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: true, data: [] }));
+
+    const controller = new AbortController();
+    await fetchJobList(controller.signal);
+
+    const init = fetchSpy.mock.calls[0]?.[1] as RequestInit | undefined;
+    expect(init?.signal).toBe(controller.signal);
   });
 
-  it("fetches and adapts jobs", async () => {
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify([{ jobId: "job-1", tasks: {} }]), { status: 200 }),
-    ) as unknown as typeof fetch;
+  it("rejects with network_error when fetch fails", async () => {
+    fetchSpy.mockRejectedValue(new Error("offline"));
 
-    await expect(fetchJobList()).resolves.toMatchObject([{ jobId: "job-1" }]);
+    await expect(fetchJobList()).rejects.toMatchObject({
+      code: "network_error",
+      message: "offline",
+    });
   });
 
-  it("passes abort signals through to fetch", async () => {
-    const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify([]), { status: 200 }),
-    );
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-    const controller = new AbortController();
+  it("rejects with AbortError when fetch rejects with one", async () => {
+    fetchSpy.mockRejectedValue(new DOMException("Aborted", "AbortError"));
 
-    await fetchJobList(controller.signal);
+    const promise = fetchJobList();
+    await expect(promise).rejects.toBeInstanceOf(DOMException);
+    await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+  });
 
-    expect(fetchMock.mock.calls[0]?.[1]?.signal).toBe(controller.signal);
+  it("rejects with typed ApiError on a non-2xx response", async () => {
+    fetchSpy.mockResolvedValue(new Response("", { status: 500 }));
+
+    await expect(fetchJobList()).rejects.toMatchObject({
+      code: "unknown_error",
+      status: 500,
+    });
+  });
+
+  it("rejects with malformed_response on a 2xx {ok:false} envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: false }));
+
+    await expect(fetchJobList()).rejects.toMatchObject({
+      code: "malformed_response",
+      status: 200,
+    });
+  });
+
+  it("rejects with malformed_response when data is not an array", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: true, data: { not: "an array" } }));
+
+    await expect(fetchJobList()).rejects.toMatchObject({
+      code: "malformed_response",
+      status: 200,
+    });
   });
 });
+
+describe("useJobList hook (AC-7, AC-8)", () => {
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, "fetch");
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+  });
+
+  it("sets error and leaves data null on an initial 500", async () => {
+    fetchSpy.mockResolvedValue(new Response("", { status: 500 }));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error).toMatchObject({
+      code: "unknown_error",
+      status: 500,
+    });
+    expect(result.current.data).toBeNull();
+  });
+
+  it("sets error and leaves data null on an initial {ok:false} envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: false }));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error?.code).toBe("malformed_response");
+    expect(result.current.data).toBeNull();
+  });
+
+  it("populates data and clears any prior error on a valid response", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({
+      ok: true,
+      data: [{ jobId: "job-1", tasks: {} }],
+    }));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.data).not.toBeNull());
+    expect(result.current.data?.[0]?.jobId).toBe("job-1");
+    expect(result.current.error).toBeNull();
+  });
+
+  it("keeps prior data and sets error on a failed refetch", async () => {
+    const expected = adaptJobSummary({ jobId: "job-1", tasks: {} });
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: [{ jobId: "job-1", tasks: {} }] }))
+      .mockResolvedValueOnce(new Response("", { status: 500 }));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.data?.[0]?.jobId).toBe("job-1"));
+
+    act(() => {
+      result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.error?.code).toBe("unknown_error"));
+    expect(result.current.data?.[0]).toEqual(expected);
+    expect(result.current.loading).toBe(false);
+  });
+
+  it("ignores AbortError on initial load (no error, data null)", async () => {
+    fetchSpy.mockRejectedValue(new DOMException("Aborted", "AbortError"));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error).toBeNull();
+    expect(result.current.data).toBeNull();
+  });
+
+  it("ignores AbortError on refetch and preserves prior data", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: [{ jobId: "job-1", tasks: {} }] }))
+      .mockRejectedValueOnce(new DOMException("Aborted", "AbortError"));
+
+    const { result } = renderHook(() => useJobList());
+
+    await waitFor(() => expect(result.current.data?.[0]?.jobId).toBe("job-1"));
+
+    act(() => {
+      result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.data?.[0]?.jobId).toBe("job-1");
+    expect(result.current.error).toBeNull();
+  });
+});

package/src/ui/client/__tests__/useJobListWithUpdates.test.ts

@@ -1,8 +1,53 @@
-import { describe, expect, it } from "vitest";
+import "../../components/__tests__/test-dom";
 
-import { applyJobEvent, shouldRefetchForListEvent } from "../hooks/useJobListWithUpdates";
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import { act, renderHook, waitFor } from "@testing-library/react";
+
+import type { JobWire } from "../../../config/sse-events.ts";
+import {
+  applyJobEvent,
+  handleListSseMessage,
+  shouldRefetchForListEvent,
+  useJobListWithUpdates,
+} from "../hooks/useJobListWithUpdates";
 import type { NormalizedJobSummary } from "../types";
 
+type Listener = (event: MessageEvent<string>) => void;
+
+class MockEventSource {
+  public readonly url: string;
+  public closed = false;
+  public listeners = new Map<string, Listener>();
+
+  constructor(url: string) {
+    this.url = url;
+    MockEventSource.instances.push(this);
+  }
+
+  addEventListener(type: string, listener: Listener): void {
+    this.listeners.set(type, listener);
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+
+  emit(type: string, data: unknown): void {
+    const listener = this.listeners.get(type);
+    if (!listener) return;
+    listener(new MessageEvent(type, { data: JSON.stringify(data) }));
+  }
+
+  static instances: MockEventSource[] = [];
+  static reset(): void {
+    MockEventSource.instances = [];
+  }
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status });
+}
+
 function makeJob(jobId: string, fields: Partial<NormalizedJobSummary> = {}): NormalizedJobSummary {
   return {
     id: jobId,
@@ -22,6 +67,9 @@ function makeJob(jobId: string, fields: Partial<NormalizedJobSummary> = {}): Nor
       totalCost: 0,
       totalInputCost: 0,
       totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
     },
     totalCost: 0,
     totalTokens: 0,
@@ -31,37 +79,200 @@ function makeJob(jobId: string, fields: Partial<NormalizedJobSummary> = {}): Nor
   };
 }
 
+function makeJobWire(fields: Partial<JobWire> & { jobId: string }): JobWire {
+  return {
+    jobId: fields.jobId,
+    title: fields.title ?? `Title for ${fields.jobId}`,
+    status: fields.status ?? "pending",
+    progress: fields.progress ?? 0,
+    createdAt: fields.createdAt ?? null,
+    updatedAt: fields.updatedAt ?? null,
+    location: fields.location ?? null,
+    tasks: fields.tasks ?? {},
+    costsSummary: fields.costsSummary ?? {
+      totalTokens: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      totalInputCost: 0,
+      totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
+    },
+  };
+}
+
 describe("useJobListWithUpdates helpers", () => {
   it("adds jobs on job:created", () => {
-    const next = applyJobEvent([], { type: "job:created", data: { jobId: "job-1", tasks: {} } });
+    const next = applyJobEvent([], {
+      type: "job:created",
+      data: makeJobWire({ jobId: "job-1" }),
+    });
     expect(next).toHaveLength(1);
     expect(next[0]?.jobId).toBe("job-1");
   });
 
   it("removes jobs on job:removed", () => {
-    const next = applyJobEvent([makeJob("job-1")], { type: "job:removed", data: { jobId: "job-1", tasks: {} } });
+    const next = applyJobEvent(
+      [makeJob("job-1")],
+      { type: "job:removed", data: { jobId: "job-1" } },
+    );
     expect(next).toEqual([]);
   });
 
   it("merges jobs on job:updated", () => {
     const next = applyJobEvent([makeJob("job-1", { name: "old" })], {
       type: "job:updated",
-      data: { jobId: "job-1", name: "new", tasks: {} },
+      data: makeJobWire({ jobId: "job-1", title: "new" }),
     });
     expect(next[0]?.name).toBe("new");
   });
 
   it("reuses the previous reference when nothing changes", () => {
-    const jobs = [makeJob("job-1")];
+    const jobs = [makeJob("job-1", { name: "same" })];
     const next = applyJobEvent(jobs, {
       type: "job:updated",
-      data: { jobId: "job-1", tasks: {} },
+      data: makeJobWire({ jobId: "job-1", title: "same" }),
     });
     expect(next).toBe(jobs);
   });
 
   it("flags list refetch events", () => {
     expect(shouldRefetchForListEvent("seed:uploaded")).toBe(true);
+    expect(shouldRefetchForListEvent("state:change")).toBe(true);
+    expect(shouldRefetchForListEvent("state:summary")).toBe(true);
     expect(shouldRefetchForListEvent("job:updated")).toBe(false);
+    expect(shouldRefetchForListEvent("heartbeat")).toBe(false);
+  });
+});
+
+describe("handleListSseMessage", () => {
+  let warnSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("schedules refetch and warns on malformed JSON without exposing an event", () => {
+    const result = handleListSseMessage("job:updated", "{not json");
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("failed to parse SSE payload");
+  });
+
+  it("schedules refetch and warns on a schema-invalid payload (AC-12)", () => {
+    const result = handleListSseMessage("job:updated", JSON.stringify({ jobId: "job-1" }));
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("dropping invalid SSE event");
+    expect(message).toContain("job:updated");
+  });
+
+  it("schedules refetch and warns on an unknown event type (AC-12)", () => {
+    const result = handleListSseMessage("task:updated", JSON.stringify({ taskName: "build" }));
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("dropping invalid SSE event");
+    expect(message).toContain("task:updated");
+  });
+
+  it("schedules refetch for a typed seed:uploaded event without warning", () => {
+    const result = handleListSseMessage("seed:uploaded", JSON.stringify({}));
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("schedules refetch for a typed state:summary event without warning", () => {
+    const result = handleListSseMessage(
+      "state:summary",
+      JSON.stringify({ changeCount: 3 }),
+    );
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("schedules refetch for a typed state:change event without warning", () => {
+    const result = handleListSseMessage(
+      "state:change",
+      JSON.stringify({ jobId: "job-1", path: "pipeline-data/current/job-1/tasks-status.json" }),
+    );
+
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("returns an apply action for a valid job:updated event without warning", () => {
+    const wire = makeJobWire({ jobId: "job-1", title: "My Job" });
+
+    const result = handleListSseMessage("job:updated", JSON.stringify(wire));
+
+    expect(result.kind).toBe("apply");
+    if (result.kind !== "apply") throw new Error("expected apply");
+    expect(result.event.type).toBe("job:updated");
+    expect(result.event.data).toEqual(wire);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("returns an apply action for a valid heartbeat event (non-list, non-refetch)", () => {
+    const result = handleListSseMessage(
+      "heartbeat",
+      JSON.stringify({ ok: true, timestamp: "2026-06-21T00:00:00.000Z" }),
+    );
+
+    expect(result.kind).toBe("apply");
+    if (result.kind !== "apply") throw new Error("expected apply");
+    expect(result.event.type).toBe("heartbeat");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("useJobListWithUpdates wrapper (AC-9)", () => {
+  const originalEventSource = globalThis.EventSource;
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, "fetch");
+    MockEventSource.reset();
+    globalThis.EventSource = MockEventSource as unknown as typeof EventSource;
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+    globalThis.EventSource = originalEventSource;
+    MockEventSource.reset();
+  });
+
+  it("keeps the rendered list intact when an SSE-triggered refetch fails (AC-9)", async () => {
+    const firstJobs = [{ jobId: "job-1", tasks: {} }];
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: firstJobs }))
+      .mockResolvedValueOnce(new Response("", { status: 500 }));
+
+    const { result } = renderHook(() => useJobListWithUpdates());
+
+    await waitFor(() => expect(result.current.data).not.toBeNull());
+    expect(result.current.data?.[0]?.jobId).toBe("job-1");
+    expect(result.current.error).toBeNull();
+
+    act(() => {
+      MockEventSource.instances[0]?.emit("state:summary", { changeCount: 1 });
+    });
+
+    await waitFor(() => expect(result.current.error?.code).toBe("unknown_error"));
+    expect(result.current.data?.[0]?.jobId).toBe("job-1");
+    expect(result.current.data?.length).toBe(1);
   });
 });

package/src/ui/client/adapters/__tests__/job-adapter.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, it } from "bun:test";
+
+import { deriveProgress } from "../../../../core/job-view.ts";
+import { adaptJobDetail, adaptJobSummary } from "../job-adapter.ts";
+import { applyJobEvent } from "../../reducers/job-events.ts";
+import type { JobWire, SseEvent } from "../../../../config/sse-events.ts";
+
+function makeWire(overrides: Partial<JobWire> & { jobId: string }): JobWire {
+  return {
+    jobId: overrides.jobId,
+    title: overrides.title ?? `Title for ${overrides.jobId}`,
+    status: overrides.status ?? "pending",
+    progress: overrides.progress ?? 0,
+    createdAt: overrides.createdAt ?? null,
+    updatedAt: overrides.updatedAt ?? null,
+    location: overrides.location ?? null,
+    tasks: overrides.tasks ?? {},
+    costsSummary: overrides.costsSummary ?? {
+      totalTokens: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      totalInputCost: 0,
+      totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
+    },
+    ...(overrides.pipelineConfig ? { pipelineConfig: overrides.pipelineConfig } : {}),
+  };
+}
+
+describe("job-adapter progress (AC-7)", () => {
+  it("adapter progress equals deriveProgress output when configured > actual", () => {
+    // Arrange — pipeline has 6 tasks, only 3 are reported; one is "done".
+    const apiJob = {
+      jobId: "job-1",
+      tasks: {
+        build: { state: "done" },
+        test: { state: "pending" },
+        lint: { state: "pending" },
+      },
+      pipelineConfig: {
+        tasks: [
+          { name: "build" },
+          { name: "test" },
+          { name: "lint" },
+          { name: "deploy" },
+          { name: "verify" },
+          { name: "publish" },
+        ],
+      },
+    };
+    const expected = deriveProgress(
+      [
+        { state: "done" },
+        { state: "pending" },
+        { state: "pending" },
+      ],
+      6,
+    );
+
+    // Act
+    const job = adaptJobSummary(apiJob);
+
+    // Assert
+    expect(job.taskCount).toBe(expected.taskCount);
+    expect(job.doneCount).toBe(expected.doneCount);
+    expect(job.completedCount).toBe(expected.completedCount);
+    expect(job.progress).toBe(expected.progress);
+  });
+
+  it("adapter progress equals deriveProgress output when configured < actual", () => {
+    // Arrange — pipeline has 2 tasks, but 3 are reported (one extra runtime task).
+    const apiJob = {
+      jobId: "job-1",
+      tasks: {
+        build: { state: "done" },
+        test: { state: "pending" },
+        _fileTrack: { state: "pending" },
+      },
+      pipelineConfig: { tasks: [{ name: "build" }, { name: "test" }] },
+    };
+    const expected = deriveProgress(
+      [
+        { state: "done" },
+        { state: "pending" },
+        { state: "pending" },
+      ],
+      2,
+    );
+
+    // Act
+    const job = adaptJobSummary(apiJob);
+
+    // Assert
+    expect(job.taskCount).toBe(expected.taskCount);
+    expect(job.doneCount).toBe(expected.doneCount);
+    expect(job.completedCount).toBe(expected.completedCount);
+    expect(job.progress).toBe(expected.progress);
+  });
+
+  it("list, detail, and adapter agree on progress for one shared fixture", () => {
+    // Arrange — one fixture covering done / skipped / pending with a 3-task pipelineConfig.
+    const apiJob = {
+      jobId: "job-1",
+      title: "Shared",
+      status: "running" as const,
+      tasks: {
+        build: { state: "done" },
+        test: { state: "skipped" },
+        deploy: { state: "pending" },
+      },
+      pipelineConfig: { tasks: [{ name: "build" }, { name: "test" }, { name: "deploy" }] },
+    };
+    const wire = makeWire({
+      jobId: "job-1",
+      title: "Shared",
+      status: "running",
+      tasks: {
+        build: { state: "done" },
+        test: { state: "skipped" },
+        deploy: { state: "pending" },
+      },
+      pipelineConfig: { tasks: [{ name: "build" }, { name: "test" }, { name: "deploy" }] },
+    });
+    const configuredCount = Array.isArray(wire.pipelineConfig?.["tasks"])
+      ? (wire.pipelineConfig?.["tasks"] as unknown[]).length
+      : null;
+    const expected = deriveProgress(
+      [
+        { state: "done" },
+        { state: "skipped" },
+        { state: "pending" },
+      ],
+      configuredCount,
+    );
+    const event: SseEvent = { type: "job:updated", data: wire };
+
+    // Act
+    const summary = adaptJobSummary(apiJob);
+    const detail = adaptJobDetail(apiJob);
+    const listAfter = applyJobEvent([], event);
+
+    // Assert — summary, detail, and the list reducer (which reuses adaptJobSummary) all agree.
+    expect(summary.taskCount).toBe(expected.taskCount);
+    expect(summary.doneCount).toBe(expected.doneCount);
+    expect(summary.completedCount).toBe(expected.completedCount);
+    expect(summary.progress).toBe(expected.progress);
+
+    expect(detail.taskCount).toBe(expected.taskCount);
+    expect(detail.doneCount).toBe(expected.doneCount);
+    expect(detail.completedCount).toBe(expected.completedCount);
+    expect(detail.progress).toBe(expected.progress);
+
+    expect(listAfter).toHaveLength(1);
+    expect(listAfter[0]?.taskCount).toBe(expected.taskCount);
+    expect(listAfter[0]?.doneCount).toBe(expected.doneCount);
+    expect(listAfter[0]?.completedCount).toBe(expected.completedCount);
+    expect(listAfter[0]?.progress).toBe(expected.progress);
+  });
+
+  it("preserves costEstimated on task cost breakdowns", () => {
+    const detail = adaptJobDetail({
+      jobId: "job-1",
+      tasks: { build: { state: "done" } },
+      costs: {
+        build: {
+          inputTokens: 10,
+          outputTokens: 5,
+          inputCost: 0,
+          outputCost: 0,
+          totalCost: 0,
+          source: "reported",
+          costEstimated: true,
+        },
+      },
+    });
+
+    expect(detail.costs?.build).toMatchObject({
+      source: "reported",
+      totalCost: 0,
+      costEstimated: true,
+    });
+  });
+});