@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -1,9 +1,11 @@
 import { describe, expect, it } from "vitest";
 
+import type { JobView } from "../../../core/job-view";
 import type {
   APIJob,
   AcquireResult,
   CanonicalJob,
+  CanonicalJobStatus,
   ChangeTrackerState,
   ComposeSnapshotOptions,
   FilterOptions,
@@ -44,7 +46,7 @@ describe("ui/state types", () => {
       jobId: "job-1",
       name: "Job 1",
       title: "Job 1",
-      status: "pending",
+      status: "failed",
       progress: 0,
       createdAt: null,
       updatedAt: null,
@@ -56,15 +58,15 @@ describe("ui/state types", () => {
     const grouped: GroupedJobs = {
       running: [],
       waiting: [],
-      error: [],
-      pending: [job],
+      failed: [],
+      pending: [],
       complete: [],
     };
     const filter: FilterOptions = { status: "pending", location: "current" };
     const apiJob: APIJob = {
       jobId: "job-1",
       title: "Job 1",
-      status: "pending",
+      status: "failed",
       progress: 0,
       createdAt: null,
       updatedAt: null,
@@ -77,6 +79,9 @@ describe("ui/state types", () => {
         totalCost: 0,
         totalInputCost: 0,
         totalOutputCost: 0,
+        estimatedCost: 0,
+        hasEstimated: false,
+        unavailableCost: 0,
       },
     };
     const stats: TransformationStats = {
@@ -96,9 +101,103 @@ describe("ui/state types", () => {
     expect(snapshotDeps.readJob).toBeUndefined();
     expect(schema.fileName).toBe("seed.json");
     expect(result.response).toBeInstanceOf(Response);
-    expect(grouped.pending[0]).toBe(job);
+    expect(job.status).toBe("failed");
+    expect(grouped.failed).toEqual([]);
     expect(filter.location).toBe("current");
     expect(apiJob.costsSummary.totalCost).toBe(0);
+    expect(apiJob.status).toBe("failed");
     expect(stats.transformationRate).toBe(0);
   });
+
+  it("rejects status:\"error\" as a CanonicalJobStatus at the type level", () => {
+    // @ts-expect-error — "error" is not assignable to CanonicalJobStatus
+    const rejected: CanonicalJobStatus = "error";
+    expect(rejected).toBe("error");
+  });
+
+  it("rejects status:\"error\" on a CanonicalJob literal", () => {
+    const job: CanonicalJob = {
+      id: "job-1",
+      jobId: "job-1",
+      name: "Job 1",
+      title: "Job 1",
+      // @ts-expect-error — "error" is not assignable to CanonicalJobStatus
+      status: "error",
+      progress: 0,
+      createdAt: null,
+      updatedAt: null,
+      location: "current",
+      tasks: {},
+      files: {},
+      costs: {},
+    };
+    expect(job.jobId).toBe("job-1");
+  });
+
+  it("rejects status:\"error\" on an APIJob literal", () => {
+    const apiJob: APIJob = {
+      jobId: "job-1",
+      title: "Job 1",
+      // @ts-expect-error — "error" is not assignable to CanonicalJobStatus
+      status: "error",
+      progress: 0,
+      createdAt: null,
+      updatedAt: null,
+      location: "current",
+      tasks: {},
+      costsSummary: {
+        totalTokens: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        totalInputCost: 0,
+        totalOutputCost: 0,
+        estimatedCost: 0,
+        hasEstimated: false,
+        unavailableCost: 0,
+      },
+    };
+    expect(apiJob.jobId).toBe("job-1");
+  });
+
+  it("preserves readable:false and error: { code, message } on a CanonicalJob", () => {
+    const job: CanonicalJob = {
+      id: "job-1",
+      jobId: "job-1",
+      name: "Job 1",
+      title: "Job 1",
+      status: "failed",
+      progress: 0,
+      createdAt: null,
+      updatedAt: null,
+      location: "current",
+      tasks: {},
+      files: {},
+      costs: {},
+      readable: false,
+      error: { code: "E_FOO", message: "broken", path: "/tmp/job-1" },
+    };
+
+    expect(job.readable).toBe(false);
+    expect(job.error).toEqual({ code: "E_FOO", message: "broken", path: "/tmp/job-1" });
+  });
+
+  it("CanonicalJob is structurally identical to JobView", () => {
+    const job: CanonicalJob = {
+      id: "job-1",
+      jobId: "job-1",
+      name: "Job 1",
+      title: "Job 1",
+      status: "failed",
+      progress: 0,
+      createdAt: null,
+      updatedAt: null,
+      location: "current",
+      tasks: {},
+      files: {},
+      costs: {},
+    };
+    const view: JobView = job;
+    expect(view.id).toBe("job-1");
+  });
 });

package/src/ui/state/snapshot.ts

@@ -10,7 +10,7 @@ import type {
   StateSnapshot,
 } from "./types";
 
-const SNAPSHOT_STATUS_ORDER = ["error", "running", "complete", "pending"] as const;
+const SNAPSHOT_STATUS_ORDER = ["failed", "running", "complete", "pending"] as const;
 
 function nowIso(now: (() => Date) | undefined): string {
   return (now ?? (() => new Date()))().toISOString();
@@ -137,7 +137,7 @@ export async function buildSnapshotFromFilesystem(deps: SnapshotDeps = {}): Prom
   const readResults = await Promise.all(
     readRequests.map(async ({ jobId, location }) => {
       try {
-        return await resolved.readJob(jobId, location);
+        return await resolved.readJob(jobId);
       } catch (error) {
         console.warn(`failed to read job "${jobId}" from "${location}"`, error);
         return { ok: false, jobId, location, message: String(error) } satisfies JobReadResult;

package/src/ui/state/transformers/__tests__/list-transformer.test.ts

@@ -34,6 +34,7 @@ describe("list-transformer", () => {
   it("returns status priorities and sorts valid jobs only", () => {
     expect(getStatusPriority("running")).toBe(4);
     expect(getStatusPriority("waiting")).toBe(4);
+    expect(getStatusPriority("failed")).toBe(3);
     expect(getStatusPriority("unknown")).toBe(0);
 
     const jobs = sortJobs([
@@ -57,17 +58,22 @@ describe("list-transformer", () => {
     const jobs = [
       makeJob({ id: "job-1", title: "Alpha", status: "running", progress: 50 }),
       makeJob({ id: "job-2", jobId: "job-2", title: "Beta", status: "complete", progress: 100, location: "complete" }),
+      makeJob({ id: "job-3", jobId: "job-3", title: "Gamma", status: "failed", progress: 25 }),
     ];
 
-    expect(groupJobsByStatus(jobs)).toMatchObject({
+    const grouped = groupJobsByStatus(jobs);
+    expect(grouped).toMatchObject({
       running: [jobs[0]],
       complete: [jobs[1]],
+      failed: [jobs[2]],
       waiting: [],
     });
-    expect(getJobListStats(jobs).averageProgress).toBe(75);
+    expect(grouped).not.toHaveProperty("error");
+    expect(getJobListStats(jobs).averageProgress).toBe(58);
     expect(filterJobs(jobs, "alp")).toEqual([jobs[0]]);
     expect(filterJobs(jobs, "JOB-2")).toEqual([jobs[1]]);
     expect(filterJobs(jobs, "", { status: "complete", location: "complete" })).toEqual([jobs[1]]);
+    expect(filterJobs(jobs, "", { status: "failed" })).toEqual([jobs[2]]);
   });
 
   it("always includes zeroed costs in API output and computes aggregation stats", () => {
@@ -80,6 +86,9 @@ describe("list-transformer", () => {
       totalCost: 0,
       totalInputCost: 0,
       totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
     });
     expect(getAggregationStats(jobs, jobs, jobs)).toEqual({
       totalInput: 2,
@@ -91,6 +100,45 @@ describe("list-transformer", () => {
     });
   });
 
+  it("preserves estimated cost fields in API output", () => {
+    const job = makeJob({
+      costs: {
+        totalTokens: 10,
+        totalInputTokens: 6,
+        totalOutputTokens: 4,
+        totalCost: 1,
+        totalInputCost: 0.6,
+        totalOutputCost: 0.4,
+        estimatedCost: 2,
+        unavailableCost: 3,
+        hasEstimated: true,
+      },
+    });
+
+    expect(transformJobListForAPI([job])[0]?.costsSummary).toEqual({
+      totalTokens: 10,
+      totalInputTokens: 6,
+      totalOutputTokens: 4,
+      totalCost: 1,
+      totalInputCost: 0.6,
+      totalOutputCost: 0.4,
+      estimatedCost: 2,
+      unavailableCost: 3,
+      hasEstimated: true,
+    });
+  });
+
+  it("defaults missing estimated cost fields to 0/false", () => {
+    const job = makeJob({ costs: { totalCost: 5 } });
+
+    expect(transformJobListForAPI([job])[0]?.costsSummary).toMatchObject({
+      totalCost: 5,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
+    });
+  });
+
   it("passes gate metadata through API list output", () => {
     const gate = {
       afterTask: "review",
@@ -103,4 +151,39 @@ describe("list-transformer", () => {
       gate,
     });
   });
+
+  it("keeps an unreadable placeholder with null createdAt through aggregate and transform", () => {
+    const error = {
+      code: "INVALID_JSON",
+      message: "Repair or delete /path/to/tasks-status.json for job \"job-x\" to recover.",
+      path: "/path/to/tasks-status.json",
+    };
+    const placeholder = makeJob({
+      id: "job-x",
+      jobId: "job-x",
+      status: "failed",
+      createdAt: null,
+      readable: false,
+      error,
+    });
+
+    const aggregated = aggregateAndSortJobs([placeholder], []);
+    expect(aggregated).toHaveLength(1);
+    expect(aggregated[0]?.id).toBe("job-x");
+
+    const apiJob = transformJobListForAPI(aggregated)[0];
+    expect(apiJob?.jobId).toBe("job-x");
+    expect(apiJob?.readable).toBe(false);
+    expect(apiJob?.error).toEqual(error);
+  });
+
+  it("does not add readable or error to a normal job in API output", () => {
+    const normal = makeJob();
+
+    expect(aggregateAndSortJobs([normal], [])).toHaveLength(1);
+
+    const apiJob = transformJobListForAPI([normal])[0];
+    expect(apiJob).not.toHaveProperty("readable");
+    expect(apiJob).not.toHaveProperty("error");
+  });
 });

package/src/ui/state/transformers/__tests__/status-transformer.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
 
+import { normalizeJobView } from "../../../../core/job-view";
 import {
+  buildUnreadableJob,
   computeJobStatus,
   getTransformationStats,
   transformJobStatus,
@@ -48,11 +50,11 @@ describe("status-transformer", () => {
     expect(job?.id).toBe("job-1");
     expect(job?.jobId).toBe("job-1");
     expect(job?.name).toBe("Title");
-    expect(warn).toHaveBeenCalledOnce();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("job id mismatch"));
     warn.mockRestore();
   });
 
-  it("computes progress from tasks alone, ignoring any previously persisted value", () => {
+  it("computeJobStatus returns running when half the tasks are done", () => {
     const result = computeJobStatus({
       a: { state: "done" },
       b: { state: "done" },
@@ -63,7 +65,7 @@ describe("status-transformer", () => {
     expect(result).toEqual({ status: "running", progress: 50 });
   });
 
-  it("counts skipped tasks as completed progress units", () => {
+  it("computeJobStatus returns pending when some tasks are pending and none running", () => {
     const result = computeJobStatus({
       a: { state: "done" },
       b: { state: "skipped" },
@@ -77,8 +79,8 @@ describe("status-transformer", () => {
     expect(computeJobStatus([])).toEqual({ status: "pending", progress: 0 });
   });
 
-  it("transformJobStatus derives progress from tasks, not record.progress", () => {
-    const job = transformJobStatus(
+  it("transformJobStatus derives progress from tasks via deriveProgress (ignores persisted progress)", () => {
+    const withProgress = transformJobStatus(
       {
         title: "Test",
         progress: 100,
@@ -91,8 +93,44 @@ describe("status-transformer", () => {
       "current",
     );
 
-    expect(job?.progress).toBe(50);
-    expect(job?.status).toBe("running");
+    expect(withProgress?.progress).toBe(50);
+    expect(withProgress?.status).toBe("running");
+
+    const withoutProgress = transformJobStatus(
+      {
+        title: "Test",
+        tasks: {
+          a: { state: "done" },
+        },
+      },
+      "job-2",
+      "current",
+    );
+
+    expect(withoutProgress?.progress).toBe(100);
+    expect(withoutProgress?.status).toBe("complete");
+  });
+
+  it("transformJobStatus aggregates task tokenUsage costs through the canonical view", () => {
+    const job = transformJobStatus(
+      {
+        title: "Costed",
+        state: "done",
+        tasks: {
+          a: { state: "done", tokenUsage: [["openai:gpt-4o", 12, 6, 0.25]] },
+          b: { state: "done", tokenUsage: [["anthropic:claude", 3, 9, 0.5]] },
+        },
+      },
+      "job-cost",
+      "complete",
+    );
+
+    expect(job?.costs).toMatchObject({
+      totalCost: 0.75,
+      totalTokens: 30,
+      totalInputTokens: 15,
+      totalOutputTokens: 15,
+    });
   });
 
   it("surfaces waiting snapshots and gate metadata", () => {
@@ -138,7 +176,7 @@ describe("status-transformer", () => {
       "current",
     );
 
-    expect(job?.status).toBe("error");
+    expect(job?.status).toBe("failed");
   });
 
   it("maps numeric restartCount on tasks", () => {
@@ -183,23 +221,15 @@ describe("status-transformer", () => {
     expect(tasks.alpha?.lastRetryError).toBeNull();
   });
 
-  it("filters failed reads and computes transformation stats", () => {
-    const transformed = transformMultipleJobs([
+  it("computes transformation stats for valid reads", () => {
+    const readResults = [
       { ok: true, data: { tasks: { a: { state: "done" } } }, jobId: "job-1", location: "current" },
-      { ok: false, jobId: "job-2", location: "current" },
-    ]);
+    ];
+    const transformed = transformMultipleJobs(readResults);
 
     expect(transformed).toHaveLength(1);
-    expect(
-      getTransformationStats(
-        [
-          { ok: true, data: { tasks: { a: { state: "done" } } }, jobId: "job-1", location: "current" },
-          { ok: false, jobId: "job-2", location: "current" },
-        ],
-        transformed,
-      ),
-    ).toEqual({
-      totalRead: 2,
+    expect(getTransformationStats(readResults, transformed)).toEqual({
+      totalRead: 1,
       successfulReads: 1,
       successfulTransforms: 1,
       failedTransforms: 0,
@@ -207,4 +237,202 @@ describe("status-transformer", () => {
       statusDistribution: { complete: 1 },
     });
   });
+
+  it("computes transformation stats without counting unreadable placeholders as successful transforms", () => {
+    const readResults = [
+      { ok: true, data: { tasks: { a: { state: "done" } } }, jobId: "job-1", location: "current" },
+      { ok: false, code: "INVALID_JSON", jobId: "job-2", location: "current" },
+      { ok: false, code: "JOB_NOT_FOUND", jobId: "job-3", location: "current" },
+    ];
+    const transformed = transformMultipleJobs(readResults);
+
+    expect(transformed).toHaveLength(2);
+    expect(getTransformationStats(readResults, transformed)).toEqual({
+      totalRead: 3,
+      successfulReads: 1,
+      successfulTransforms: 1,
+      failedTransforms: 0,
+      transformationRate: 1,
+      statusDistribution: { complete: 1, failed: 1 },
+    });
+  });
+
+  it("buildUnreadableJob maps corrupt reads to an error placeholder with recovery guidance", () => {
+    const placeholder = buildUnreadableJob({
+      ok: false,
+      code: "INVALID_JSON",
+      path: "/jobs/job-2/tasks-status.json",
+      jobId: "job-2",
+      location: "current",
+    });
+
+    expect(placeholder.readable).toBe(false);
+    expect(placeholder.status).toBe("failed");
+    expect(placeholder.error?.code).toBe("INVALID_JSON");
+    expect(placeholder.error?.path).toBe("/jobs/job-2/tasks-status.json");
+    const message = placeholder.error?.message.toLowerCase() ?? "";
+    expect(message).toContain("repair");
+    expect(message).toContain("delete");
+    expect(message).toContain("job-2");
+    expect(message).toContain("/jobs/job-2/tasks-status.json");
+  });
+
+  it("buildUnreadableJob uses the same fallback code in the message and structured error", () => {
+    const placeholder = buildUnreadableJob({
+      ok: false,
+      message: "EACCES",
+      jobId: "job-2",
+      location: "current",
+    });
+
+    expect(placeholder.error?.code).toBe("UNKNOWN_READ_ERROR");
+    expect(placeholder.error?.message).toContain("(UNKNOWN_READ_ERROR)");
+    expect(placeholder.error?.message).toContain("EACCES");
+  });
+
+  it("transformMultipleJobs maps corrupt reads to placeholders, skips missing reads, and leaves valid results readable", () => {
+    const transformed = transformMultipleJobs([
+      {
+        ok: true,
+        data: { tasks: { a: { state: "done" } } },
+        jobId: "job-1",
+        location: "current",
+      },
+      {
+        ok: false,
+        code: "INVALID_JSON",
+        path: "/jobs/job-2/tasks-status.json",
+        jobId: "job-2",
+        location: "current",
+      },
+      {
+        ok: false,
+        code: "JOB_NOT_FOUND",
+        jobId: "job-3",
+        location: "current",
+      },
+    ]);
+
+    expect(transformed).toHaveLength(2);
+    const [valid, unreadable] = transformed;
+
+    expect(valid?.status).toBe("complete");
+    expect(valid?.readable).toBeUndefined();
+    expect(valid?.error).toBeUndefined();
+
+    expect(unreadable?.readable).toBe(false);
+    expect(unreadable?.status).toBe("failed");
+    expect(unreadable?.error?.code).toBe("INVALID_JSON");
+    expect(unreadable?.error?.path).toBe("/jobs/job-2/tasks-status.json");
+  });
+
+  it("coerces parseable-but-tasks-missing snapshots to readable jobs", () => {
+    const transformed = transformMultipleJobs([
+      { ok: true, data: { jobId: "job-3" }, jobId: "job-3", location: "current" },
+    ]);
+
+    expect(transformed).toHaveLength(1);
+    const job = transformed[0];
+    expect(job?.readable).not.toBe(false);
+    expect(job?.error).toBeUndefined();
+    expect(job?.status).toBe("pending");
+    expect(job?.tasks).toEqual({});
+  });
+
+  it("transformJobStatus output equals normalizeJobView for object inputs", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const raw = {
+      jobId: "job-1",
+      title: "Title",
+      state: "failed",
+      tasks: { alpha: { state: "done" } },
+      gate: null,
+      error: { name: "GateRejected", message: "gate rejected" },
+    };
+
+    const wrapped = transformJobStatus(raw, "job-1", "current");
+    const direct = normalizeJobView(raw, "job-1", "current");
+
+    expect(wrapped).not.toBeNull();
+    expect(wrapped).toEqual(direct);
+    warn.mockRestore();
+  });
+
+  it("transformJobStatus returns null for non-object raw input", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    expect(transformJobStatus(null, "job-1", "current")).toBeNull();
+    expect(transformJobStatus("not an object", "job-1", "current")).toBeNull();
+    expect(transformJobStatus([1, 2, 3], "job-1", "current")).toBeNull();
+    expect(warn).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it("buildUnreadableJob returns status:'failed' and survives isValidJob", () => {
+    const placeholder = buildUnreadableJob({
+      ok: false,
+      code: "INVALID_JSON",
+      path: "/jobs/job-2/tasks-status.json",
+      jobId: "job-2",
+      location: "current",
+    });
+
+    expect(placeholder.status).toBe("failed");
+    expect(placeholder.readable).toBe(false);
+    expect(placeholder.id).toBe("job-2");
+    expect(placeholder.jobId).toBe("job-2");
+    expect(placeholder.error?.code).toBe("INVALID_JSON");
+    expect(placeholder.error?.path).toBe("/jobs/job-2/tasks-status.json");
+
+    expect(Boolean(placeholder.id && placeholder.status)).toBe(true);
+  });
+
+  it("transformTasks uses zero-based fallback ids for unnamed array entries", () => {
+    const unnamed = transformTasks([{}, {}]);
+    expect(Object.keys(unnamed)).toEqual(["task-0", "task-1"]);
+
+    const mixed = transformTasks([{ name: "alpha" }, {}]);
+    expect(Object.keys(mixed)).toEqual(["alpha", "task-1"]);
+  });
+
+  it("transformJobStatus preserves control_invalid kind and omits invalid kind (AC-11)", () => {
+    const controlInvalid = transformJobStatus(
+      {
+        state: "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" },
+        },
+      },
+      "job-1",
+      "current",
+    );
+
+    expect(controlInvalid?.gate?.kind).toBe("control_invalid");
+
+    const invalidKind = transformJobStatus(
+      {
+        state: "waiting",
+        gate: {
+          afterTask: "review",
+          message: "Control file invalid.",
+          requestedAt: "2026-06-19T12:00:00.000Z",
+          kind: "garbage",
+        },
+        tasks: {
+          review: { state: "done" },
+        },
+      },
+      "job-2",
+      "current",
+    );
+
+    expect(invalidKind?.gate).toBeDefined();
+    expect(Object.hasOwn(invalidKind!.gate!, "kind")).toBe(false);
+  });
 });

package/src/ui/state/transformers/list-transformer.ts

@@ -12,7 +12,7 @@ import type {
 const STATUS_PRIORITY: Record<string, number> = {
   running: 4,
   waiting: 4,
-  error: 3,
+  failed: 3,
   pending: 2,
   complete: 1,
 };
@@ -24,9 +24,13 @@ const ZERO_COSTS: CostsSummary = {
   totalCost: 0,
   totalInputCost: 0,
   totalOutputCost: 0,
+  estimatedCost: 0,
+  hasEstimated: false,
+  unavailableCost: 0,
 };
 
 function isValidJob(job: CanonicalJob): boolean {
+  if (job.readable === false) return Boolean(job.id && job.status);
   return Boolean(job.id && job.status && job.createdAt);
 }
 
@@ -42,6 +46,9 @@ function getCostsSummary(costs: Record<string, unknown>): CostsSummary {
     totalCost: typeof costs["totalCost"] === "number" ? costs["totalCost"] : 0,
     totalInputCost: typeof costs["totalInputCost"] === "number" ? costs["totalInputCost"] : 0,
     totalOutputCost: typeof costs["totalOutputCost"] === "number" ? costs["totalOutputCost"] : 0,
+    estimatedCost: typeof costs["estimatedCost"] === "number" ? costs["estimatedCost"] : 0,
+    hasEstimated: typeof costs["hasEstimated"] === "boolean" ? costs["hasEstimated"] : false,
+    unavailableCost: typeof costs["unavailableCost"] === "number" ? costs["unavailableCost"] : 0,
   };
 }
 
@@ -56,7 +63,7 @@ export function sortJobs(jobs: CanonicalJob[]): CanonicalJob[] {
     .sort((left, right) => {
       const priority = getStatusPriority(right.status) - getStatusPriority(left.status);
       if (priority !== 0) return priority;
-      const created = left.createdAt!.localeCompare(right.createdAt!);
+      const created = (left.createdAt ?? "").localeCompare(right.createdAt ?? "");
       if (created !== 0) return created;
       return left.id.localeCompare(right.id);
     });
@@ -82,7 +89,7 @@ export function groupJobsByStatus(jobs: CanonicalJob[]): GroupedJobs {
   const grouped: GroupedJobs = {
     running: [],
     waiting: [],
-    error: [],
+    failed: [],
     pending: [],
     complete: [],
   };
@@ -158,6 +165,9 @@ export function transformJobListForAPI(
       apiJob.pipelineConfig = job.pipelineConfig;
     }
 
+    if (job.readable !== undefined) apiJob.readable = job.readable;
+    if (job.error !== undefined) apiJob.error = job.error;
+
     return apiJob;
   });
 }