@ryanfw/prompt-orchestration-pipeline 1.2.9 → 1.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",

package/src/core/__tests__/pipeline-runner.test.ts

@@ -278,6 +278,54 @@ describe("runPipelineJob — multi-task success regression", () => {
     expect(anyLifecycleBlock).toBe(false);
     expect(exitCalls).toEqual([]);
   });
+
+  test("starting a task clears stale terminal fields from earlier attempts", async () => {
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    const initialStatusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const initialStatus = JSON.parse(initialStatusText) as {
+      tasks: Record<string, Record<string, unknown>>;
+    };
+    initialStatus.tasks["task-a"] = {
+      ...initialStatus.tasks["task-a"],
+      state: "pending",
+      endedAt: "2026-04-01T10:00:00.000Z",
+      failedStage: "generate",
+      error: { message: "old failure" },
+      stageLogPath: "/tmp/old.log",
+      errorContext: { stage: "generate" },
+      retrying: true,
+      nextRetryAt: "2026-04-01T10:01:00.000Z",
+      lastRetryError: { message: "old retry" },
+    };
+    await writeFile(join(fixture.jobDir, "tasks-status.json"), JSON.stringify(initialStatus));
+
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      throw new Error(`process.exit called with ${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    const finalStatusText = await readFile(fixture.statusPath, "utf-8");
+    const finalStatus = JSON.parse(finalStatusText) as {
+      tasks: Record<string, Record<string, unknown>>;
+    };
+    const task = finalStatus.tasks["task-a"];
+    expect(task?.["state"]).toBe("done");
+    expect(typeof task?.["endedAt"]).toBe("string");
+    expect(task?.["failedStage"]).toBeUndefined();
+    expect(task?.["error"]).toBeUndefined();
+    expect(task?.["stageLogPath"]).toBeUndefined();
+    expect(task?.["errorContext"]).toBeUndefined();
+    expect(task?.["retrying"]).toBeUndefined();
+    expect(task?.["nextRetryAt"]).toBeUndefined();
+    expect(task?.["lastRetryError"]).toBeUndefined();
+  });
 });
 
 describe("runPipelineJob — outer-catch failure surfacing", () => {
@@ -361,6 +409,18 @@ describe("runPipelineJob — outer-catch failure surfacing", () => {
     expect(typeof failure.message).toBe("string");
     expect(failure.message).toContain(injectedMessage);
 
+    const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const status = JSON.parse(statusText) as {
+      state?: string;
+      current?: string | null;
+      tasks: Record<string, { state?: string; failedStage?: unknown; error?: unknown }>;
+    };
+    expect(status.state).toBe("pending");
+    expect(status.current).toBeNull();
+    expect(status.tasks["task-a"]?.state).toBe("pending");
+    expect(status.tasks["task-a"]?.failedStage).toBeUndefined();
+    expect(status.tasks["task-a"]?.error).toBeUndefined();
+
     const stderrContainsMessage = consoleErrorMessages.some((args) =>
       args.some((a) => typeof a === "string" && a.includes(injectedMessage)),
     );
@@ -501,11 +561,21 @@ describe("runPipelineJob — bounded retry loop", () => {
 
     const statusText = await readFile(fixture.statusPath, "utf-8");
     const status = JSON.parse(statusText) as {
-      tasks: Record<string, { state?: string; attempts?: number; restartCount?: number }>;
+      tasks: Record<string, {
+        state?: string;
+        attempts?: number;
+        restartCount?: number;
+        retrying?: unknown;
+        nextRetryAt?: unknown;
+        lastRetryError?: unknown;
+      }>;
     };
     expect(status.tasks["task-a"]?.state).toBe("done");
     expect(status.tasks["task-a"]?.attempts).toBe(3);
     expect(status.tasks["task-a"]?.restartCount).toBe(2);
+    expect(status.tasks["task-a"]?.retrying).toBeUndefined();
+    expect(status.tasks["task-a"]?.nextRetryAt).toBeUndefined();
+    expect(status.tasks["task-a"]?.lastRetryError).toBeUndefined();
   });
 
   test("maxAttempts: 3 — always fails: three calls, restartCount=2, exits non-zero", async () => {
@@ -535,11 +605,25 @@ describe("runPipelineJob — bounded retry loop", () => {
 
     const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
     const status = JSON.parse(statusText) as {
-      tasks: Record<string, { state?: string; attempts?: number; restartCount?: number }>;
+      tasks: Record<string, {
+        state?: string;
+        attempts?: number;
+        restartCount?: number;
+        retrying?: unknown;
+        nextRetryAt?: unknown;
+        lastRetryError?: unknown;
+        failedStage?: unknown;
+        error?: unknown;
+      }>;
     };
     expect(status.tasks["task-a"]?.state).toBe("failed");
     expect(status.tasks["task-a"]?.attempts).toBe(3);
     expect(status.tasks["task-a"]?.restartCount).toBe(2);
+    expect(status.tasks["task-a"]?.retrying).toBeUndefined();
+    expect(status.tasks["task-a"]?.nextRetryAt).toBeUndefined();
+    expect(status.tasks["task-a"]?.lastRetryError).toBeUndefined();
+    expect(status.tasks["task-a"]?.failedStage).toBe("generate");
+    expect(status.tasks["task-a"]?.error).toBeDefined();
   });
 
   test("interim status between attempts: state=running, no failedStage/error, restartCount incremented", async () => {
@@ -548,7 +632,17 @@ describe("runPipelineJob — bounded retry loop", () => {
     cleanupDirs.push(fixture.tmpDir);
 
     let call = 0;
-    let interimSnapshot: { state?: string; attempts?: number; failedStage?: unknown; error?: unknown; restartCount?: number } | undefined;
+    let interimLastUpdated: string | undefined;
+    let interimSnapshot: {
+      state?: string;
+      attempts?: number;
+      failedStage?: unknown;
+      error?: unknown;
+      restartCount?: number;
+      retrying?: unknown;
+      nextRetryAt?: unknown;
+      lastRetryError?: { message?: unknown };
+    } | undefined;
 
     // Capture the snapshot from disk *during* the second call (after the first failure
     // and the interim writeJobStatus). At call #2 we read tasks-status.json, then
@@ -558,8 +652,19 @@ describe("runPipelineJob — bounded retry loop", () => {
       if (call === 2) {
         const text = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
         const parsed = JSON.parse(text) as {
-          tasks: Record<string, { state?: string; attempts?: number; failedStage?: unknown; error?: unknown; restartCount?: number }>;
+          lastUpdated?: string;
+          tasks: Record<string, {
+            state?: string;
+            attempts?: number;
+            failedStage?: unknown;
+            error?: unknown;
+            restartCount?: number;
+            retrying?: unknown;
+            nextRetryAt?: unknown;
+            lastRetryError?: { message?: unknown };
+          }>;
         };
+        interimLastUpdated = parsed.lastUpdated;
         interimSnapshot = parsed.tasks["task-a"];
         return makeSuccessResult() as never;
       }
@@ -584,6 +689,62 @@ describe("runPipelineJob — bounded retry loop", () => {
     expect(interimSnapshot?.error).toBeUndefined();
     expect(interimSnapshot?.attempts).toBe(2);
     expect(interimSnapshot?.restartCount).toBe(1);
+    expect(interimSnapshot?.retrying).toBe(true);
+    expect(typeof interimSnapshot?.nextRetryAt).toBe("string");
+    expect(interimSnapshot?.lastRetryError?.message).toBe("stub failure");
+    expect(Date.parse(interimSnapshot?.nextRetryAt as string)).toBeGreaterThan(Date.parse(interimLastUpdated ?? ""));
+  });
+
+  test("exception escaping retry loop after first retry metadata write clears retrying/nextRetryAt/lastRetryError", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    let call = 0;
+    mockRunPipeline.mockImplementation(async () => {
+      call += 1;
+      if (call === 1) return makeFailureResult() as never;
+      // On the second attempt, throw an exception instead of returning a result.
+      // This simulates an unexpected error escaping the retry loop after retry
+      // metadata (retrying=true, nextRetryAt, lastRetryError) has been written.
+      throw new Error("exception mid-retry");
+    });
+
+    const exitCalls: Array<number | undefined> = [];
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      exitCalls.push(code);
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+    const fakeTimer = { unref: () => fakeTimer, ref: () => fakeTimer };
+    // Stub setTimeout to prevent the delayed process.exit(1) from leaking into subsequent tests.
+    const setTimeoutSpy = spyOn(globalThis, "setTimeout").mockImplementation(
+      ((() => fakeTimer as unknown as ReturnType<typeof setTimeout>) as unknown) as typeof setTimeout,
+    );
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(exitCalls).toContain(1);
+
+    const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const status = JSON.parse(statusText) as {
+      tasks: Record<string, {
+        state?: string;
+        retrying?: unknown;
+        nextRetryAt?: unknown;
+        lastRetryError?: unknown;
+      }>;
+    };
+    expect(status.tasks["task-a"]?.state).toBe("failed");
+    expect(status.tasks["task-a"]?.retrying).toBeUndefined();
+    expect(status.tasks["task-a"]?.nextRetryAt).toBeUndefined();
+    expect(status.tasks["task-a"]?.lastRetryError).toBeUndefined();
   });
 
   test("missing taskRunner config falls back to the default retry cap", async () => {
@@ -617,6 +778,12 @@ describe("runPipelineJob — bounded retry loop", () => {
       exitCalls.push(code);
       throw new Error(`__test_exit__:${String(code)}`);
     }) as typeof process.exit);
+    const fakeTimer = { unref: () => fakeTimer, ref: () => fakeTimer };
+    // The catch block schedules process.exit(1) via setTimeout(...).unref(); without this
+    // stub the timer leaks into subsequent tests.
+    const setTimeoutSpy = spyOn(globalThis, "setTimeout").mockImplementation(
+      ((() => fakeTimer as unknown as ReturnType<typeof setTimeout>) as unknown) as typeof setTimeout,
+    );
 
     try {
       await runPipelineJob(fixture.jobId);
@@ -624,11 +791,33 @@ describe("runPipelineJob — bounded retry loop", () => {
       if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
     } finally {
       exitSpy.mockRestore();
+      setTimeoutSpy.mockRestore();
     }
 
     expect(mockRunPipeline.mock.calls.length).toBe(1);
     expect(sleepDelays).toEqual([]);
     expect(exitCalls).toContain(1);
+
+    const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const status = JSON.parse(statusText) as {
+      state?: string;
+      current?: string | null;
+      currentStage?: string | null;
+      tasks: Record<string, {
+        state?: string;
+        endedAt?: string;
+        failedStage?: string;
+        error?: { message?: string };
+      }>;
+    };
+    const failedTask = status.tasks["task-a"];
+    expect(status.state).toBe("failed");
+    expect(status.current).toBe("task-a");
+    expect(status.currentStage).toBeNull();
+    expect(failedTask?.state).toBe("failed");
+    expect(typeof failedTask?.endedAt).toBe("string");
+    expect(failedTask?.failedStage).toBe("orchestrator");
+    expect(failedTask?.error?.message).toContain("task module exploded");
   });
 });
 

package/src/core/pipeline-runner.ts

@@ -100,6 +100,9 @@ export interface TaskStatus {
   executionTimeMs?: number;
   refinementAttempts?: number;
   restartCount?: number;
+  retrying?: boolean;
+  nextRetryAt?: string;
+  lastRetryError?: NormalizedError;
   error?: NormalizedError;
   failedStage?: string;
   stageLogPath?: string;
@@ -285,6 +288,7 @@ const RETRY_BACKOFF_MULTIPLIER = 2;
 /** Runs a pipeline job end-to-end for the given job ID. */
 export async function runPipelineJob(jobId: string): Promise<void> {
   let workDir: string | undefined;
+  let activeTaskName: string | null = null;
   const poRoot = resolve(process.env["PO_ROOT"] ?? process.cwd());
   let dataDir: string | undefined = resolve(poRoot, process.env["PO_DATA_DIR"] ?? "pipeline-data");
   try {
@@ -374,6 +378,7 @@ export async function runPipelineJob(jobId: string): Promise<void> {
     }
 
     // Update status to RUNNING
+    activeTaskName = taskName;
     await writeJobStatus(config.workDir, (snapshot) => {
       snapshot.state = "running";
       snapshot.current = taskName;
@@ -382,6 +387,14 @@ export async function runPipelineJob(jobId: string): Promise<void> {
       taskEntry.state = "running";
       taskEntry.startedAt = new Date().toISOString();
       taskEntry.attempts = (taskEntry.attempts ?? 0) + 1;
+      delete taskEntry.endedAt;
+      delete taskEntry.failedStage;
+      delete taskEntry.error;
+      delete taskEntry.stageLogPath;
+      delete taskEntry.errorContext;
+      delete taskEntry.retrying;
+      delete taskEntry.nextRetryAt;
+      delete taskEntry.lastRetryError;
       snapshot.tasks[taskName] = taskEntry;
     });
 
@@ -452,13 +465,15 @@ export async function runPipelineJob(jobId: string): Promise<void> {
     let result: PipelineResult | undefined;
     for (let attempt = 1; attempt <= cap; attempt++) {
       result = await runPipeline(relocatedEntryPath, taskExecutionContext);
-      if (result.ok) break;
+      const failedResult = result; // const binding lets TypeScript narrow the union after the ok check below
+      if (failedResult.ok) break;
       if (attempt >= cap) break;
 
       const delay = Math.min(
         INITIAL_RETRY_DELAY_MS * RETRY_BACKOFF_MULTIPLIER ** (attempt - 1),
         MAX_RETRY_DELAY_MS,
       );
+      const nextRetryAt = new Date(Date.now() + delay).toISOString();
 
       await writeJobStatus(config.workDir, (snapshot) => {
         const entry = snapshot.tasks[taskName] ?? {};
@@ -466,6 +481,9 @@ export async function runPipelineJob(jobId: string): Promise<void> {
         entry.state = "running";
         entry.attempts = currentAttempts + 1;
         entry.restartCount = (entry.restartCount ?? 0) + 1;
+        entry.retrying = true;
+        entry.nextRetryAt = nextRetryAt;
+        entry.lastRetryError = failedResult.error;
         delete entry.failedStage;
         delete entry.error;
         snapshot.tasks[taskName] = entry;
@@ -493,8 +511,12 @@ export async function runPipelineJob(jobId: string): Promise<void> {
         taskEntry.endedAt = new Date().toISOString();
         taskEntry.executionTimeMs = executionTimeMs;
         taskEntry.refinementAttempts = ((result.context as unknown) as Record<string, unknown>)["refinementAttempts"] as number | undefined ?? 0;
+        delete taskEntry.retrying;
+        delete taskEntry.nextRetryAt;
+        delete taskEntry.lastRetryError;
         snapshot.tasks[taskName] = taskEntry;
       });
+      activeTaskName = null;
 
       // Add task output to pipelineArtifacts
       const outputPath = join(config.workDir, "tasks", taskName, "output.json");
@@ -522,8 +544,12 @@ export async function runPipelineJob(jobId: string): Promise<void> {
         raw["failedStage"] = result.failedStage;
         raw["stageLogPath"] = result.error.debug?.logPath;
         raw["errorContext"] = result.error.debug as unknown as Record<string, unknown>;
+        delete raw["retrying"];
+        delete raw["nextRetryAt"];
+        delete raw["lastRetryError"];
         snapshot.tasks[taskName] = raw as typeof snapshot.tasks[string];
       });
+      activeTaskName = null;
 
       await releaseJobSlotBestEffort(dataDir, jobId);
       process.exit(1);
@@ -567,6 +593,32 @@ export async function runPipelineJob(jobId: string): Promise<void> {
       } catch {
         // Do not mask the original failure if log-write fails
       }
+      if (activeTaskName !== null) {
+        try {
+          const failedTaskName = activeTaskName;
+          const failedAt = new Date().toISOString();
+          await writeJobStatus(workDir, (snapshot) => {
+            snapshot.state = "failed";
+            snapshot.current = failedTaskName;
+            snapshot.currentStage = null;
+            const existing = snapshot.tasks[failedTaskName] ?? {};
+            const taskEntry: Partial<TaskStatus> & Record<string, unknown> = {
+              ...existing,
+              state: TaskState.FAILED,
+              endedAt: failedAt,
+              failedStage: "orchestrator",
+              error: normalized,
+              currentStage: null,
+            };
+            delete taskEntry.retrying;
+            delete taskEntry.nextRetryAt;
+            delete taskEntry.lastRetryError;
+            snapshot.tasks[failedTaskName] = taskEntry as typeof snapshot.tasks[string];
+          });
+        } catch {
+          // Do not mask the original failure if status finalization fails
+        }
+      }
       try {
         await cleanupPidFile(workDir);
       } catch {

package/src/core/status-writer.ts

@@ -1,3 +1,8 @@
+import { rename, unlink, mkdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { createJobLogger } from "./logger";
+import type { NormalizedError } from "./pipeline-runner";
+
 export type JobState = "pending" | "running" | "done" | "failed";
 
 type TaskState = "pending" | "running" | "done" | "failed";
@@ -16,9 +21,14 @@ export interface TaskEntry {
   attempts?: number;
   restartCount?: number;
   refinementAttempts?: number;
+  retrying?: boolean;
+  nextRetryAt?: string;
+  lastRetryError?: NormalizedError;
   tokenUsage?: unknown[];
   startedAt?: string;
   endedAt?: string;
+  stageLogPath?: string;
+  errorContext?: Record<string, unknown>;
   files?: FilesManifest;
   [key: string]: unknown;
 }
@@ -52,9 +62,17 @@ export interface UploadArtifact {
 
 export const STATUS_FILENAME = "tasks-status.json";
 
-import { rename, unlink, mkdir } from "node:fs/promises";
-import { basename, join } from "node:path";
-import { createJobLogger } from "./logger";
+function clearResetTaskMetadata(task: TaskEntry): void {
+  delete task.startedAt;
+  delete task.endedAt;
+  delete task.failedStage;
+  delete task.error;
+  delete task.stageLogPath;
+  delete task.errorContext;
+  delete task.retrying;
+  delete task.nextRetryAt;
+  delete task.lastRetryError;
+}
 
 export function validateFilePath(filename: string): boolean {
   if (!filename || typeof filename !== "string") {
@@ -225,8 +243,7 @@ export function resetJobFromTask(jobDir: string, fromTask: string, options?: Res
       const task = snapshot.tasks[key]!;
       task.state = "pending";
       task.currentStage = null;
-      delete task.failedStage;
-      delete task.error;
+      clearResetTaskMetadata(task);
       task.attempts = 0;
       task.restartCount = 0;
       task.refinementAttempts = 0;
@@ -252,8 +269,7 @@ export function resetJobToCleanSlate(jobDir: string, options?: ResetOptions): Pr
       const task = snapshot.tasks[key]!;
       task.state = "pending";
       task.currentStage = null;
-      delete task.failedStage;
-      delete task.error;
+      clearResetTaskMetadata(task);
       task.attempts = 0;
       task.restartCount = 0;
       task.refinementAttempts = 0;
@@ -280,8 +296,7 @@ export function resetSingleTask(jobDir: string, taskId: string, options?: ResetO
     const task = snapshot.tasks[taskId]!;
     task.state = "pending";
     task.currentStage = null;
-    delete task.failedStage;
-    delete task.error;
+    clearResetTaskMetadata(task);
     task.attempts = 0;
     task.restartCount = 0;
     task.refinementAttempts = 0;

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

@@ -42,6 +42,33 @@ describe("job adapter", () => {
     expect(normalizeTasks({ t1: { state: "done" } })["t1"]?.restartCount).toBeUndefined();
   });
 
+  it("maps retry metadata when present and leaves it undefined when absent", () => {
+    const tasks = normalizeTasks({
+      retrying: {
+        state: "running",
+        retrying: true,
+        nextRetryAt: "2026-04-01T10:01:00.000Z",
+        lastRetryError: { message: "try again" },
+      },
+      plain: { state: "pending" },
+    });
+
+    expect(tasks["retrying"]?.retrying).toBe(true);
+    expect(tasks["retrying"]?.nextRetryAt).toBe("2026-04-01T10:01:00.000Z");
+    expect(tasks["retrying"]?.lastRetryError).toEqual({ message: "try again" });
+    expect(tasks["plain"]?.retrying).toBeUndefined();
+    expect(tasks["plain"]?.nextRetryAt).toBeUndefined();
+    expect(tasks["plain"]?.lastRetryError).toBeUndefined();
+  });
+
+  it("maps lastRetryError: null and preserves null on the normalized task", () => {
+    const tasks = normalizeTasks({
+      t1: { state: "running", lastRetryError: null },
+    });
+
+    expect(tasks["t1"]?.lastRetryError).toBeNull();
+  });
+
   it("adapts summary jobs with defaults", () => {
     const job = adaptJobSummary({
       jobId: "job-1",

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

@@ -50,6 +50,9 @@ function normalizeTask(name: string, rawTask: unknown): NormalizedTask {
     endedAt: toStringOrNull(task["endedAt"]),
     attempts: typeof task["attempts"] === "number" ? task["attempts"] : undefined,
     restartCount: typeof task["restartCount"] === "number" ? task["restartCount"] : undefined,
+    retrying: typeof task["retrying"] === "boolean" ? task["retrying"] : undefined,
+    nextRetryAt: typeof task["nextRetryAt"] === "string" ? task["nextRetryAt"] : undefined,
+    lastRetryError: Object.hasOwn(task, "lastRetryError") ? task["lastRetryError"] as import("../types").RetryError | null : 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/types.ts

@@ -79,6 +79,8 @@ export interface CostsSummary {
   totalOutputCost: number;
 }
 
+export type RetryError = { message: string; name?: string; stack?: string } | string;
+
 export interface TaskFiles {
   artifacts: string[];
   logs: string[];
@@ -92,6 +94,9 @@ export interface NormalizedTask {
   endedAt: string | null;
   attempts?: number;
   restartCount?: number;
+  retrying?: boolean;
+  nextRetryAt?: string;
+  lastRetryError?: RetryError | null;
   executionTimeMs?: number;
   currentStage?: string;
   failedStage?: string;

package/src/ui/dist/assets/{index-BnAqY4_n.js → index-HrBsHfx3.js}

@@ -21943,6 +21943,9 @@ function normalizeTask(name2, rawTask) {
     endedAt: toStringOrNull(task["endedAt"]),
     attempts: typeof task["attempts"] === "number" ? task["attempts"] : void 0,
     restartCount: typeof task["restartCount"] === "number" ? task["restartCount"] : void 0,
+    retrying: typeof task["retrying"] === "boolean" ? task["retrying"] : void 0,
+    nextRetryAt: typeof task["nextRetryAt"] === "string" ? task["nextRetryAt"] : void 0,
+    lastRetryError: Object.hasOwn(task, "lastRetryError") ? task["lastRetryError"] : void 0,
     executionTimeMs: typeof task["executionTimeMs"] === "number" ? task["executionTimeMs"] : void 0,
     currentStage: typeof task["currentStage"] === "string" ? task["currentStage"] : void 0,
     failedStage: typeof task["failedStage"] === "string" ? task["failedStage"] : void 0,