@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/ui/client/reducers/__tests__/job-events.test.ts

@@ -0,0 +1,568 @@
+import { describe, expect, it } from "bun:test";
+
+import type { JobWire, SseEvent } from "../../../../config/sse-events.ts";
+import { adaptJobDetail } from "../../adapters/job-adapter.ts";
+import { applyDetailEvent, applyJobEvent } from "../job-events.ts";
+import type { NormalizedJobDetail, NormalizedJobSummary } from "../../types.ts";
+
+function makeJob(jobId: string, fields: Partial<NormalizedJobSummary> = {}): 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",
+    ...fields,
+  };
+}
+
+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("applyJobEvent", () => {
+  describe("job:created", () => {
+    it("appends to an empty list", () => {
+      // Arrange
+      const event: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-1" }),
+      };
+
+      // Act
+      const next = applyJobEvent([], event);
+
+      // Assert
+      expect(next).toHaveLength(1);
+      expect(next[0]?.jobId).toBe("job-1");
+    });
+
+    it("appends to a non-empty list when the jobId is new", () => {
+      // Arrange
+      const jobs = [makeJob("job-1")];
+      const event: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-2" }),
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next).toHaveLength(2);
+      expect(next.map((job) => job.jobId).sort()).toEqual(["job-1", "job-2"]);
+    });
+  });
+
+  describe("job:updated", () => {
+    it("merges the incoming data into the existing entry", () => {
+      // Arrange
+      const jobs = [makeJob("job-1", { name: "old" })];
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({ jobId: "job-1", title: "new" }),
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next).toHaveLength(1);
+      expect(next[0]?.name).toBe("new");
+    });
+
+    it("returns the same array reference when the update is a no-op", () => {
+      // Arrange
+      const jobs = [makeJob("job-1", { name: "same" })];
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({ jobId: "job-1", title: "same" }),
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next).toBe(jobs);
+    });
+  });
+
+  describe("job:removed", () => {
+    it("drops the matching job", () => {
+      // Arrange
+      const jobs = [makeJob("job-1"), makeJob("job-2")];
+      const event: SseEvent = {
+        type: "job:removed",
+        data: { jobId: "job-1" },
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next).toHaveLength(1);
+      expect(next[0]?.jobId).toBe("job-2");
+    });
+
+    it("returns the same array reference when the jobId is absent", () => {
+      // Arrange
+      const jobs = [makeJob("job-1")];
+      const event: SseEvent = {
+        type: "job:removed",
+        data: { jobId: "job-missing" },
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next).toBe(jobs);
+    });
+  });
+
+  describe("sort order", () => {
+    it("applies a stable 3-key sort (status, createdAt, jobId)", () => {
+      // Arrange — three pending jobs with the same createdAt; tie-break must be jobId asc.
+      const jobs = [
+        makeJob("job-c", { status: "pending", createdAt: "2026-01-01T00:00:00.000Z" }),
+        makeJob("job-a", { status: "pending", createdAt: "2026-01-01T00:00:00.000Z" }),
+        makeJob("job-b", { status: "pending", createdAt: "2026-01-01T00:00:00.000Z" }),
+      ];
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-x",
+          title: "x",
+          status: "pending",
+          createdAt: "2026-01-01T00:00:00.000Z",
+        }),
+      };
+
+      // Act
+      const next = applyJobEvent(jobs, event);
+
+      // Assert
+      expect(next.map((job) => job.jobId)).toEqual(["job-a", "job-b", "job-c", "job-x"]);
+    });
+  });
+
+  describe("idempotency", () => {
+    it("does not duplicate when the same job:created snapshot is applied twice", () => {
+      // Arrange
+      const event: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-1" }),
+      };
+
+      // Act
+      const once = applyJobEvent([], event);
+      const twice = applyJobEvent(once, event);
+
+      // Assert
+      expect(twice).toHaveLength(1);
+      expect(twice[0]?.jobId).toBe("job-1");
+      expect(twice).toBe(once);
+    });
+
+    it("does not duplicate or mutate when the same job:updated snapshot is applied twice", () => {
+      // Arrange
+      const jobs = [makeJob("job-1", { name: "old" })];
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({ jobId: "job-1", title: "new" }),
+      };
+      const jobsBefore = jobs.slice();
+
+      // Act
+      const once = applyJobEvent(jobs, event);
+      const twice = applyJobEvent(once, event);
+
+      // Assert
+      expect(twice).toHaveLength(1);
+      expect(twice[0]?.name).toBe("new");
+      expect(jobs).toEqual(jobsBefore);
+    });
+
+    it("commutes for events targeting different jobIds", () => {
+      // Arrange
+      const eventA: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-a" }),
+      };
+      const eventB: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-b" }),
+      };
+
+      // Act
+      const orderAB = applyJobEvent(applyJobEvent([], eventA), eventB);
+      const orderBA = applyJobEvent(applyJobEvent([], eventB), eventA);
+
+      // Assert — same content, same deterministic order (jobId ascending tie-break)
+      expect(orderAB.map((job) => job.jobId)).toEqual(["job-a", "job-b"]);
+      expect(orderBA.map((job) => job.jobId)).toEqual(["job-a", "job-b"]);
+      expect(orderAB).toEqual(orderBA);
+    });
+  });
+
+  describe("non-list event types", () => {
+    it("returns the same array reference for heartbeat, seed:uploaded, state:change, and state:summary", () => {
+      // Arrange
+      const jobs = [makeJob("job-1")];
+      const heartbeat: SseEvent = {
+        type: "heartbeat",
+        data: { ok: true, timestamp: "2026-06-21T00:00:00.000Z" },
+      };
+      const seedUploaded: SseEvent = { type: "seed:uploaded", data: {} };
+      const stateChange: SseEvent = {
+        type: "state:change",
+        data: { jobId: "job-1", path: "pipeline-data/current/job-1/tasks-status.json" },
+      };
+      const stateSummary: SseEvent = { type: "state:summary", data: { changeCount: 1 } };
+
+      // Act + Assert
+      expect(applyJobEvent(jobs, heartbeat)).toBe(jobs);
+      expect(applyJobEvent(jobs, seedUploaded)).toBe(jobs);
+      expect(applyJobEvent(jobs, stateChange)).toBe(jobs);
+      expect(applyJobEvent(jobs, stateSummary)).toBe(jobs);
+    });
+  });
+});
+
+function makeDetail(jobId: string): NormalizedJobDetail {
+  return {
+    id: jobId,
+    jobId,
+    name: jobId,
+    status: "pending",
+    progress: 0,
+    taskCount: 2,
+    doneCount: 0,
+    location: "current",
+    tasks: {
+      build: {
+        name: "build",
+        state: "pending",
+        startedAt: null,
+        endedAt: null,
+        files: { artifacts: [], logs: [], tmp: [] },
+      },
+      test: {
+        name: "test",
+        state: "pending",
+        startedAt: null,
+        endedAt: null,
+        files: { artifacts: [], logs: [], tmp: [] },
+      },
+    },
+    displayCategory: "current",
+  };
+}
+
+describe("applyDetailEvent", () => {
+  describe("job:updated", () => {
+    it("merges a matching event and updates the changed task state (AC-11)", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "done" },
+            test: { state: "running" },
+          },
+        }),
+      };
+
+      // Act
+      const next = applyDetailEvent(detail, event);
+
+      // Assert
+      expect(next.tasks["build"]?.state).toBe("done");
+      expect(next.tasks["test"]?.state).toBe("running");
+    });
+
+    it("ignores a job:updated whose jobId does not match the detail", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-2",
+          tasks: { build: { state: "done" } },
+        }),
+      };
+
+      // Act
+      const next = applyDetailEvent(detail, event);
+
+      // Assert
+      expect(next).toBe(detail);
+    });
+  });
+
+  describe("task reference preservation (AC-9)", () => {
+    it("preserves the object reference for tasks whose normalized payload did not change and replaces the reference for tasks whose payload changed", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "done" },
+            test: { state: "pending" },
+          },
+        }),
+      };
+
+      // Act
+      const next = applyDetailEvent(detail, event);
+
+      // Assert — changed task gets a new reference, unchanged task keeps its reference
+      expect(next.tasks["build"]).not.toBe(detail.tasks["build"]);
+      expect(next.tasks["build"]?.state).toBe("done");
+      expect(next.tasks["test"]).toBe(detail.tasks["test"]);
+    });
+  });
+
+  describe("idempotency (AC-8)", () => {
+    it("returns the same reference when the same snapshot is applied twice", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "done" },
+            test: { state: "running" },
+          },
+        }),
+      };
+
+      // Act
+      const once = applyDetailEvent(detail, event);
+      const twice = applyDetailEvent(once, event);
+
+      // Assert
+      expect(twice).toBe(once);
+    });
+
+    it("preserves task references and leaves derived fields unchanged when the event payload already matches the current detail", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "pending" },
+            test: { state: "pending" },
+          },
+        }),
+      };
+
+      // Act
+      const next = applyDetailEvent(detail, event);
+
+      // Assert — payload matches ⇒ unchanged task references and unchanged derived fields
+      expect(next.tasks["build"]).toBe(detail.tasks["build"]);
+      expect(next.tasks["test"]).toBe(detail.tasks["test"]);
+      expect(next.progress).toBe(detail.progress);
+      expect(next.taskCount).toBe(detail.taskCount);
+      expect(next.doneCount).toBe(detail.doneCount);
+    });
+  });
+
+  describe("convergence (AC-10)", () => {
+    it("reducing a job:updated built from a fixture matches normalizing that fixture via adaptJobDetail", () => {
+      // Arrange — fixture designed so adaptBaseJob.progress and deriveProgress.progress agree
+      const fixture: JobWire = {
+        jobId: "job-1",
+        title: "My Job",
+        status: "running",
+        progress: 50,
+        createdAt: "2026-01-01T00:00:00.000Z",
+        updatedAt: "2026-01-02T00:00:00.000Z",
+        location: "current",
+        tasks: {
+          build: { state: "done" },
+          test: { state: "running" },
+        },
+        costsSummary: {
+          totalTokens: 100,
+          totalInputTokens: 60,
+          totalOutputTokens: 40,
+          totalCost: 0,
+          totalInputCost: 0,
+          totalOutputCost: 0,
+          estimatedCost: 0,
+          hasEstimated: false,
+          unavailableCost: 0,
+        },
+      };
+      const event: SseEvent = { type: "job:updated", data: fixture };
+
+      // Act
+      const refetched = adaptJobDetail({ ...fixture });
+      const reduced = applyDetailEvent(makeDetail("job-1"), event);
+
+      // Assert — convergence on the fields the refetch path also produces
+      expect(reduced.jobId).toBe(refetched.jobId);
+      expect(reduced.status).toBe(refetched.status);
+      expect(reduced.progress).toBe(refetched.progress);
+      expect(reduced.taskCount).toBe(refetched.taskCount);
+      expect(reduced.doneCount).toBe(refetched.doneCount);
+      expect(reduced.completedCount).toBe(refetched.completedCount);
+      expect(Object.keys(reduced.tasks).sort()).toEqual(Object.keys(refetched.tasks).sort());
+      for (const name of Object.keys(refetched.tasks)) {
+        expect(reduced.tasks[name]).toEqual(refetched.tasks[name]);
+      }
+    });
+
+    it("derives progress from the event's configured count, not the stale captured one (AC-10)", () => {
+      // Arrange — the detail was captured with a 2-task configured count, but the incoming
+      // job:updated carries a 4-task pipelineConfig (the detail endpoint enriches config via
+      // loadPipelineJson, so the wire config can legitimately differ from the value captured
+      // at load). Progress must converge on the event's config, exactly as a refetch would.
+      const prev: NormalizedJobDetail = {
+        ...makeDetail("job-1"),
+        pipelineConfig: { tasks: ["build", "test"] },
+        taskCount: 2,
+      };
+      const wire: JobWire = {
+        ...makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "done" },
+            test: { state: "running" },
+          },
+        }),
+        pipelineConfig: { tasks: ["build", "test", "lint", "deploy"] },
+      };
+      const event: SseEvent = { type: "job:updated", data: wire };
+
+      // Act
+      const reduced = applyDetailEvent(prev, event);
+      const refetched = adaptJobDetail({ ...wire });
+
+      // Assert — converges on the event's 4-task denominator: floor(1/4*100) = 25
+      expect(reduced.taskCount).toBe(4);
+      expect(reduced.progress).toBe(25);
+      expect(reduced.taskCount).toBe(refetched.taskCount);
+      expect(reduced.progress).toBe(refetched.progress);
+      expect(reduced.doneCount).toBe(refetched.doneCount);
+      expect(reduced.completedCount).toBe(refetched.completedCount);
+    });
+  });
+
+  describe("non-job:updated events are no-ops (AC-11)", () => {
+    it("returns the same detail reference for heartbeat, state:change, state:summary, seed:uploaded, job:removed, and job:created", () => {
+      // Arrange
+      const detail = makeDetail("job-1");
+      const heartbeat: SseEvent = {
+        type: "heartbeat",
+        data: { ok: true, timestamp: "2026-06-21T00:00:00.000Z" },
+      };
+      const stateChange: SseEvent = {
+        type: "state:change",
+        data: { jobId: "job-1", path: "pipeline-data/current/job-1/tasks-status.json" },
+      };
+      const stateSummary: SseEvent = { type: "state:summary", data: { changeCount: 1 } };
+      const seedUploaded: SseEvent = { type: "seed:uploaded", data: {} };
+      const jobRemoved: SseEvent = { type: "job:removed", data: { jobId: "job-1" } };
+      const jobCreated: SseEvent = {
+        type: "job:created",
+        data: makeJobWire({ jobId: "job-1" }),
+      };
+
+      // Act + Assert
+      expect(applyDetailEvent(detail, heartbeat)).toBe(detail);
+      expect(applyDetailEvent(detail, stateChange)).toBe(detail);
+      expect(applyDetailEvent(detail, stateSummary)).toBe(detail);
+      expect(applyDetailEvent(detail, seedUploaded)).toBe(detail);
+      expect(applyDetailEvent(detail, jobRemoved)).toBe(detail);
+      expect(applyDetailEvent(detail, jobCreated)).toBe(detail);
+    });
+  });
+
+  describe("deriveProgress is the only progress formula (AC-7)", () => {
+    it("computes progress against the configured task count, not the current task list length", () => {
+      // Arrange — configured pipeline has 6 tasks, only 2 are recorded; one is "done".
+      // adaptBaseJob.progress would be floor(1/6*100) = 16; deriveProgress returns 16 too here,
+      // so to differentiate we instead assert the larger configured denominator wins even when
+      // tasks.length is greater than configuredCount.
+      const detail: NormalizedJobDetail = {
+        ...makeDetail("job-1"),
+        pipelineConfig: { tasks: ["build", "test", "extra1", "extra2", "extra3", "extra4"] },
+        taskCount: 6,
+        doneCount: 0,
+        progress: 0,
+      };
+      const event: SseEvent = {
+        type: "job:updated",
+        data: makeJobWire({
+          jobId: "job-1",
+          tasks: {
+            build: { state: "done" },
+            test: { state: "pending" },
+            extra1: { state: "pending" },
+            extra2: { state: "pending" },
+            extra3: { state: "pending" },
+            extra4: { state: "pending" },
+          },
+        }),
+      };
+
+      // Act
+      const next = applyDetailEvent(detail, event);
+
+      // Assert — deriveProgress: max(6, 6) = 6 taskCount; completed = 1; progress = floor(1/6*100) = 16
+      expect(next.taskCount).toBe(6);
+      expect(next.doneCount).toBe(1);
+      expect(next.progress).toBe(16);
+    });
+  });
+});

package/src/ui/client/reducers/job-events.ts

@@ -0,0 +1,137 @@
+import { deriveProgress } from "../../../core/job-view.ts";
+import type { SseEvent } from "../../../config/sse-events.ts";
+import { adaptJobDetail, adaptJobSummary } from "../adapters/job-adapter.ts";
+import type { NormalizedJobDetail, NormalizedJobSummary, NormalizedTask } from "../types.ts";
+
+function sortNormalizedJobs(jobs: NormalizedJobSummary[]): NormalizedJobSummary[] {
+  const priority: Record<string, number> = {
+    running: 4,
+    waiting: 4,
+    failed: 3,
+    pending: 2,
+    complete: 1,
+  };
+
+  return jobs.slice().sort((left, right) => {
+    const statusOrder = (priority[right.status] ?? 0) - (priority[left.status] ?? 0);
+    if (statusOrder !== 0) return statusOrder;
+    const leftCreated = left.createdAt ?? "";
+    const rightCreated = right.createdAt ?? "";
+    const createdOrder = leftCreated.localeCompare(rightCreated);
+    if (createdOrder !== 0) return createdOrder;
+    return left.jobId.localeCompare(right.jobId);
+  });
+}
+
+function completedCountFromTasks(job: NormalizedJobSummary): number {
+  return deriveProgress(Object.values(job.tasks), null).completedCount;
+}
+
+function comparableJob(job: NormalizedJobSummary): Record<string, unknown> {
+  const comparable: Record<string, unknown> = { ...job };
+  for (const [key, value] of Object.entries(comparable)) {
+    if (value === undefined) delete comparable[key];
+  }
+  if (comparable["completedCount"] === completedCountFromTasks(job)) {
+    delete comparable["completedCount"];
+  }
+  return comparable;
+}
+
+function jobsEqual(left: NormalizedJobSummary[], right: NormalizedJobSummary[]): boolean {
+  return JSON.stringify(left.map(comparableJob)) === JSON.stringify(right.map(comparableJob));
+}
+
+function mergeJob(current: NormalizedJobSummary, incoming: NormalizedJobSummary): NormalizedJobSummary {
+  return {
+    ...current,
+    ...incoming,
+    id: incoming.id || current.id,
+    jobId: incoming.jobId || current.jobId,
+    name: incoming.name || current.name,
+    createdAt: incoming.createdAt ?? current.createdAt,
+    updatedAt: incoming.updatedAt ?? current.updatedAt,
+    pipeline: incoming.pipeline ?? current.pipeline,
+    pipelineLabel: incoming.pipelineLabel ?? current.pipelineLabel,
+    current: incoming.current ?? current.current,
+    currentStage: incoming.currentStage ?? current.currentStage,
+  };
+}
+
+export function applyJobEvent(
+  jobs: NormalizedJobSummary[],
+  event: SseEvent,
+): NormalizedJobSummary[] {
+  if (event.type === "job:removed") {
+    const key = event.data.jobId;
+    const next = jobs.filter((job) => job.jobId !== key);
+    return jobsEqual(next, jobs) ? jobs : sortNormalizedJobs(next);
+  }
+
+  if (event.type === "job:created" || event.type === "job:updated") {
+    const incoming = adaptJobSummary(event.data);
+    const key = incoming.jobId;
+    const existingIndex = jobs.findIndex((job) => job.jobId === key);
+    const next = existingIndex === -1
+      ? [...jobs, incoming]
+      : jobs.map((job, index) => index === existingIndex ? mergeJob(job, incoming) : job);
+    const sorted = sortNormalizedJobs(next);
+    return jobsEqual(sorted, jobs) ? jobs : sorted;
+  }
+
+  return jobs;
+}
+
+function getConfiguredTaskCount(detail: NormalizedJobDetail): number | null {
+  const config = detail.pipelineConfig;
+  if (config && Array.isArray(config["tasks"])) return config["tasks"].length;
+  return null;
+}
+
+function tasksEqual(left: NormalizedTask, right: NormalizedTask): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function detailsDeepEqual(left: NormalizedJobDetail, right: NormalizedJobDetail): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export function applyDetailEvent(
+  detail: NormalizedJobDetail,
+  event: SseEvent,
+): NormalizedJobDetail {
+  if (event.type !== "job:updated") return detail;
+  if (event.data.jobId !== detail.jobId) return detail;
+
+  const merged = { ...detail, ...event.data } as Record<string, unknown>;
+  const adapted = adaptJobDetail(merged);
+
+  const preservedTasks: Record<string, NormalizedTask> = {};
+  let tasksChanged = false;
+  for (const [name, nextTask] of Object.entries(adapted.tasks)) {
+    const prevTask = detail.tasks[name];
+    if (prevTask !== undefined && tasksEqual(prevTask, nextTask)) {
+      preservedTasks[name] = prevTask;
+    } else {
+      preservedTasks[name] = nextTask;
+      tasksChanged = true;
+    }
+  }
+
+  const derived = deriveProgress(Object.values(preservedTasks), getConfiguredTaskCount(adapted));
+
+  const candidate: NormalizedJobDetail = {
+    ...adapted,
+    tasks: preservedTasks,
+    taskCount: derived.taskCount,
+    doneCount: derived.doneCount,
+    completedCount: derived.completedCount,
+    progress: derived.progress,
+  };
+
+  if (!tasksChanged && detailsDeepEqual(candidate, detail)) {
+    return detail;
+  }
+
+  return candidate;
+}