@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -1,3 +1,4 @@
+import { deriveProgress } from "../../../core/job-view.ts";
 import { deriveJobStatusFromTasks, normalizeJobStatus, normalizeTaskState } from "../../../config/statuses";
 import type {
   AllowedActions,
@@ -19,6 +20,9 @@ const EMPTY_COSTS: CostsSummary = {
   totalCost: 0,
   totalInputCost: 0,
   totalOutputCost: 0,
+  estimatedCost: 0,
+  hasEstimated: false,
+  unavailableCost: 0,
 };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -50,10 +54,14 @@ function normalizeGate(value: unknown): GateInfo | null | undefined {
     ? value["artifacts"].filter((artifact): artifact is string => typeof artifact === "string")
     : undefined;
 
+  const rawKind = value["kind"];
+  const kind = rawKind === "approval" || rawKind === "control_invalid" ? rawKind : undefined;
+
   return {
     afterTask: typeof value["afterTask"] === "string" ? value["afterTask"] : "",
     message: typeof value["message"] === "string" ? value["message"] : "",
     requestedAt: typeof value["requestedAt"] === "string" ? value["requestedAt"] : "",
+    ...(kind ? { kind } : {}),
     ...(artifacts && artifacts.length > 0 ? { artifacts } : {}),
   };
 }
@@ -108,6 +116,14 @@ function getWarnings(rawTasks: unknown): string[] {
   return ["Unsupported task collection shape"];
 }
 
+function isErrorShape(value: unknown): value is { code: string; message: string; path?: string } {
+  if (!isRecord(value)) return false;
+  if (typeof value["code"] !== "string") return false;
+  if (typeof value["message"] !== "string") return false;
+  if ("path" in value && typeof value["path"] !== "string") return false;
+  return true;
+}
+
 function normalizeCostsSummary(costs: unknown): CostsSummary {
   if (!isRecord(costs)) return EMPTY_COSTS;
   return {
@@ -117,6 +133,9 @@ function normalizeCostsSummary(costs: unknown): CostsSummary {
     totalCost: toNumber(costs["totalCost"]),
     totalInputCost: toNumber(costs["totalInputCost"]),
     totalOutputCost: toNumber(costs["totalOutputCost"]),
+    estimatedCost: toNumber(costs["estimatedCost"]),
+    hasEstimated: typeof costs["hasEstimated"] === "boolean" ? costs["hasEstimated"] : false,
+    unavailableCost: toNumber(costs["unavailableCost"]),
   };
 }
 
@@ -124,13 +143,24 @@ function normalizeCostBreakdown(costs: unknown): Record<string, TaskCostBreakdow
   if (!isRecord(costs)) return undefined;
   const entries = Object.entries(costs).flatMap(([name, value]) => {
     if (!isRecord(value)) return [];
-    return [[name, {
+    const entry: TaskCostBreakdown = {
       inputTokens: toNumber(value["inputTokens"]),
       outputTokens: toNumber(value["outputTokens"]),
       inputCost: toNumber(value["inputCost"]),
       outputCost: toNumber(value["outputCost"]),
       totalCost: toNumber(value["totalCost"]),
-    } satisfies TaskCostBreakdown] as const];
+    };
+    const rawSource = value["source"];
+    if (rawSource === "reported" || rawSource === "estimated" || rawSource === "unavailable" || rawSource === "zero") {
+      entry.source = rawSource;
+    }
+    if (typeof value["failed"] === "boolean") {
+      entry.failed = value["failed"];
+    }
+    if (typeof value["costEstimated"] === "boolean") {
+      entry.costEstimated = value["costEstimated"];
+    }
+    return [[name, entry] as const];
   });
   return Object.fromEntries(entries);
 }
@@ -159,20 +189,13 @@ function adaptBaseJob(apiJob: Record<string, unknown>): NormalizedJobSummary {
   const rawTasks = apiJob["tasks"] ?? apiJob["tasksStatus"];
   const tasks = normalizeTasks(rawTasks);
   const taskList = Object.values(tasks);
-  const doneCount = taskList.filter((task) => task.state === "done").length;
-  const completedCount = taskList.filter((task) => isCompletedTaskState(task.state)).length;
   const rawPipelineConfig = isRecord(apiJob["pipelineConfig"]) ? apiJob["pipelineConfig"] : null;
-  const pipelineTaskArray = rawPipelineConfig && Array.isArray(rawPipelineConfig["tasks"])
-    ? rawPipelineConfig["tasks"] as unknown[]
+  const configuredCount = rawPipelineConfig && Array.isArray(rawPipelineConfig["tasks"])
+    ? (rawPipelineConfig["tasks"] as unknown[]).length
     : null;
-  const taskCount = pipelineTaskArray ? pipelineTaskArray.length : taskList.length;
+  const derived = deriveProgress(taskList, configuredCount);
   const inferredStatus = deriveJobStatusFromTasks(taskList);
   const status = normalizeJobStatus(apiJob["status"] ?? inferredStatus);
-  const progress = pipelineTaskArray
-    ? (taskCount === 0 ? 0 : Math.min(100, Math.floor((completedCount / taskCount) * 100)))
-    : typeof apiJob["progress"] === "number"
-      ? apiJob["progress"]
-      : taskCount === 0 ? 0 : Math.min(100, Math.floor((completedCount / taskCount) * 100));
 
   return {
     id: typeof apiJob["id"] === "string" ? apiJob["id"] : String(apiJob["jobId"] ?? ""),
@@ -181,10 +204,10 @@ function adaptBaseJob(apiJob: Record<string, unknown>): NormalizedJobSummary {
       ? apiJob["name"]
       : typeof apiJob["title"] === "string" ? apiJob["title"] : "",
     status,
-    progress,
-    taskCount,
-    doneCount,
-    completedCount,
+    progress: derived.progress,
+    taskCount: derived.taskCount,
+    doneCount: derived.doneCount,
+    completedCount: derived.completedCount,
     location: typeof apiJob["location"] === "string" ? apiJob["location"] : "current",
     tasks,
     current: normalizeCurrent(apiJob["current"]),
@@ -202,6 +225,8 @@ function adaptBaseJob(apiJob: Record<string, unknown>): NormalizedJobSummary {
     totalTokens: toNumber(apiJob["totalTokens"], normalizeCostsSummary(apiJob["costsSummary"]).totalTokens),
     displayCategory: getDisplayCategory(status),
     __warnings: getWarnings(rawTasks),
+    ...(typeof apiJob["readable"] === "boolean" ? { readable: apiJob["readable"] } : {}),
+    ...(isErrorShape(apiJob["error"]) ? { error: apiJob["error"] } : {}),
   };
 }
 

package/src/ui/client/api.ts

@@ -201,14 +201,22 @@ export async function decideGate(
   ) as Promise<GateDecisionResponse>;
 }
 
-export async function fetchConcurrencyStatus(
-  signal?: AbortSignal,
-): Promise<JobConcurrencyApiStatus> {
+export async function getJson<T>(
+  url: string,
+  opts?: {
+    signal?: AbortSignal;
+    validate?: (data: unknown) => data is T;
+    malformedMessage?: string;
+  },
+): Promise<T> {
+  const signal = opts?.signal;
+  if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+
   let response: Response;
   let payload: unknown;
 
   try {
-    response = await fetch("/api/concurrency", { signal });
+    response = await fetch(url, { signal });
     if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
     payload = await parseJson(response);
   } catch (error) {
@@ -227,19 +235,34 @@ export async function fetchConcurrencyStatus(
     );
   }
 
-  if (
-    isRecord(payload) &&
-    payload["ok"] === true &&
-    isJobConcurrencyApiStatus(payload["data"])
-  ) {
-    return payload["data"];
+  if (!isRecord(payload) || payload["ok"] !== true) {
+    throw {
+      code: "malformed_response",
+      message: opts?.malformedMessage ?? "Malformed response",
+      status: response.status,
+    } satisfies ApiError;
   }
 
-  throw {
-    code: "malformed_response",
-    message: "Malformed concurrency status response",
-    status: response.status,
-  } satisfies ApiError;
+  const data = payload["data"];
+  if (data === undefined || (opts?.validate && !opts.validate(data))) {
+    throw {
+      code: "malformed_response",
+      message: opts?.malformedMessage ?? "Malformed response",
+      status: response.status,
+    } satisfies ApiError;
+  }
+
+  return data as T;
+}
+
+export async function fetchConcurrencyStatus(
+  signal?: AbortSignal,
+): Promise<JobConcurrencyApiStatus> {
+  return getJson<JobConcurrencyApiStatus>("/api/concurrency", {
+    signal,
+    validate: isJobConcurrencyApiStatus,
+    malformedMessage: "Malformed concurrency status response",
+  });
 }
 
 function isJobConcurrencyApiStatus(value: unknown): value is JobConcurrencyApiStatus {

package/src/ui/client/bootstrap.ts

@@ -1,29 +1,34 @@
-import type { BootstrapOptions, SseEventType } from "./types";
+import { getJson } from "./api";
+import type { ApiError, BootstrapOptions, SseEventType } from "./types";
 
 const DEFAULT_STATE_URL = "/api/state";
 const DEFAULT_SSE_URL = "/api/events";
-const BOOTSTRAP_EVENTS: SseEventType[] = [
-  "state",
-  "job:updated",
+const BOOTSTRAP_EVENTS: readonly SseEventType[] = [
+  "state:change",
+  "state:summary",
   "job:created",
+  "job:updated",
   "job:removed",
   "heartbeat",
-  "message",
+  "seed:uploaded",
 ];
 
-async function parseJson(response: Response): Promise<unknown> {
-  try {
-    return await response.json();
-  } catch {
-    return null;
-  }
+function isApiError(value: unknown): value is ApiError {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { code?: unknown }).code === "string" &&
+    typeof (value as { message?: unknown }).message === "string"
+  );
 }
 
 async function loadSnapshot(stateUrl: string): Promise<unknown> {
   try {
-    const response = await fetch(stateUrl);
-    return await parseJson(response);
-  } catch {
+    return await getJson<unknown>(stateUrl);
+  } catch (error) {
+    if (isApiError(error)) {
+      console.warn("bootstrap: failed to load initial state", error);
+    }
     return null;
   }
 }

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

@@ -1,14 +1,19 @@
 import { useCallback, useEffect, useRef, useState, useTransition } from "react";
 
+import { parseSseEvent, type SseEvent } from "../../../config/sse-events.ts";
 import { adaptJobDetail } from "../adapters/job-adapter";
+import { getJson } from "../api";
+import { nextLoadState, type LoadState } from "../load-state";
+import { applyDetailEvent } from "../reducers/job-events.ts";
 import type {
+  ApiError,
   ConnectionStatus,
   NormalizedJobDetail,
-  NormalizedTask,
-  SseJobEvent,
   UseJobDetailWithUpdatesResult,
 } from "../types";
 
+export { applyDetailEvent };
+
 export const REFRESH_DEBOUNCE_MS = 200;
 export const POLL_INTERVAL_MS = 3_000;
 
@@ -16,18 +21,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
-export function extractJobDetail(payload: unknown): Record<string, unknown> | null {
-  if (isRecord(payload) && isRecord(payload["data"])) return payload["data"];
-  if (isRecord(payload)) return payload;
-  return null;
-}
-
-function getPipelineTaskCount(detail: NormalizedJobDetail): number | null {
-  const config = detail.pipelineConfig;
-  if (config && Array.isArray(config["tasks"])) return config["tasks"].length;
-  return null;
-}
-
 function getPipelineTaskNames(detail: NormalizedJobDetail): string[] {
   const config = detail.pipelineConfig;
   if (!config || !Array.isArray(config["tasks"])) return Object.keys(detail.tasks);
@@ -46,12 +39,7 @@ function sameTaskSet(left: string[], right: string[]): boolean {
   return left.every((taskName) => rightSet.has(taskName));
 }
 
-export function shouldRefetchDetailForTaskSet(detail: NormalizedJobDetail, event: SseJobEvent): boolean {
-  if (event.type === "task:updated") {
-    const taskName = typeof event.data["taskName"] === "string" ? event.data["taskName"] : null;
-    return taskName !== null && detail.tasks[taskName] === undefined;
-  }
-
+export function shouldRefetchDetailForTaskSet(detail: NormalizedJobDetail, event: SseEvent): boolean {
   if (event.type !== "job:updated") return false;
   const rawTasks = event.data["tasks"];
   if (!isRecord(rawTasks)) return false;
@@ -61,21 +49,6 @@ export function shouldRefetchDetailForTaskSet(detail: NormalizedJobDetail, event
   return !sameTaskSet(getPipelineTaskNames(detail), incomingTaskNames);
 }
 
-function recomputeProgress(detail: NormalizedJobDetail): NormalizedJobDetail {
-  const tasks = Object.values(detail.tasks);
-  const doneCount = tasks.filter((task) => task.state === "done").length;
-  const completedCount = tasks.filter((task) => task.state === "done" || task.state === "skipped").length;
-  const taskCount = getPipelineTaskCount(detail) ?? tasks.length;
-  return {
-    ...detail,
-    doneCount,
-    completedCount,
-    taskCount,
-    progress: taskCount === 0 ? 0 : Math.min(100, Math.floor((completedCount / taskCount) * 100)),
-    updatedAt: new Date().toISOString(),
-  };
-}
-
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -85,67 +58,72 @@ export function matchesJobTasksStatusPath(path: string, jobId: string): boolean
   return pattern.test(path);
 }
 
-export function applyDetailEvent(
-  detail: NormalizedJobDetail,
-  event: SseJobEvent,
-): NormalizedJobDetail {
-  const eventJobId = typeof event.data["jobId"] === "string" ? event.data["jobId"] : null;
-  if (eventJobId !== detail.jobId) return detail;
-
-  if (event.type === "job:updated") {
-    return adaptJobDetail({ ...detail, ...event.data });
+export type DetailMessageAction =
+  | { kind: "refetch" }
+  | { kind: "apply"; event: SseEvent }
+  | { kind: "skip" };
+
+export function handleDetailSseMessage(
+  type: string,
+  rawData: string,
+  jobId: string,
+): DetailMessageAction {
+  let parsedData: unknown;
+  try {
+    parsedData = JSON.parse(rawData);
+  } catch (error) {
+    console.warn("useJobDetailWithUpdates: failed to parse SSE payload", error);
+    return { kind: "refetch" };
   }
 
-  if (event.type === "task:updated") {
-    const taskName = typeof event.data["taskName"] === "string" ? event.data["taskName"] : null;
-    if (taskName === null) return detail;
-    const currentTask = detail.tasks[taskName];
-    if (!currentTask) return detail;
-
-    const nextTask: NormalizedTask = {
-      ...currentTask,
-      ...(isRecord(event.data["task"]) ? adaptJobDetail({
-        ...detail,
-        tasks: {
-          [taskName]: event.data["task"],
-        },
-      }).tasks[taskName] ?? currentTask : currentTask),
-    };
+  const event = parseSseEvent(type, parsedData);
+  if (event === null) {
+    console.warn(`useJobDetailWithUpdates: dropping invalid SSE event of type "${type}"`);
+    return { kind: "refetch" };
+  }
 
-    return recomputeProgress({
-      ...detail,
-      tasks: {
-        ...detail.tasks,
-        [taskName]: nextTask,
-      },
-    });
+  if (event.type === "state:change") {
+    return matchesJobTasksStatusPath(event.data.path, jobId)
+      ? { kind: "refetch" }
+      : { kind: "skip" };
   }
 
-  return detail;
+  return { kind: "apply", event };
 }
 
-async function fetchJobDetail(jobId: string, signal: AbortSignal): Promise<NormalizedJobDetail> {
-  const response = await fetch(`/api/jobs/${jobId}`, { signal });
-  const payload = extractJobDetail(await response.json());
-  return adaptJobDetail(payload ?? {});
+export async function fetchJobDetail(jobId: string, signal: AbortSignal): Promise<NormalizedJobDetail> {
+  const raw = await getJson<Record<string, unknown>>(`/api/jobs/${jobId}`, {
+    signal,
+    validate: isRecord,
+    malformedMessage: "Malformed job detail response",
+  });
+  return adaptJobDetail(raw);
 }
 
 export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesResult {
   const [data, setData] = useState<NormalizedJobDetail | null>(null);
   const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
+  const [error, setError] = useState<ApiError | null>(null);
   const [connectionStatus, setConnectionStatus] = useState<ConnectionStatus>("disconnected");
   const [isRefreshing, setIsRefreshing] = useState(false);
   const [isHydrated, setIsHydrated] = useState(false);
   const [isTransitioning, startTransition] = useTransition();
   const mountedRef = useRef(true);
   const dataRef = useRef<NormalizedJobDetail | null>(null);
+  const errorRef = useRef<ApiError | null>(null);
   const hydratedRef = useRef(false);
   const abortRef = useRef<AbortController | null>(null);
-  const queueRef = useRef<SseJobEvent[]>([]);
+  const queueRef = useRef<SseEvent[]>([]);
   const refetchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const refetchingRef = useRef(false);
 
+  const apply = (next: LoadState<NormalizedJobDetail>) => {
+    dataRef.current = next.data;
+    errorRef.current = next.error;
+    setData(next.data);
+    setError(next.error);
+  };
+
   const load = useCallback(() => {
     abortRef.current?.abort();
     const controller = new AbortController();
@@ -160,16 +138,20 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
         if (!mountedRef.current) return;
         const replayed = queueRef.current.reduce(applyDetailEvent, detail);
         queueRef.current = [];
-        dataRef.current = replayed;
+        apply(nextLoadState(
+          { data: dataRef.current, error: errorRef.current },
+          { ok: true, data: replayed },
+        ));
         hydratedRef.current = true;
-        setData(replayed);
-        setError(null);
         setIsHydrated(true);
       })
-      .catch((fetchError) => {
+      .catch((fetchError: unknown) => {
         if (fetchError instanceof DOMException && fetchError.name === "AbortError") return;
         if (!mountedRef.current) return;
-        setError(fetchError instanceof Error ? fetchError.message : "Failed to load job");
+        apply(nextLoadState(
+          { data: dataRef.current, error: errorRef.current },
+          { ok: false, error: fetchError as ApiError },
+        ));
       })
       .finally(() => {
         if (!mountedRef.current) return;
@@ -202,31 +184,21 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
     };
 
     const onMessage = (event: MessageEvent<string>) => {
-      let payload: SseJobEvent;
-      try {
-        payload = {
-          type: event.type as SseJobEvent["type"],
-          data: JSON.parse(event.data) as Record<string, unknown>,
-        };
-      } catch (parseError) {
-        console.warn("Failed to parse job detail SSE payload", parseError);
-        return;
-      }
+      const result = handleDetailSseMessage(event.type, event.data, jobId);
 
-      if (payload.type === "state:change") {
-        const path = typeof payload.data["path"] === "string" ? payload.data["path"] : "";
-        if (matchesJobTasksStatusPath(path, jobId)) {
-          scheduleRefetch();
-        }
+      if (result.kind === "refetch") {
+        scheduleRefetch();
         return;
       }
 
+      if (result.kind === "skip") return;
+
       if (!hydratedRef.current || refetchingRef.current || dataRef.current === null) {
-        queueRef.current.push(payload);
+        queueRef.current.push(result.event);
         return;
       }
 
-      if (shouldRefetchDetailForTaskSet(dataRef.current, payload)) {
+      if (shouldRefetchDetailForTaskSet(dataRef.current, result.event)) {
         scheduleRefetch();
         return;
       }
@@ -234,7 +206,7 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
       startTransition(() => {
         setData((current) => {
           if (current === null) return current;
-          const next = applyDetailEvent(current, payload);
+          const next = applyDetailEvent(current, result.event);
           dataRef.current = next;
           return next;
         });
@@ -242,7 +214,6 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
     };
 
     source.addEventListener("job:updated", onMessage as EventListener);
-    source.addEventListener("task:updated", onMessage as EventListener);
     source.addEventListener("state:change", onMessage as EventListener);
 
     return () => {
@@ -265,6 +236,10 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
     return () => clearInterval(interval);
   }, [data?.status, load]);
 
+  const refetch = useCallback(() => {
+    load();
+  }, [load]);
+
   return {
     data,
     loading,
@@ -273,5 +248,6 @@ export function useJobDetailWithUpdates(jobId: string): UseJobDetailWithUpdatesR
     isRefreshing,
     isTransitioning,
     isHydrated,
+    refetch,
   };
 }

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

@@ -1,39 +1,17 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { adaptJobSummary } from "../adapters/job-adapter";
+import { getJson } from "../api";
+import { nextLoadState, type LoadState } from "../load-state";
 import type { ApiError, NormalizedJobSummary, UseJobListResult } from "../types";
 
 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 jobs",
-  };
-}
-
-export function extractJobList(payload: unknown): Record<string, unknown>[] {
-  if (Array.isArray(payload)) return payload.filter(isRecord);
-  if (isRecord(payload) && payload["ok"] === true && Array.isArray(payload["data"])) {
-    return payload["data"].filter(isRecord);
-  }
-  return [];
-}
-
 export async function fetchJobList(signal?: AbortSignal): Promise<NormalizedJobSummary[]> {
-  const response = await fetch("/api/jobs", { signal });
-  const payload = await response.json();
-  return extractJobList(payload).map(adaptJobSummary);
+  const raw = await getJson<unknown[]>("/api/jobs", { signal, validate: Array.isArray });
+  return raw.filter(isRecord).map(adaptJobSummary);
 }
 
 export function useJobList(): UseJobListResult {
@@ -41,6 +19,15 @@ export function useJobList(): UseJobListResult {
   const [data, setData] = useState<NormalizedJobSummary[] | null>(null);
   const [error, setError] = useState<ApiError | null>(null);
   const abortRef = useRef<AbortController | null>(null);
+  const dataRef = useRef<NormalizedJobSummary[] | null>(null);
+  const errorRef = useRef<ApiError | null>(null);
+
+  const apply = (next: LoadState<NormalizedJobSummary[]>) => {
+    dataRef.current = next.data;
+    errorRef.current = next.error;
+    setData(next.data);
+    setError(next.error);
+  };
 
   const load = useCallback((cancelPrevious: boolean) => {
     if (cancelPrevious) abortRef.current?.abort();
@@ -50,14 +37,22 @@ export function useJobList(): UseJobListResult {
 
     void fetchJobList(controller.signal)
       .then((jobs) => {
-        setData(jobs);
-        setError(null);
+        if (abortRef.current !== controller) return;
+        apply(nextLoadState(
+          { data: dataRef.current, error: errorRef.current },
+          { ok: true, data: jobs },
+        ));
       })
-      .catch((fetchError) => {
+      .catch((fetchError: unknown) => {
         if (fetchError instanceof DOMException && fetchError.name === "AbortError") return;
-        setError(toApiError(fetchError));
+        if (abortRef.current !== controller) return;
+        apply(nextLoadState(
+          { data: dataRef.current, error: errorRef.current },
+          { ok: false, error: fetchError as ApiError },
+        ));
       })
       .finally(() => {
+        if (abortRef.current !== controller) return;
         setLoading(false);
       });
   }, []);
@@ -72,4 +67,4 @@ export function useJobList(): UseJobListResult {
   }, [load]);
 
   return { loading, data, error, refetch };
-}
+}