@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -92,6 +92,9 @@ describe("job adapter", () => {
       totalCost: 0,
       totalInputCost: 0,
       totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
     });
   });
 
@@ -130,14 +133,14 @@ describe("job adapter", () => {
     });
   });
 
-  it("derives taskCount from pipelineConfig when available", () => {
+  it("derives taskCount as max(configured, actual) when pipelineConfig is available", () => {
     const job = adaptJobSummary({
       jobId: "job-1",
       tasks: { build: { state: "done" }, test: { state: "pending" }, _fileTrack: { state: "pending" } },
       pipelineConfig: { tasks: [{ name: "build" }, { name: "test" }] },
     });
 
-    expect(job.taskCount).toBe(2);
+    expect(job.taskCount).toBe(3);
     expect(job.doneCount).toBe(1);
   });
 
@@ -227,6 +230,38 @@ describe("job adapter", () => {
     expect(job.__warnings).toEqual(["Unsupported task collection shape"]);
   });
 
+  it("passes readable:false and the full error payload through to the normalized summary", () => {
+    const error = {
+      code: "INVALID_JSON",
+      message: "Status file is unreadable. Repair or delete tasks-status.json for job \"job-1\" to recover.",
+      path: "pipeline-data/current/job-1/tasks-status.json",
+    };
+
+    const job = adaptJobSummary({
+      jobId: "job-1",
+      status: "error",
+      tasks: {},
+      readable: false,
+      error,
+    });
+
+    expect(job.readable).toBe(false);
+    expect(job.error).toEqual(error);
+    expect(job.error?.path).toBe(error.path);
+  });
+
+  it("omits readable and error when the input does not provide them", () => {
+    const job = adaptJobSummary({
+      jobId: "job-1",
+      tasks: { build: { state: "done" } },
+    });
+
+    expect(job.readable).toBeUndefined();
+    expect(Object.hasOwn(job, "readable")).toBe(false);
+    expect(job.error).toBeUndefined();
+    expect(Object.hasOwn(job, "error")).toBe(false);
+  });
+
   it("disables actions for running jobs", () => {
     const job = adaptJobSummary({
       jobId: "job-1",
@@ -270,4 +305,170 @@ describe("job adapter", () => {
 
     expect(deriveAllowedActions(job, ["build", "test"])).toEqual({ start: true, restart: true });
   });
+
+  it("adapts a canonical failed job to status 'failed' and displayCategory 'errors'", () => {
+    const job = adaptJobSummary({
+      jobId: "job-1",
+      status: "failed",
+      tasks: { build: { state: "done" } },
+    });
+
+    expect(job.status).toBe("failed");
+    expect(job.displayCategory).toBe("errors");
+  });
+
+  it("tolerates legacy status 'error' and emits canonical 'failed'", () => {
+    const job = adaptJobSummary({
+      jobId: "job-1",
+      status: "error",
+      tasks: { build: { state: "done" } },
+    });
+
+    expect(job.status).toBe("failed");
+    expect(job.displayCategory).toBe("errors");
+  });
+
+  it("uses 'task-0' and 'task-1' fallback ids for unnamed array entries to match the server fixture", () => {
+    const tasks = normalizeTasks([
+      { state: "done" },
+      { state: "pending" },
+    ]);
+
+    expect(Object.keys(tasks).sort()).toEqual(["task-0", "task-1"]);
+    expect(tasks["task-0"]?.name).toBe("task-0");
+    expect(tasks["task-0"]?.state).toBe("done");
+    expect(tasks["task-1"]?.name).toBe("task-1");
+    expect(tasks["task-1"]?.state).toBe("pending");
+  });
+
+  it("uses explicit task names as object keys when array entries are named", () => {
+    const tasks = normalizeTasks([
+      { name: "build", state: "done" },
+      { name: "test", state: "pending" },
+    ]);
+
+    expect(Object.keys(tasks).sort()).toEqual(["build", "test"]);
+    expect(tasks["build"]?.name).toBe("build");
+    expect(tasks["test"]?.name).toBe("test");
+  });
+
+  it("preserves gate.kind === 'control_invalid' through adaptJobDetail (AC-11)", () => {
+    const job = adaptJobDetail({
+      jobId: "job-1",
+      status: "waiting",
+      gate: {
+        afterTask: "review",
+        message: "Control file invalid for review: bad directive.",
+        requestedAt: "2026-06-19T12:00:00.000Z",
+        kind: "control_invalid",
+      },
+      tasks: {
+        review: { state: "done" },
+        deploy: { state: "pending" },
+      },
+    });
+
+    expect(job.gate?.kind).toBe("control_invalid");
+  });
+
+  it("omits gate.kind when value is not one of the allowed strings (AC-11)", () => {
+    for (const invalidKind of [{ junk: true }, "garbage"]) {
+      const job = adaptJobDetail({
+      jobId: "job-1",
+      status: "waiting",
+      gate: {
+        afterTask: "review",
+        message: "Control file invalid.",
+        requestedAt: "2026-06-19T12:00:00.000Z",
+        kind: invalidKind,
+      },
+      tasks: {
+        review: { state: "done" },
+      },
+    });
+
+      expect(job.gate).not.toBeNull();
+      expect(job.gate).toBeDefined();
+      expect(Object.hasOwn(job.gate!, "kind")).toBe(false);
+    }
+  });
+
+  it("preserves estimated cost summary fields through adaptJobSummary", () => {
+    const job = adaptJobSummary({
+      jobId: "job-1",
+      tasks: {},
+      costsSummary: {
+        totalTokens: 10,
+        totalInputTokens: 6,
+        totalOutputTokens: 4,
+        totalCost: 1,
+        totalInputCost: 0.6,
+        totalOutputCost: 0.4,
+        estimatedCost: 2,
+        unavailableCost: 3,
+        hasEstimated: true,
+      },
+    });
+
+    expect(job.costsSummary).toEqual({
+      totalTokens: 10,
+      totalInputTokens: 6,
+      totalOutputTokens: 4,
+      totalCost: 1,
+      totalInputCost: 0.6,
+      totalOutputCost: 0.4,
+      estimatedCost: 2,
+      unavailableCost: 3,
+      hasEstimated: true,
+    });
+  });
+
+  it("preserves source and failed markers in cost breakdown through adaptJobDetail", () => {
+    const detail = adaptJobDetail({
+      jobId: "job-1",
+      tasks: { build: { state: "done" } },
+      costs: {
+        build: {
+          inputTokens: 1,
+          outputTokens: 2,
+          inputCost: 3,
+          outputCost: 4,
+          totalCost: 7,
+          source: "estimated",
+          failed: true,
+        },
+      },
+    });
+
+    expect(detail.costs?.build).toEqual({
+      inputTokens: 1,
+      outputTokens: 2,
+      inputCost: 3,
+      outputCost: 4,
+      totalCost: 7,
+      source: "estimated",
+      failed: true,
+    });
+  });
+
+  it("drops unknown source values in cost breakdown", () => {
+    const detail = adaptJobDetail({
+      jobId: "job-1",
+      tasks: { build: { state: "done" } },
+      costs: {
+        build: {
+          inputTokens: 1,
+          outputTokens: 2,
+          inputCost: 3,
+          outputCost: 4,
+          totalCost: 7,
+          source: "bogus",
+        },
+      },
+    });
+
+    expect(detail.costs?.build).toBeDefined();
+    expect(Object.hasOwn(detail.costs!.build!, "source")).toBe(false);
+    expect(Object.hasOwn(detail.costs!.build!, "failed")).toBe(false);
+  });
 });

package/src/ui/client/__tests__/load-state.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "bun:test";
+
+import { nextLoadState } from "../load-state";
+import type { ApiError } from "../types";
+
+function makeError(overrides: Partial<ApiError> = {}): ApiError {
+  return {
+    code: "unknown_error",
+    message: "boom",
+    status: 500,
+    ...overrides,
+  };
+}
+
+describe("nextLoadState", () => {
+  it("stores data and clears any prior error on a successful read", () => {
+    const prev = { data: null, error: makeError({ message: "stale" }) } as const;
+    const result = { ok: true, data: "fresh" } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).toEqual({ data: "fresh", error: null });
+  });
+
+  it("captures a scratch error when there is no prior data", () => {
+    const prev = { data: null, error: null } as const;
+    const result = { ok: false, error: makeError({ message: "offline" }) } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).toEqual({ data: null, error: result.error });
+  });
+
+  it("keeps prior data when a refetch fails", () => {
+    const prev = { data: ["job-1"], error: null } as const;
+    const result = { ok: false, error: makeError({ message: "refetch failed" }) } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).toEqual({ data: ["job-1"], error: result.error });
+  });
+
+  it("replaces a prior error on a new error while keeping prior data", () => {
+    const prev = { data: { id: "job-1" }, error: makeError({ code: "network_error" }) } as const;
+    const result = { ok: false, error: makeError({ code: "unknown_error", message: "later" }) } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).toEqual({ data: { id: "job-1" }, error: result.error });
+  });
+
+  it("replaces a prior error with the latest error when no data has loaded", () => {
+    const prev = { data: null, error: makeError({ message: "first" }) } as const;
+    const result = { ok: false, error: makeError({ message: "second" }) } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).toEqual({ data: null, error: result.error });
+  });
+
+  it("returns a new object so React state updates are referentially detectable", () => {
+    const prev = { data: null, error: null } as const;
+    const result = { ok: true, data: 42 } as const;
+
+    const next = nextLoadState(prev, result);
+
+    expect(next).not.toBe(prev);
+    expect(next).not.toBe(result);
+  });
+});

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

@@ -1,10 +1,11 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 
 import type {
   AllowedActions,
   AnalysisProgressState,
   ApiError,
   ConnectionStatus,
+  CostsSummary,
   NormalizedJobSummary,
   SseEventType,
 } from "../types";
@@ -51,14 +52,76 @@ describe("ui client types", () => {
     } satisfies AnalysisProgressState;
 
     const connection: ConnectionStatus = "connected";
-    const event: SseEventType = "job:updated";
     const actions = { start: true, restart: false } satisfies AllowedActions;
 
     expect(error.status).toBe(404);
     expect(job.jobId).toBe("job-1");
     expect(analysis.status).toBe("idle");
     expect(connection).toBe("connected");
-    expect(event).toBe("job:updated");
     expect(actions.start).toBe(true);
   });
 });
+
+describe("SseEventType", () => {
+  it("accepts every contract event name", () => {
+    const contractNames: SseEventType[] = [
+      "state:change",
+      "state:summary",
+      "job:created",
+      "job:updated",
+      "job:removed",
+      "heartbeat",
+      "seed:uploaded",
+    ];
+
+    expect(contractNames).toHaveLength(7);
+    expect(new Set(contractNames).size).toBe(7);
+  });
+
+  it("does not include the legacy task:updated name", () => {
+    const contractNames: SseEventType[] = [
+      "state:change",
+      "state:summary",
+      "job:created",
+      "job:updated",
+      "job:removed",
+      "heartbeat",
+      "seed:uploaded",
+    ];
+
+    expect(contractNames).not.toContain("task:updated");
+  });
+
+  it("rejects legacy browser event names that are not in the contract", () => {
+    // @ts-expect-error — "state" is a legacy event name not in the SseEvent contract.
+    const legacyState: SseEventType = "state";
+    // @ts-expect-error — "message" is a legacy event name not in the SseEvent contract.
+    const legacyMessage: SseEventType = "message";
+    // @ts-expect-error — "status:changed" is a legacy event name not in the SseEvent contract.
+    const legacyStatusChanged: SseEventType = "status:changed";
+    // @ts-expect-error — "task:updated" is the dead cross-process event; removed in this spec.
+    const legacyTaskUpdated: SseEventType = "task:updated";
+
+    expect([legacyState, legacyMessage, legacyStatusChanged, legacyTaskUpdated]).toHaveLength(4);
+  });
+});
+
+describe("CostsSummary estimate contract", () => {
+  it("supports the estimated-cost and unavailable-cost fields", () => {
+    const summary: CostsSummary = {
+      totalTokens: 1000,
+      totalInputTokens: 800,
+      totalOutputTokens: 200,
+      totalCost: 0.5,
+      totalInputCost: 0.4,
+      totalOutputCost: 0.1,
+      estimatedCost: 0.12,
+      hasEstimated: true,
+      unavailableCost: 0,
+    };
+
+    expect(summary.estimatedCost).toBe(0.12);
+    expect(summary.hasEstimated).toBe(true);
+    expect(summary.unavailableCost).toBe(0);
+  });
+});