Replace Polly with Kevlar

Directory.Packages.props

@@ -38,6 +38,7 @@
     <PackageVersion Include="FluentFTP" Version="54.2.0" />
     <PackageVersion Include="FSharp.Core" Version="10.1.400" />
     <PackageVersion Include="Initialization.Microsoft.Extensions.DependencyInjection" Version="1.1.44" />
+    <PackageVersion Include="Kevlar" Version="0.3.0" />
     <PackageVersion Include="MailKit" Version="4.17.0" />
     <PackageVersion Include="Mediator.Abstractions" Version="3.0.2" />
     <PackageVersion Include="Mediator.SourceGenerator" Version="3.0.2" />
@@ -70,7 +71,6 @@
     <PackageVersion Include="Octokit" Version="14.0.0" />
     <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.18.0" />
     <PackageVersion Include="OpenTelemetry.Extensions.Hosting" Version="1.18.0" />
-    <PackageVersion Include="Polly" Version="8.7.0" />
     <PackageVersion Include="RichardSzalay.MockHttp" Version="7.1.0" />
     <PackageVersion Include="Slack.Webhooks" Version="1.1.6" />
     <PackageVersion Include="Sourcy.DotNet" Version="1.1.1" />

README.md

@@ -227,7 +227,7 @@ ModularPipelines takes a different approach: each unit of work is a self-contain
 * **Secret obfuscation** - Automatic masking in logs
 * **Hooks** - Run code before/after any module
 * **Skip conditions** - Dynamically skip modules based on custom logic
-* **Retry policies** - Configurable retry with Polly integration
+* **Resilience shields** - Configurable retries and advanced Kevlar integration
 * **Requirements validation** - Check prerequisites before running
 * **Progress reporting** - Real-time console output with parallel execution visualization
 * **Source controlled** - Your pipeline is code, version it like code

README_Template.md

@@ -186,7 +186,7 @@ ModularPipelines takes a different approach: each unit of work is a self-contain
 * **Secret obfuscation** - Automatic masking in logs
 * **Hooks** - Run code before/after any module
 * **Skip conditions** - Dynamically skip modules based on custom logic
-* **Retry policies** - Configurable retry with Polly integration
+* **Resilience shields** - Configurable retries and advanced Kevlar integration
 * **Requirements validation** - Check prerequisites before running
 * **Progress reporting** - Real-time console output with parallel execution visualization
 * **Source controlled** - Your pipeline is code, version it like code

docs/docs/architecture/module-execution-lifecycle.md

@@ -24,7 +24,7 @@ For a module that runs successfully, the phases are:
 11. Attribute `IModuleEndHandler` handlers run sequentially by priority.
 12. The module result is published and dependants become eligible.
 
-`OnBeforeExecuteAsync` and `OnAfterExecuteAsync` wrap the complete retry policy, not each
+`OnBeforeExecuteAsync` and `OnAfterExecuteAsync` wrap the complete resilience shield, not each
 individual attempt.
 
 ## Skipped modules

docs/docs/how-to/defining-modules.md

@@ -92,7 +92,7 @@ public class MyModule : Module<FileInfo>
 |--------|-------------|
 | `.WithTimeout(TimeSpan)` | Maximum execution time before module is cancelled |
 | `.WithRetry(int, TimeSpan?, Func<Exception, bool>?)` | Retry attempts, jittered base delay, and optional exception filter |
-| `.Advanced.WithRetryPolicy(IAsyncPolicy)` | Custom Polly policy for advanced scenarios |
+| `.Advanced.WithShield(Shield)` | Custom Kevlar resilience shield for advanced scenarios |
 | `.WithSkipWhen(...)` | Condition to skip the module |
 | `.WithIgnoreFailures()` | Don't fail the pipeline if this module fails |
 | `.WithIgnoreFailuresWhen(...)` | Conditionally ignore failures |

docs/docs/how-to/hooks.md

@@ -139,7 +139,7 @@ The order for a successful module is:
 3. Global `OnModuleStartAsync`
 4. Attribute `IModuleStartHandler`
 5. Module `OnBeforeExecuteAsync`
-6. Module `ExecuteAsync` with its retry policy
+6. Module `ExecuteAsync` through its configured resilience shield
 7. Module `OnAfterExecuteAsync`
 8. Global `OnModuleEndAsync`
 9. Attribute `IModuleEndHandler`

docs/docs/how-to/retry-policy.md

@@ -1,9 +1,9 @@
 ---
-title: Retry Policies
+title: Retries and Resilience Shields
 sidebar_position: 6
 ---
 
-# Retry Policies
+# Retries and Resilience Shields
 
 When creating modules, you can configure retries per module using the `Configure()` method.
 The standard API supports exponential backoff, jitter, and exception filtering without exposing
@@ -42,18 +42,18 @@ protected override ModuleConfiguration Configure() => ModuleConfiguration.Create
     .Build();
 ```
 
-### Advanced Polly Policy
+### Advanced Resilience Shield
 
-For policy features outside the standard API, use the explicit `.Advanced` surface:
+For resilience features outside the standard API, use a Kevlar `Shield` through the explicit `.Advanced` surface:
 
 ```csharp
 public class MyModule : Module<CommandResult>
 {
     protected override ModuleConfiguration Configure() => ModuleConfiguration.Create()
         .Advanced
-        .WithRetryPolicy(
-            Policy.Handle<HttpRequestException>()
-                .WaitAndRetryAsync(5, i => TimeSpan.FromSeconds(i * i)))
+        .WithShield(
+            Shield.When<HttpRequestException>()
+                .Retry(5, Backoff.Custom(i => TimeSpan.FromSeconds(i * i))))
         .Build();
 
     protected override async Task<CommandResult> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
@@ -63,28 +63,28 @@ public class MyModule : Module<CommandResult>
 }
 ```
 
-### Context-Aware Retry Policy
+### Context-Aware Resilience Shield
 
-If you need access to the pipeline context when building your policy:
+If you need access to the pipeline context when building your shield:
 
 ```csharp
 public class MyModule : Module<CommandResult>
 {
     protected override ModuleConfiguration Configure() => ModuleConfiguration.Create()
         .Advanced
-        .WithRetryPolicy(ctx =>
+        .WithShield(ctx =>
         {
             var retryCount = ctx.Environment.IsCI ? 5 : 2;
-            return Policy.Handle<Exception>()
-                .WaitAndRetryAsync(retryCount, i => TimeSpan.FromSeconds(i));
+            return Shield.When<Exception>()
+                .Retry(retryCount, Backoff.Custom(i => TimeSpan.FromSeconds(i)));
         })
         .Build();
 }
 ```
 
 ## Combining with Other Behaviors
 
-Retry policies can be combined with other module behaviors:
+Retry configuration can be combined with other module behaviors:
 
 ```csharp
 public class ResilientModule : Module<CommandResult>
@@ -97,9 +97,9 @@ public class ResilientModule : Module<CommandResult>
 }
 ```
 
-## Default Retry Policy
+## Default Retry Configuration
 
-Retry policies are off by default. You can set a default retry count on the `PipelineOptions`:
+Retries are off by default. You can set a default retry count on the `PipelineOptions`:
 
 ```csharp
 var builder = Pipeline.CreateBuilder(args);
@@ -117,4 +117,4 @@ builder.ConfigurePipelineOptions(options => options with
 await builder.ExecutePipelineAsync();
 ```
 
-This applies to all modules that don't override their retry policy. Modules can override this default by configuring their own retry policy in `Configure()`.
+This applies to all modules that don't override their retry configuration. Modules can override this default by configuring retries in `Configure()`.

docs/docs/migrating-to-v3.md

@@ -240,7 +240,7 @@ public class MyModule : Module<string>
 | V2 Override | V3 Configure() Method |
 |-------------|----------------------|
 | `TimeSpan Timeout` property | `.WithTimeout(TimeSpan)` |
-| `AsyncRetryPolicy<T?> RetryPolicy` property | `.WithRetry(int, ...)` or `.Advanced.WithRetryPolicy(IAsyncPolicy)` |
+| `AsyncRetryPolicy<T?> RetryPolicy` property | `.WithRetry(int, ...)` or `.Advanced.WithShield(Shield)` |
 | `Task<SkipDecision> ShouldSkip()` method | `.WithSkipWhen(...)` |
 | `Task<bool> ShouldIgnoreFailures()` method | `.WithIgnoreFailures()` or `.WithIgnoreFailuresWhen(...)` |
 | `ModuleRunType.AlwaysRun` | `.WithAlwaysRun()` |
@@ -867,7 +867,7 @@ The following have been removed in V3:
 | `ShouldIgnoreFailures()` method | `Configure().WithIgnoreFailures()` |
 | `ModuleRunType` property | `Configure().WithAlwaysRun()` |
 | `Timeout` property | `Configure().WithTimeout()` |
-| `RetryPolicy` property | `Configure().WithRetry()` or `.Advanced.WithRetryPolicy()` |
+| `RetryPolicy` property | `Configure().WithRetry()` or `.Advanced.WithShield()` |
 | `GetModule<T>()` on module | `context.GetModule<TModule>()` |
 
 ## New Features in V3

src/ModularPipelines.Build/Modules/UnitTests/RunUnitTestModule.cs

@@ -1,4 +1,5 @@
 using System.Text.RegularExpressions;
+using Kevlar;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using ModularPipelines;
@@ -14,7 +15,6 @@
 using ModularPipelines.Models;
 using ModularPipelines.Modules;
 using ModularPipelines.Options;
-using Polly;
 using Spectre.Console;
 using File = ModularPipelines.FileSystem.File;
 
@@ -40,7 +40,7 @@ public abstract partial class RunUnitTestModule(IOptions<PipelineSettings> pipel
     protected override ModuleConfiguration Configure() => ModuleConfiguration.Create()
         .WithSkipWhen(GetSkipDecision)
         .Advanced
-        .WithRetryPolicy(Policy.Handle<Exception>().RetryAsync(0))
+        .WithShield(Shield.Retry(0))
         .Build();
 
     protected virtual SkipDecision GetSkipDecision(IModuleContext context) => SkipDecision.DoNotSkip;

src/ModularPipelines/Configuration/AdvancedModuleConfigurationBuilder.cs

@@ -1,10 +1,10 @@
+using Kevlar;
 using ModularPipelines.Context;
-using Polly;
 
 namespace ModularPipelines.Configuration;
 
 /// <summary>
-/// Provides advanced module configuration that depends on third-party policy abstractions.
+/// Provides advanced module configuration using Kevlar resilience shields.
 /// </summary>
 public sealed class AdvancedModuleConfigurationBuilder
 {
@@ -16,24 +16,24 @@ internal AdvancedModuleConfigurationBuilder(ModuleConfigurationBuilder builder)
     }
 
     /// <summary>
-    /// Sets a custom Polly async policy for module execution.
+    /// Sets a custom Kevlar shield for module execution.
     /// </summary>
-    /// <param name="policy">The Polly async policy to execute around the module.</param>
+    /// <param name="shield">The Kevlar shield to execute around the module.</param>
     /// <returns>The parent module configuration builder.</returns>
-    public ModuleConfigurationBuilder WithRetryPolicy(IAsyncPolicy policy)
+    public ModuleConfigurationBuilder WithShield(Shield shield)
     {
-        ArgumentNullException.ThrowIfNull(policy);
-        return _builder.SetAdvancedRetryPolicy(_ => policy);
+        ArgumentNullException.ThrowIfNull(shield);
+        return _builder.SetResilienceShield(_ => shield);
     }
 
     /// <summary>
-    /// Sets a factory that creates a custom Polly async policy from the module context.
+    /// Sets a factory that creates a custom Kevlar shield from the module context.
     /// </summary>
-    /// <param name="factory">The policy factory.</param>
+    /// <param name="factory">The shield factory.</param>
     /// <returns>The parent module configuration builder.</returns>
-    public ModuleConfigurationBuilder WithRetryPolicy(Func<IModuleContext, IAsyncPolicy> factory)
+    public ModuleConfigurationBuilder WithShield(Func<IModuleContext, Shield> factory)
     {
         ArgumentNullException.ThrowIfNull(factory);
-        return _builder.SetAdvancedRetryPolicy(factory);
+        return _builder.SetResilienceShield(factory);
     }
 }

src/ModularPipelines/Configuration/ModuleConfiguration.cs

@@ -1,8 +1,8 @@
 using System.Collections.Frozen;
+using Kevlar;
 using ModularPipelines.Context;
 using ModularPipelines.Enums;
 using ModularPipelines.Models;
-using Polly;
 
 namespace ModularPipelines.Configuration;
 
@@ -158,7 +158,7 @@ public sealed class ModuleConfiguration
     internal ModuleRetryConfiguration? RetryConfiguration { get; init; }
 
     /// <summary>
-    /// Gets the advanced policy factory for module execution.
+    /// Gets the resilience shield factory for module execution.
     /// </summary>
-    internal Func<IModuleContext, IAsyncPolicy>? AdvancedRetryPolicyFactory { get; init; }
+    internal Func<IModuleContext, Shield>? ResilienceShieldFactory { get; init; }
 }

src/ModularPipelines/Configuration/ModuleConfigurationAttributeAdapter.cs

@@ -39,7 +39,7 @@ public static ModuleConfiguration Apply(
             PlanningSkipCondition = configured.PlanningSkipCondition,
             Timeout = configured.Timeout,
             RetryConfiguration = configured.RetryConfiguration,
-            AdvancedRetryPolicyFactory = configured.AdvancedRetryPolicyFactory,
+            ResilienceShieldFactory = configured.ResilienceShieldFactory,
             IgnoreFailuresCondition = configured.IgnoreFailuresCondition,
             AlwaysRun = configured.AlwaysRun,
             ParallelConstraintKeys = configured.ParallelConstraintKeys

src/ModularPipelines/Configuration/ModuleConfigurationBuilder.cs

@@ -1,10 +1,10 @@
+using Kevlar;
 using ModularPipelines.Context;
 using ModularPipelines.Engine;
 using ModularPipelines.Enums;
 using ModularPipelines.Exceptions;
 using ModularPipelines.Models;
 using ModularPipelines.Modules;
-using Polly;
 
 namespace ModularPipelines.Configuration;
 
@@ -45,7 +45,7 @@ public sealed class ModuleConfigurationBuilder
     private string? _cacheAssemblyVersionKey;
     private TimeSpan? _timeout;
     private ModuleRetryConfiguration? _retryConfiguration;
-    private Func<IModuleContext, IAsyncPolicy>? _advancedRetryPolicyFactory;
+    private Func<IModuleContext, Shield>? _resilienceShieldFactory;
     private Func<IModuleContext, Exception, Task<bool>>? _ignoreFailuresCondition;
     private bool _alwaysRun;
     private string[]? _parallelConstraintKeys;
@@ -364,7 +364,7 @@ public ModuleConfigurationBuilder WithRetry(
         }
 
         _retryConfiguration = new ModuleRetryConfiguration(count, retryBaseDelay, shouldRetry);
-        _advancedRetryPolicyFactory = null;
+        _resilienceShieldFactory = null;
         return this;
     }
 
@@ -432,7 +432,7 @@ public ModuleConfiguration Build()
             PlanningSkipCondition = ComposePlanningSkipConditions(),
             Timeout = _timeout,
             RetryConfiguration = _retryConfiguration,
-            AdvancedRetryPolicyFactory = _advancedRetryPolicyFactory,
+            ResilienceShieldFactory = _resilienceShieldFactory,
             IgnoreFailuresCondition = _ignoreFailuresCondition,
             AlwaysRun = _alwaysRun,
             ParallelConstraintKeys = _parallelConstraintKeys,
@@ -447,9 +447,9 @@ public ModuleConfiguration Build()
         };
     }
 
-    internal ModuleConfigurationBuilder SetAdvancedRetryPolicy(Func<IModuleContext, IAsyncPolicy> factory)
+    internal ModuleConfigurationBuilder SetResilienceShield(Func<IModuleContext, Shield> factory)
     {
-        _advancedRetryPolicyFactory = factory;
+        _resilienceShieldFactory = factory;
         _retryConfiguration = null;
         return this;
     }

src/ModularPipelines/Configuration/ModuleRetryPolicyFactory.cs → src/ModularPipelines/Configuration/ModuleRetryShieldFactory.cs

@@ -1,21 +1,19 @@
-using Polly;
+using Kevlar;
 
 namespace ModularPipelines.Configuration;
 
-internal static class ModuleRetryPolicyFactory
+internal static class ModuleRetryShieldFactory
 {
-    internal static IAsyncPolicy Create(ModuleRetryConfiguration configuration)
+    internal static Shield Create(ModuleRetryConfiguration configuration)
     {
-        var policyBuilder = configuration.ShouldRetry is null
-            ? Policy.Handle<Exception>()
-            : Policy.Handle<Exception>(configuration.ShouldRetry);
-
-        return policyBuilder.WaitAndRetryAsync(
-            configuration.Count,
-            retryAttempt => CalculateDelay(
-                retryAttempt,
-                configuration.BaseDelay,
-                Random.Shared.NextDouble()));
+        return Shield
+            .When(configuration.ShouldRetry ?? (static _ => true))
+            .Retry(
+                configuration.Count,
+                Backoff.Custom(retryAttempt => CalculateDelay(
+                    retryAttempt,
+                    configuration.BaseDelay,
+                    Random.Shared.NextDouble())));
     }
 
     internal static TimeSpan CalculateDelay(