@calmo/task-runner 3.0.0 → 3.2.0

package/dist/strategies/DryRunExecutionStrategy.d.ts

@@ -0,0 +1,16 @@
+import { IExecutionStrategy } from "./IExecutionStrategy.js";
+import { TaskStep } from "../TaskStep.js";
+import { TaskResult } from "../TaskResult.js";
+/**
+ * Execution strategy that simulates task execution without running the actual logic.
+ */
+export declare class DryRunExecutionStrategy<TContext> implements IExecutionStrategy<TContext> {
+    /**
+     * Simulates execution by returning a success result immediately.
+     * @param step The task step (ignored).
+     * @param context The shared context (ignored).
+     * @param signal Optional abort signal (ignored).
+     * @returns A promise resolving to a success result.
+     */
+    execute(_step: TaskStep<TContext>, _context: TContext, _signal?: AbortSignal): Promise<TaskResult>;
+}

package/dist/strategies/DryRunExecutionStrategy.js

@@ -0,0 +1,25 @@
+/**
+ * Execution strategy that simulates task execution without running the actual logic.
+ */
+export class DryRunExecutionStrategy {
+    /**
+     * Simulates execution by returning a success result immediately.
+     * @param step The task step (ignored).
+     * @param context The shared context (ignored).
+     * @param signal Optional abort signal (ignored).
+     * @returns A promise resolving to a success result.
+     */
+    async execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _step, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _context, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _signal) {
+        return Promise.resolve({
+            status: "success",
+            message: "Dry run: simulated success",
+        });
+    }
+}
+//# sourceMappingURL=DryRunExecutionStrategy.js.map

package/dist/strategies/DryRunExecutionStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DryRunExecutionStrategy.js","sourceRoot":"","sources":["../../src/strategies/DryRunExecutionStrategy.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAGlC;;;;;;OAMG;IACH,KAAK,CAAC,OAAO;IACX,6DAA6D;IAC7D,KAAyB;IACzB,6DAA6D;IAC7D,QAAkB;IAClB,6DAA6D;IAC7D,OAAqB;QAErB,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,MAAM,EAAE,SAAS;YACjB,OAAO,EAAE,4BAA4B;SACtC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/strategies/RetryingExecutionStrategy.d.ts

@@ -0,0 +1,12 @@
+import { IExecutionStrategy } from "./IExecutionStrategy.js";
+import { TaskStep } from "../TaskStep.js";
+import { TaskResult } from "../TaskResult.js";
+/**
+ * Execution strategy that retries tasks upon failure based on their retry configuration.
+ */
+export declare class RetryingExecutionStrategy<TContext> implements IExecutionStrategy<TContext> {
+    private innerStrategy;
+    constructor(innerStrategy: IExecutionStrategy<TContext>);
+    execute(step: TaskStep<TContext>, context: TContext, signal?: AbortSignal): Promise<TaskResult>;
+    private sleep;
+}

package/dist/strategies/RetryingExecutionStrategy.js

@@ -0,0 +1,74 @@
+/**
+ * Execution strategy that retries tasks upon failure based on their retry configuration.
+ */
+export class RetryingExecutionStrategy {
+    innerStrategy;
+    constructor(innerStrategy) {
+        this.innerStrategy = innerStrategy;
+    }
+    async execute(step, context, signal) {
+        const config = step.retry;
+        if (!config) {
+            return this.innerStrategy.execute(step, context, signal);
+        }
+        let attempt = 0;
+        while (true) {
+            // Check for cancellation before execution
+            if (signal?.aborted) {
+                return {
+                    status: "cancelled",
+                    message: "Task cancelled before execution",
+                };
+            }
+            const result = await this.innerStrategy.execute(step, context, signal);
+            if (result.status === "success" || result.status === "cancelled" || result.status === "skipped") {
+                return result;
+            }
+            // Task failed, check if we should retry
+            if (attempt >= config.attempts) {
+                return result; // Max attempts reached, return failure
+            }
+            attempt++;
+            // Calculate delay
+            let delay = config.delay;
+            if (config.backoff === "exponential") {
+                delay = config.delay * Math.pow(2, attempt - 1);
+            }
+            // Wait for delay, respecting cancellation
+            try {
+                await this.sleep(delay, signal);
+            }
+            catch (e) {
+                if (signal?.aborted) {
+                    return {
+                        status: "cancelled",
+                        message: "Task cancelled during retry delay",
+                    };
+                }
+                throw e;
+            }
+        }
+    }
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(new Error("AbortError"));
+                return;
+            }
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                clearTimeout(timer);
+                cleanup();
+                reject(new Error("AbortError"));
+            };
+            const cleanup = () => {
+                signal?.removeEventListener("abort", onAbort);
+            };
+            signal?.addEventListener("abort", onAbort);
+        });
+    }
+}
+//# sourceMappingURL=RetryingExecutionStrategy.js.map

package/dist/strategies/RetryingExecutionStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryingExecutionStrategy.js","sourceRoot":"","sources":["../../src/strategies/RetryingExecutionStrategy.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,OAAO,yBAAyB;IAChB;IAApB,YAAoB,aAA2C;QAA3C,kBAAa,GAAb,aAAa,CAA8B;IAAG,CAAC;IAEnE,KAAK,CAAC,OAAO,CACX,IAAwB,EACxB,OAAiB,EACjB,MAAoB;QAEpB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,OAAO,IAAI,EAAE,CAAC;YACZ,0CAA0C;YAC1C,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;gBACpB,OAAO;oBACL,MAAM,EAAE,WAAW;oBACnB,OAAO,EAAE,iCAAiC;iBAC3C,CAAC;YACJ,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAEvE,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAChG,OAAO,MAAM,CAAC;YAChB,CAAC;YAED,wCAAwC;YACxC,IAAI,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAC/B,OAAO,MAAM,CAAC,CAAC,uCAAuC;YACxD,CAAC;YAED,OAAO,EAAE,CAAC;YAEV,kBAAkB;YAClB,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YACzB,IAAI,MAAM,CAAC,OAAO,KAAK,aAAa,EAAE,CAAC;gBACrC,KAAK,GAAG,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YAClD,CAAC;YAED,0CAA0C;YAC1C,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAClC,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACb,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;oBACpB,OAAO;wBACL,MAAM,EAAE,WAAW;wBACnB,OAAO,EAAE,mCAAmC;qBAC7C,CAAC;gBACJ,CAAC;gBACD,MAAM,CAAC,CAAC;YACR,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,EAAU,EAAE,MAAoB;QAC5C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;gBACpB,MAAM,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;gBAChC,OAAO;YACT,CAAC;YAED,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,CAAC;YACZ,CAAC,EAAE,EAAE,CAAC,CAAC;YAEP,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,YAAY,CAAC,KAAK,CAAC,CAAC;gBACpB,OAAO,EAAE,CAAC;gBACV,MAAM,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YAClC,CAAC,CAAC;YAEF,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAChD,CAAC,CAAC;YAEF,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/openspec/changes/add-concurrency-control/proposal.md

@@ -4,11 +4,11 @@
 The current implementation executes *all* independent tasks in parallel. In large graphs with many independent nodes, this could overwhelm system resources (CPU, memory) or trigger external API rate limits.
 
 ## What Changes
-- Add a concurrency control mechanism to the `TaskRunner`.
-- Add `concurrency: number` to the `TaskRunnerExecutionConfig`.
-- Implement a task queue to hold tasks that are ready but waiting for a free slot.
-- Update `WorkflowExecutor` to respect the concurrency limit.
+- Add `concurrency: number` optional property to `WorkflowExecutor`.
+- Modify `WorkflowExecutor.processLoop` to respect the concurrency limit.
+    - Track the active promise count.
+    - Only start new tasks from the ready queue if `active < concurrency`.
+    - Continue to defer ready tasks until slots open up.
 
 ## Impact
-- Affected specs: `task-runner`
-- Affected code: `src/TaskRunner.ts`, `src/WorkflowExecutor.ts`, `src/TaskRunnerExecutionConfig.ts`
+- **Affected Components**: `WorkflowExecutor`

package/openspec/changes/add-task-retry-policy/proposal.md

@@ -4,10 +4,13 @@
 Tasks currently run once and fail immediately if they throw an error or return a failure status. Network glitches or transient issues can therefore cause an entire workflow to fail unnecessarily.
 
 ## What Changes
-- Allow tasks to define a retry policy.
-- Update `TaskStep` interface to include optional `retry` configuration.
-- Implement logic in `TaskRunner` (or `WorkflowExecutor`) to catch failures, check the retry policy, and re-execute the task after the specified delay.
+- Add `TaskRetryConfig` interface to define retry behavior (attempts, delay, backoff).
+- Update `TaskStep` interface to include optional `retry: TaskRetryConfig`.
+- Implement `RetryingExecutionStrategy` which decorates any `IExecutionStrategy`.
+  - It catches failures from the inner strategy.
+  - It checks the retry policy.
+  - It waits and re-executes the step if applicable.
 
 ## Impact
-- Affected specs: `task-runner`
-- Affected code: `src/TaskStep.ts`, `src/WorkflowExecutor.ts` (or `TaskRunner.ts`), `src/contracts/TaskRetryConfig.ts`
+- **New Components**: `RetryingExecutionStrategy`, `TaskRetryConfig`
+- **Affected Components**: `TaskStep` (interface update)

package/openspec/changes/archive/2026-01-18-add-workflow-preview/proposal.md

@@ -0,0 +1,13 @@
+# Change: Add Workflow Preview
+
+## Why
+It can be difficult to understand the execution flow of complex dependency graphs just by looking at the code. Users also currently cannot easily verify the execution plan without running the side effects, which carries risk.
+
+## What Changes
+- Add a `DryRunExecutionStrategy` which implements `IExecutionStrategy`. This allows `WorkflowExecutor` to simulate execution without side effects.
+- Add a standalone utility `generateMermaidGraph(steps: TaskStep[])` to generate a Mermaid.js diagram of the dependency graph.
+- Expose these features via the main `TaskRunner` facade if applicable, or as separate utilities.
+
+## Impact
+- **New Components**: `DryRunExecutionStrategy`, `generateMermaidGraph`
+- **Affected Components**: `WorkflowExecutor` (indirectly, via strategy injection)

package/openspec/changes/archive/2026-01-18-add-workflow-preview/tasks.md

@@ -0,0 +1,7 @@
+## Implementation
+- [x] 1.1 Update `TaskRunnerExecutionConfig` to include an optional `dryRun: boolean` property.
+- [x] 1.2 Implement `dryRun` logic in `WorkflowExecutor` (traverse graph, validate order, skip `step.run()`, return `skipped` or `success` pseudo-status).
+- [x] 1.3 Implement `getMermaidGraph(steps: TaskStep[])` method (can be static or instance method on `TaskRunner`).
+- [x] 1.4 Ensure `dryRun` respects other configs like `concurrency` (if applicable) to simulate actual timing/order if possible, or just strict topological order.
+- [x] 1.5 Add unit tests for `dryRun` ensuring no side effects occur.
+- [x] 1.6 Add unit tests for `getMermaidGraph` output correctness (nodes and edges).

package/openspec/changes/feat-per-task-timeout/proposal.md

@@ -0,0 +1,25 @@
+# Feature: Per-Task Timeout
+
+## 🎯 User Story
+"As a developer, I want to define a maximum execution time for specific tasks so that a single hung task (e.g., a stalled network request) fails fast without blocking the rest of the independent tasks or waiting for the global workflow timeout."
+
+## ❓ Why
+Currently, the `TaskRunner` allows a **global** timeout for the entire `execute()` call. However, this is insufficient for granular control:
+1.  **Varying Latency**: Some tasks are expected to be fast (local validation), others slow (data fetching). A global timeout of 30s is too loose for the fast ones.
+2.  **Boilerplate**: Developers currently have to manually implement `setTimeout`, `Promise.race`, and `AbortController` logic inside every `run()` method to handle timeouts properly.
+3.  **Resilience**: A single "zombie" task can hold up the entire pipeline until the global timeout kills everything. Per-task timeouts allow failing that specific task (and skipping its dependents) while letting other independent tasks continue.
+
+## 🛠️ What Changes
+1.  **Interface Update**: Update `TaskStep<T>` to accept an optional `timeout` property (in milliseconds).
+2.  **Execution Strategy**: Update `StandardExecutionStrategy` to:
+    -   Create a local timeout timer for the task.
+    -   Create a combined `AbortSignal` (merging the workflow's signal and the local timeout).
+    -   Race the task execution against the timer.
+    -   Return a specific failure result if the timeout wins.
+
+## ✅ Acceptance Criteria
+- [ ] A task with `timeout: 100` must fail if the `run` method takes > 100ms.
+- [ ] The error message for a timed-out task should clearly state "Task timed out after 100ms".
+- [ ] The `AbortSignal` passed to the task's `run` method must be triggered when the timeout occurs.
+- [ ] If the Global Workflow is cancelled *before* the task times out, the task should receive the cancellation signal immediately.
+- [ ] A task completing *before* the timeout should clear the timer to prevent open handles.

package/openspec/changes/feat-per-task-timeout/tasks.md

@@ -0,0 +1,27 @@
+# Engineering Tasks
+
+- [ ] **Task 1: Update Interface**
+  - Modify `src/TaskStep.ts` to add `timeout?: number;` to the `TaskStep` interface.
+  - Document the property (milliseconds).
+
+- [ ] **Task 2: Add Timeout Logic to StandardExecutionStrategy**
+  - Modify `src/strategies/StandardExecutionStrategy.ts`.
+  - Inside `execute`:
+    - Check if `step.timeout` is defined.
+    - If yes, create an `AbortController`.
+    - Set a `setTimeout` to trigger the controller.
+    - Use `Promise.race` (or simply pass the new signal and wait) to handle the timeout.
+    - **Crucial**: Ensure the new signal respects the *parent* `signal` (if global cancel happens, local signal must also abort).
+    - **Crucial**: Clean up the timer (`clearTimeout`) in a `finally` block.
+
+- [ ] **Task 3: Unit Tests**
+  - Create `tests/strategies/StandardExecutionStrategy.timeout.test.ts`.
+  - Test case: Task finishes before timeout (success).
+  - Test case: Task runs longer than timeout (failure/error).
+  - Test case: Task receives AbortSignal on timeout.
+  - Test case: Global cancellation overrides local timeout.
+
+- [ ] **Task 4: Integration Test**
+  - Update `tests/TaskRunner.test.ts` or create `tests/timeouts.test.ts`.
+  - Define a workflow with a slow task and a short timeout.
+  - Verify that the slow task fails, dependents are skipped, and independent tasks still complete (if any).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calmo/task-runner",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "",
   "repository": {
     "type": "git",

package/src/TaskRunner.ts

@@ -9,6 +9,8 @@ import { TaskRunnerExecutionConfig } from "./TaskRunnerExecutionConfig.js";
 import { TaskStateManager } from "./TaskStateManager.js";
 import { IExecutionStrategy } from "./strategies/IExecutionStrategy.js";
 import { StandardExecutionStrategy } from "./strategies/StandardExecutionStrategy.js";
+import { RetryingExecutionStrategy } from "./strategies/RetryingExecutionStrategy.js";
+import { DryRunExecutionStrategy } from "./strategies/DryRunExecutionStrategy.js";
 
 // Re-export types for backward compatibility
 export { RunnerEventPayloads, RunnerEventListener, TaskRunnerExecutionConfig };
@@ -21,7 +23,9 @@ export { RunnerEventPayloads, RunnerEventListener, TaskRunnerExecutionConfig };
 export class TaskRunner<TContext> {
   private eventBus = new EventBus<TContext>();
   private validator = new TaskGraphValidator();
-  private executionStrategy: IExecutionStrategy<TContext> = new StandardExecutionStrategy();
+  private executionStrategy: IExecutionStrategy<TContext> = new RetryingExecutionStrategy(
+    new StandardExecutionStrategy()
+  );
 
   /**
    * @param context The shared context object to be passed to each task.
@@ -64,6 +68,54 @@ export class TaskRunner<TContext> {
     return this;
   }
 
+  /**
+   * Generates a Mermaid.js graph representation of the task workflow.
+   * @param steps The list of tasks to visualize.
+   * @returns A string containing the Mermaid graph definition.
+   */
+  public static getMermaidGraph<T>(steps: TaskStep<T>[]): string {
+    const graphLines = ["graph TD"];
+
+    // Helper to sanitize node names or wrap them if needed
+    // For simplicity, we just wrap in quotes and use the name as ID if it's simple
+    // or generate an ID if strictly needed. Here we assume names are unique IDs.
+    // We will wrap names in quotes for the label, but use the name as the ID.
+    // Actually, Mermaid ID cannot have spaces without quotes.
+    const safeId = (name: string) => JSON.stringify(name);
+    const sanitize = (name: string) => this.sanitizeMermaidId(name);
+
+
+    // Add all nodes first to ensure they exist
+    for (const step of steps) {
+      // Using the name as both ID and Label for simplicity
+      // Format: ID["Label"]
+      // safeId returns a quoted string (e.g. "Task Name"), so we use it directly as the label
+      graphLines.push(`  ${sanitize(step.name)}[${safeId(step.name)}]`);
+    }
+
+    // Add edges
+    for (const step of steps) {
+      if (step.dependencies) {
+        for (const dep of step.dependencies) {
+          graphLines.push(
+            `  ${sanitize(dep)} --> ${sanitize(step.name)}`
+          );
+        }
+      }
+    }
+
+    return [...new Set(graphLines)].join("\n");
+  }
+
+  /**
+   * Sanitizes a string for use as a Mermaid node ID.
+   * @param id The string to sanitize.
+   * @returns The sanitized string.
+   */
+  private static sanitizeMermaidId(id: string): string {
+    return id.replaceAll(/ /g, "_").replaceAll(/:/g, "_").replaceAll(/"/g, "_");
+  }
+
   /**
    * Executes a list of tasks, respecting their dependencies and running
    * independent tasks in parallel.
@@ -90,11 +142,17 @@ export class TaskRunner<TContext> {
     }
 
     const stateManager = new TaskStateManager(this.eventBus);
+
+    let strategy = this.executionStrategy;
+    if (config?.dryRun) {
+      strategy = new DryRunExecutionStrategy<TContext>();
+    }
+
     const executor = new WorkflowExecutor(
       this.context,
       this.eventBus,
       stateManager,
-      this.executionStrategy
+      strategy
     );
 
     // We need to handle the timeout cleanup properly.

package/src/TaskRunnerExecutionConfig.ts

@@ -10,4 +10,9 @@ export interface TaskRunnerExecutionConfig {
    * A timeout in milliseconds for the entire workflow.
    */
   timeout?: number;
+  /**
+   * If true, the runner will simulate execution without running the actual tasks.
+   * Useful for verifying the execution order and graph structure.
+   */
+  dryRun?: boolean;
 }

package/src/TaskStep.ts

@@ -1,4 +1,5 @@
 import { TaskResult } from "./TaskResult.js";
+import { TaskRetryConfig } from "./contracts/TaskRetryConfig.js";
 
 /**
  * Represents a single, executable step within a workflow.
@@ -9,6 +10,8 @@ export interface TaskStep<TContext> {
   name: string;
   /** An optional list of task names that must complete successfully before this step can run. */
   dependencies?: string[];
+  /** Optional retry configuration for the task. */
+  retry?: TaskRetryConfig;
   /**
    * The core logic of the task.
    * @param context The shared context object, allowing for state to be passed between tasks.

package/src/contracts/TaskRetryConfig.ts

@@ -0,0 +1,8 @@
+export interface TaskRetryConfig {
+  /** Number of retries (excluding the initial run). */
+  attempts: number;
+  /** Delay in milliseconds between retries. */
+  delay: number;
+  /** Backoff strategy: 'fixed' (default) or 'exponential'. */
+  backoff?: "fixed" | "exponential";
+}

package/src/index.ts

@@ -2,7 +2,9 @@ export { TaskRunner } from "./TaskRunner.js";
 export { TaskRunnerBuilder } from "./TaskRunnerBuilder.js";
 export { TaskStateManager } from "./TaskStateManager.js";
 export { StandardExecutionStrategy } from "./strategies/StandardExecutionStrategy.js";
+export { RetryingExecutionStrategy } from "./strategies/RetryingExecutionStrategy.js";
 export type { IExecutionStrategy } from "./strategies/IExecutionStrategy.js";
+export type { TaskRetryConfig } from "./contracts/TaskRetryConfig.js";
 export type { TaskStep } from "./TaskStep.js";
 export type { TaskResult } from "./TaskResult.js";
 export type { TaskStatus } from "./TaskStatus.js";

package/src/strategies/DryRunExecutionStrategy.ts

@@ -0,0 +1,31 @@
+import { IExecutionStrategy } from "./IExecutionStrategy.js";
+import { TaskStep } from "../TaskStep.js";
+import { TaskResult } from "../TaskResult.js";
+
+/**
+ * Execution strategy that simulates task execution without running the actual logic.
+ */
+export class DryRunExecutionStrategy<TContext>
+  implements IExecutionStrategy<TContext>
+{
+  /**
+   * Simulates execution by returning a success result immediately.
+   * @param step The task step (ignored).
+   * @param context The shared context (ignored).
+   * @param signal Optional abort signal (ignored).
+   * @returns A promise resolving to a success result.
+   */
+  async execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _step: TaskStep<TContext>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _context: TContext,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _signal?: AbortSignal
+  ): Promise<TaskResult> {
+    return Promise.resolve({
+      status: "success",
+      message: "Dry run: simulated success",
+    });
+  }
+}

package/src/strategies/RetryingExecutionStrategy.ts

@@ -0,0 +1,90 @@
+import { IExecutionStrategy } from "./IExecutionStrategy.js";
+import { TaskStep } from "../TaskStep.js";
+import { TaskResult } from "../TaskResult.js";
+
+/**
+ * Execution strategy that retries tasks upon failure based on their retry configuration.
+ */
+export class RetryingExecutionStrategy<TContext> implements IExecutionStrategy<TContext> {
+  constructor(private innerStrategy: IExecutionStrategy<TContext>) {}
+
+  async execute(
+    step: TaskStep<TContext>,
+    context: TContext,
+    signal?: AbortSignal
+  ): Promise<TaskResult> {
+    const config = step.retry;
+    if (!config) {
+      return this.innerStrategy.execute(step, context, signal);
+    }
+
+    let attempt = 0;
+    while (true) {
+      // Check for cancellation before execution
+      if (signal?.aborted) {
+        return {
+          status: "cancelled",
+          message: "Task cancelled before execution",
+        };
+      }
+
+      const result = await this.innerStrategy.execute(step, context, signal);
+
+      if (result.status === "success" || result.status === "cancelled" || result.status === "skipped") {
+        return result;
+      }
+
+      // Task failed, check if we should retry
+      if (attempt >= config.attempts) {
+        return result; // Max attempts reached, return failure
+      }
+
+      attempt++;
+
+      // Calculate delay
+      let delay = config.delay;
+      if (config.backoff === "exponential") {
+        delay = config.delay * Math.pow(2, attempt - 1);
+      }
+
+      // Wait for delay, respecting cancellation
+      try {
+        await this.sleep(delay, signal);
+      } catch (e) {
+      if (signal?.aborted) {
+        return {
+          status: "cancelled",
+          message: "Task cancelled during retry delay",
+        };
+      }
+      throw e;
+      }
+    }
+  }
+
+  private sleep(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, ms);
+
+      const onAbort = () => {
+        clearTimeout(timer);
+        cleanup();
+        reject(new Error("AbortError"));
+      };
+
+      const cleanup = () => {
+        signal?.removeEventListener("abort", onAbort);
+      };
+
+      signal?.addEventListener("abort", onAbort);
+    });
+  }
+}