@ryanfw/prompt-orchestration-pipeline 1.2.7 → 1.2.9

package/src/core/status-writer.ts

@@ -14,6 +14,7 @@ export interface TaskEntry {
   failedStage?: string;
   error?: string;
   attempts?: number;
+  restartCount?: number;
   refinementAttempts?: number;
   tokenUsage?: unknown[];
   startedAt?: string;
@@ -227,6 +228,7 @@ export function resetJobFromTask(jobDir: string, fromTask: string, options?: Res
       delete task.failedStage;
       delete task.error;
       task.attempts = 0;
+      task.restartCount = 0;
       task.refinementAttempts = 0;
       if (options?.clearTokenUsage !== false) {
         task.tokenUsage = [];
@@ -253,6 +255,7 @@ export function resetJobToCleanSlate(jobDir: string, options?: ResetOptions): Pr
       delete task.failedStage;
       delete task.error;
       task.attempts = 0;
+      task.restartCount = 0;
       task.refinementAttempts = 0;
       if (options?.clearTokenUsage !== false) {
         task.tokenUsage = [];
@@ -280,6 +283,7 @@ export function resetSingleTask(jobDir: string, taskId: string, options?: ResetO
     delete task.failedStage;
     delete task.error;
     task.attempts = 0;
+    task.restartCount = 0;
     task.refinementAttempts = 0;
     if (options?.clearTokenUsage !== false) {
       task.tokenUsage = [];

package/src/core/task-runner.ts

@@ -795,7 +795,7 @@ export async function runPipeline(
 
   // Write done status (best-effort)
   try {
-    const lastStage = KNOWN_STAGES[KNOWN_STAGES.length - 1]!;
+    const lastStage = KNOWN_STAGES.at(-1)!;
     const doneProgress = computeDeterministicProgress(
       pipelineTasks ?? [taskName],
       taskName,

package/src/providers/__tests__/base.test.ts

@@ -165,7 +165,7 @@ describe("isRetryableError", () => {
 });
 
 describe("DEFAULT_REQUEST_TIMEOUT_MS", () => {
-  it("is 3 600 000 ms", () => {
+  it("is 1 hour (3 600 000 ms)", () => {
     expect(DEFAULT_REQUEST_TIMEOUT_MS).toBe(3_600_000);
   });
 });

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

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-import { restartJob, stopJob } from "../api";
+import { fetchConcurrencyStatus, restartJob, startTask, stopJob } from "../api";
+import type { JobConcurrencyApiStatus } from "../types";
 
 const fetchMock = vi.fn<typeof fetch>();
 const originalFetch = globalThis.fetch;
@@ -43,6 +44,46 @@ describe("ui client api", () => {
     });
   });
 
+  it("preserves concurrency_limit_reached on restart and surfaces capacity message", async () => {
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          ok: false,
+          code: "concurrency_limit_reached",
+          message: "concurrency limit reached",
+        }),
+        { status: 409 },
+      ),
+    );
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    await expect(restartJob("job-1")).rejects.toMatchObject({
+      code: "concurrency_limit_reached",
+      status: 409,
+      message: "Capacity reached. Wait for a job to finish, then try again.",
+    });
+  });
+
+  it("preserves concurrency_limit_reached on task start and surfaces capacity message", async () => {
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          ok: false,
+          code: "concurrency_limit_reached",
+          message: "concurrency limit reached",
+        }),
+        { status: 409 },
+      ),
+    );
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    await expect(startTask("job-1", "task-1")).rejects.toMatchObject({
+      code: "concurrency_limit_reached",
+      status: 409,
+      message: "Capacity reached. Wait for a job to finish, then try again.",
+    });
+  });
+
   it("returns ok responses for stop", async () => {
     fetchMock.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
     globalThis.fetch = fetchMock as unknown as typeof fetch;
@@ -59,4 +100,63 @@ describe("ui client api", () => {
       message: "offline",
     });
   });
+
+  describe("fetchConcurrencyStatus", () => {
+    const sampleStatus: JobConcurrencyApiStatus = {
+      limit: 3,
+      runningCount: 1,
+      availableSlots: 2,
+      queuedCount: 1,
+      activeJobs: [
+        { jobId: "job-1", pid: 1234, acquiredAt: "2024-01-01T00:00:00Z", source: "orchestrator" },
+      ],
+      queuedJobs: [
+        { jobId: "job-2", queuedAt: "2024-01-01T00:00:01Z", name: "second", pipeline: "demo" },
+      ],
+      staleSlots: [],
+    };
+
+    it("parses a successful response and unwraps data", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: true, data: sampleStatus }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(fetchConcurrencyStatus()).resolves.toEqual(sampleStatus);
+      expect(fetchMock).toHaveBeenCalledWith("/api/concurrency", expect.objectContaining({}));
+    });
+
+    it("maps network failures to network_error", async () => {
+      fetchMock.mockRejectedValue(new Error("offline"));
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(fetchConcurrencyStatus()).rejects.toMatchObject({
+        code: "network_error",
+        message: "offline",
+      });
+    });
+
+    it("propagates abort signals to fetch", async () => {
+      fetchMock.mockImplementation((_url, init) => {
+        return new Promise((_resolve, reject) => {
+          const signal = (init as RequestInit | undefined)?.signal;
+          if (signal?.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+          }
+          signal?.addEventListener("abort", () => {
+            reject(new DOMException("Aborted", "AbortError"));
+          });
+        });
+      });
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      const controller = new AbortController();
+      const promise = fetchConcurrencyStatus(controller.signal);
+      controller.abort();
+
+      await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+      expect(fetchMock.mock.calls[0]?.[1]?.signal).toBe(controller.signal);
+    });
+  });
 });

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

@@ -30,6 +30,18 @@ describe("job adapter", () => {
     expect(normalizeTasks(null)).toEqual({});
   });
 
+  it("maps numeric restartCount onto the normalized task", () => {
+    expect(normalizeTasks({ t1: { state: "done", restartCount: 2 } })["t1"]?.restartCount).toBe(2);
+  });
+
+  it("treats null restartCount as undefined", () => {
+    expect(normalizeTasks({ t1: { state: "done", restartCount: null } })["t1"]?.restartCount).toBeUndefined();
+  });
+
+  it("leaves restartCount undefined when absent", () => {
+    expect(normalizeTasks({ t1: { state: "done" } })["t1"]?.restartCount).toBeUndefined();
+  });
+
   it("adapts summary jobs with defaults", () => {
     const job = adaptJobSummary({
       jobId: "job-1",

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

@@ -0,0 +1,126 @@
+import "../../components/__tests__/test-dom";
+
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+
+import { useConcurrencyStatus } from "../hooks/useConcurrencyStatus";
+import type { JobConcurrencyApiStatus } from "../types";
+
+const originalFetch = globalThis.fetch;
+const originalEventSource = globalThis.EventSource;
+
+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 = [];
+  }
+}
+
+const sampleStatus: JobConcurrencyApiStatus = {
+  limit: 3,
+  runningCount: 0,
+  availableSlots: 3,
+  queuedCount: 0,
+  activeJobs: [],
+  queuedJobs: [],
+  staleSlots: [],
+};
+
+function makeStatus(overrides: Partial<JobConcurrencyApiStatus> = {}): JobConcurrencyApiStatus {
+  return { ...sampleStatus, ...overrides };
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status });
+}
+
+describe("useConcurrencyStatus", () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    globalThis.EventSource = originalEventSource;
+    MockEventSource.reset();
+    vi.restoreAllMocks();
+  });
+
+  it("populates data after the initial fetch", async () => {
+    const status = makeStatus({ runningCount: 1, availableSlots: 2 });
+    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
+      jsonResponse({ ok: true, data: status }),
+    ) as unknown as typeof fetch;
+    globalThis.EventSource = MockEventSource as unknown as typeof EventSource;
+
+    const { result } = renderHook(() => useConcurrencyStatus());
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.data).toEqual(status);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("refetches on state:summary SSE events", async () => {
+    const first = makeStatus({ runningCount: 1 });
+    const second = makeStatus({ runningCount: 2 });
+    const fetchMock = vi.fn<typeof fetch>()
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: first }))
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: second }));
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+    globalThis.EventSource = MockEventSource as unknown as typeof EventSource;
+
+    const { result } = renderHook(() => useConcurrencyStatus());
+
+    await waitFor(() => expect(result.current.data).toEqual(first));
+
+    act(() => {
+      MockEventSource.instances[0]?.emit("state:summary", { ok: true });
+    });
+
+    await waitFor(() => expect(result.current.data).toEqual(second));
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("aborts the in-flight request on unmount", async () => {
+    let capturedSignal: AbortSignal | undefined;
+    const fetchMock = vi.fn<typeof fetch>().mockImplementation((_url, init) => {
+      capturedSignal = (init as RequestInit | undefined)?.signal ?? undefined;
+      return new Promise((_resolve, reject) => {
+        capturedSignal?.addEventListener("abort", () => {
+          reject(new DOMException("Aborted", "AbortError"));
+        });
+      });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+    globalThis.EventSource = MockEventSource as unknown as typeof EventSource;
+
+    const { unmount } = renderHook(() => useConcurrencyStatus());
+
+    expect(capturedSignal?.aborted).toBe(false);
+    unmount();
+    expect(capturedSignal?.aborted).toBe(true);
+    expect(MockEventSource.instances[0]?.closed).toBe(true);
+  });
+});

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

@@ -49,6 +49,7 @@ function normalizeTask(name: string, rawTask: unknown): NormalizedTask {
     startedAt: toStringOrNull(task["startedAt"]),
     endedAt: toStringOrNull(task["endedAt"]),
     attempts: typeof task["attempts"] === "number" ? task["attempts"] : undefined,
+    restartCount: typeof task["restartCount"] === "number" ? task["restartCount"] : undefined,
     executionTimeMs: typeof task["executionTimeMs"] === "number" ? task["executionTimeMs"] : undefined,
     currentStage: typeof task["currentStage"] === "string" ? task["currentStage"] : undefined,
     failedStage: typeof task["failedStage"] === "string" ? task["failedStage"] : undefined,

package/src/ui/client/api.ts

@@ -2,9 +2,12 @@ import type {
   ApiError,
   ApiErrorCode,
   ApiOkResponse,
+  JobConcurrencyApiStatus,
   RestartJobOptions,
 } from "./types";
 
+const CONCURRENCY_LIMIT_MESSAGE = "Capacity reached. Wait for a job to finish, then try again.";
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
@@ -22,10 +25,12 @@ function normalizeBackendErrorCode(errorData: unknown, status: number): ApiError
     code === "spawn_failed" ||
     code === "unknown_error" ||
     code === "network_error" ||
+    code === "malformed_response" ||
     code === "dependencies_not_satisfied" ||
     code === "unsupported_lifecycle" ||
     code === "task_not_found" ||
-    code === "task_not_pending"
+    code === "task_not_pending" ||
+    code === "concurrency_limit_reached"
   ) {
     return code;
   }
@@ -45,6 +50,10 @@ function getMessage(value: unknown): string | null {
   return typeof value["message"] === "string" ? value["message"] : null;
 }
 
+function hasBackendCode(errorData: unknown, code: string): boolean {
+  return isRecord(errorData) && errorData["code"] === code;
+}
+
 export function getErrorCodeFromStatus(status: number): ApiErrorCode {
   if (status === 404) return "job_not_found";
   if (status === 409) return "conflict";
@@ -66,25 +75,31 @@ export function getErrorMessageFromStatus(status: number): string {
 }
 
 export function getRestartErrorMessage(errorData: unknown, status: number): string {
-  if (isRecord(errorData) && errorData["code"] === "job_running") {
+  if (hasBackendCode(errorData, "job_running")) {
     return "Cannot restart a job while it is still running";
   }
-  if (isRecord(errorData) && errorData["code"] === "spawn_failed") {
+  if (hasBackendCode(errorData, "spawn_failed")) {
     return "Failed to spawn the restarted job";
   }
+  if (hasBackendCode(errorData, "concurrency_limit_reached")) {
+    return CONCURRENCY_LIMIT_MESSAGE;
+  }
   return getMessage(errorData) ?? getErrorMessageFromStatus(status);
 }
 
 export function getStartTaskErrorMessage(errorData: unknown, status: number): string {
-  if (isRecord(errorData) && errorData["code"] === "dependencies_not_satisfied") {
+  if (hasBackendCode(errorData, "dependencies_not_satisfied")) {
     return "Cannot start task before its dependencies are complete";
   }
-  if (isRecord(errorData) && errorData["code"] === "task_not_found") {
+  if (hasBackendCode(errorData, "task_not_found")) {
     return "Task not found";
   }
-  if (isRecord(errorData) && errorData["code"] === "task_not_pending") {
+  if (hasBackendCode(errorData, "task_not_pending")) {
     return "Only pending tasks can be started";
   }
+  if (hasBackendCode(errorData, "concurrency_limit_reached")) {
+    return CONCURRENCY_LIMIT_MESSAGE;
+  }
   return getMessage(errorData) ?? getErrorMessageFromStatus(status);
 }
 
@@ -101,7 +116,8 @@ export function getStopErrorMessage(errorData: unknown, status: number): string
 async function parseJson(response: Response): Promise<unknown> {
   try {
     return await response.json();
-  } catch {
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
     return null;
   }
 }
@@ -170,3 +186,57 @@ export async function startTask(jobId: string, taskId: string): Promise<ApiOkRes
 export async function stopJob(jobId: string): Promise<ApiOkResponse> {
   return postJson(`/api/jobs/${jobId}/stop`, {}, getStopErrorMessage);
 }
+
+export async function fetchConcurrencyStatus(
+  signal?: AbortSignal,
+): Promise<JobConcurrencyApiStatus> {
+  let response: Response;
+  let payload: unknown;
+
+  try {
+    response = await fetch("/api/concurrency", { signal });
+    if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+    payload = await parseJson(response);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw {
+      code: "network_error",
+      message: error instanceof Error ? error.message : "Network request failed",
+    } satisfies ApiError;
+  }
+
+  if (!response.ok) {
+    throw toApiError(
+      response.status,
+      getMessage(payload) ?? getErrorMessageFromStatus(response.status),
+      payload,
+    );
+  }
+
+  if (
+    isRecord(payload) &&
+    payload["ok"] === true &&
+    isJobConcurrencyApiStatus(payload["data"])
+  ) {
+    return payload["data"];
+  }
+
+  throw {
+    code: "malformed_response",
+    message: "Malformed concurrency status response",
+    status: response.status,
+  } satisfies ApiError;
+}
+
+function isJobConcurrencyApiStatus(value: unknown): value is JobConcurrencyApiStatus {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value["limit"] === "number" &&
+    typeof value["runningCount"] === "number" &&
+    typeof value["availableSlots"] === "number" &&
+    typeof value["queuedCount"] === "number" &&
+    Array.isArray(value["activeJobs"]) &&
+    Array.isArray(value["queuedJobs"]) &&
+    Array.isArray(value["staleSlots"])
+  );
+}

package/src/ui/client/hooks/useConcurrencyStatus.ts

@@ -0,0 +1,102 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import { fetchConcurrencyStatus } from "../api";
+import type {
+  ApiError,
+  JobConcurrencyApiStatus,
+  UseConcurrencyStatusResult,
+} from "../types";
+
+const REFETCH_EVENTS = ["state:summary", "state:change"] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function toApiError(error: unknown): ApiError {
+  if (isRecord(error) && typeof error["code"] === "string" && typeof error["message"] === "string") {
+    return {
+      code: error["code"] as ApiError["code"],
+      message: error["message"],
+      status: typeof error["status"] === "number" ? error["status"] : undefined,
+    };
+  }
+  return {
+    code: "unknown_error",
+    message: error instanceof Error ? error.message : "Failed to load concurrency status",
+  };
+}
+
+export function useConcurrencyStatus(): UseConcurrencyStatusResult {
+  const [loading, setLoading] = useState(true);
+  const [data, setData] = useState<JobConcurrencyApiStatus | null>(null);
+  const [error, setError] = useState<ApiError | null>(null);
+  const abortRef = useRef<AbortController | null>(null);
+  const dataRef = useRef<JobConcurrencyApiStatus | null>(null);
+  const mountedRef = useRef(true);
+  const refetchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const load = useCallback((showLoading = false) => {
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    if (showLoading || dataRef.current === null) setLoading(true);
+
+    void fetchConcurrencyStatus(controller.signal)
+      .then((status) => {
+        if (!mountedRef.current || abortRef.current !== controller) return;
+        dataRef.current = status;
+        setData(status);
+        setError(null);
+      })
+      .catch((fetchError) => {
+        if (fetchError instanceof DOMException && fetchError.name === "AbortError") return;
+        if (!mountedRef.current || abortRef.current !== controller) return;
+        setError(toApiError(fetchError));
+      })
+      .finally(() => {
+        if (!mountedRef.current || abortRef.current !== controller) return;
+        setLoading(false);
+      });
+  }, []);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    load(true);
+
+    const source = new EventSource("/api/events");
+    const onMessage = () => {
+      if (refetchTimerRef.current) return;
+      refetchTimerRef.current = setTimeout(() => {
+        refetchTimerRef.current = null;
+        load(false);
+      }, 0);
+    };
+    for (const eventName of REFETCH_EVENTS) {
+      source.addEventListener(eventName, onMessage as EventListener);
+    }
+    source.onerror = () => {
+      if (!mountedRef.current) return;
+      setError({
+        code: "network_error",
+        message: "Live concurrency updates disconnected",
+      });
+    };
+
+    return () => {
+      mountedRef.current = false;
+      if (refetchTimerRef.current) {
+        clearTimeout(refetchTimerRef.current);
+        refetchTimerRef.current = null;
+      }
+      abortRef.current?.abort();
+      source.close();
+    };
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    load(true);
+  }, [load]);
+
+  return { loading, data, error, refetch };
+}

package/src/ui/client/types.ts

@@ -5,10 +5,12 @@ export type ApiErrorCode =
   | "spawn_failed"
   | "unknown_error"
   | "network_error"
+  | "malformed_response"
   | "dependencies_not_satisfied"
   | "unsupported_lifecycle"
   | "task_not_found"
-  | "task_not_pending";
+  | "task_not_pending"
+  | "concurrency_limit_reached";
 
 export interface ApiError {
   code: ApiErrorCode;
@@ -89,6 +91,7 @@ export interface NormalizedTask {
   startedAt: string | null;
   endedAt: string | null;
   attempts?: number;
+  restartCount?: number;
   executionTimeMs?: number;
   currentStage?: string;
   failedStage?: string;
@@ -184,6 +187,36 @@ export interface AllowedActions {
   restart: boolean;
 }
 
+export interface JobConcurrencyApiStatus {
+  limit: number;
+  runningCount: number;
+  availableSlots: number;
+  queuedCount: number;
+  activeJobs: Array<{
+    jobId: string;
+    pid: number | null;
+    acquiredAt: string;
+    source: "orchestrator" | "restart" | "task-start";
+  }>;
+  queuedJobs: Array<{
+    jobId: string;
+    queuedAt: string | null;
+    name: string | null;
+    pipeline: string | null;
+  }>;
+  staleSlots: Array<{
+    jobId: string;
+    reason: "missing_current_job" | "missing_pid" | "dead_pid" | "invalid_json";
+  }>;
+}
+
+export interface UseConcurrencyStatusResult {
+  loading: boolean;
+  data: JobConcurrencyApiStatus | null;
+  error: ApiError | null;
+  refetch: () => void;
+}
+
 export interface SseJobEvent {
   type: SseEventType;
   data: Record<string, unknown>;

package/src/ui/components/DAGGrid.tsx

@@ -276,7 +276,17 @@ export default function DAGGrid({
                 data-role="card-header"
                 className={`flex items-center justify-between gap-3 rounded-t-lg border-b px-4 py-2 ${reducedMotion ? "" : "transition-opacity duration-300 ease-in-out"} ${getHeaderClasses(getItemStatus(items[index], index, activeIndex))}`}
               >
-                <div className="truncate font-medium">{items[index]?.title ?? formatStepName(items[index]?.id ?? "")}</div>
+                {(items[index]?.restartCount ?? 0) > 0 ? (
+                  <span
+                    data-role="restart-badge"
+                    className="inline-flex items-center justify-center min-w-[20px] h-5 px-1.5 rounded-sm border border-red-300 bg-red-50 text-red-700 text-[11px] font-medium tabular-nums"
+                    title={`Restarted ${items[index]!.restartCount} time${items[index]!.restartCount === 1 ? "" : "s"}`}
+                    aria-label={`Restarted ${items[index]!.restartCount} time${items[index]!.restartCount === 1 ? "" : "s"}`}
+                  >
+                    ↻ {items[index]!.restartCount}
+                  </span>
+                ) : null}
+                <div className="min-w-0 flex-1 truncate text-left font-medium">{items[index]?.title ?? formatStepName(items[index]?.id ?? "")}</div>
                 <div className="flex items-center gap-2">
                   {getItemStatus(items[index], index, activeIndex) === "running" ? (
                     <>

package/src/ui/components/JobDetail.tsx

@@ -43,7 +43,8 @@ export default function JobDetail({
         prior.stage === item.stage &&
         prior.title === item.title &&
         prior.subtitle === item.subtitle &&
-        prior.body === item.body
+        prior.body === item.body &&
+        prior.restartCount === item.restartCount
       ) {
         return prior;
       }