feat: Enhance Task Runner with simulation and failure policy support

- Added tests for output projection and failure policy population in TaskPackPlanner.
- Introduced new failure policy manifest in TestManifests.
- Implemented simulation endpoints in the web service for task execution.
- Created TaskRunnerServiceOptions for configuration management.
- Updated appsettings.json to include TaskRunner configuration.
- Enhanced PackRunWorkerService to handle execution graphs and state management.
- Added support for parallel execution and conditional steps in the worker service.
- Updated documentation to reflect new features and changes in execution flow.

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/IPackRunStepExecutor.cs

@@ -0,0 +1,13 @@
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public interface IPackRunStepExecutor
+{
+    Task<PackRunStepExecutionResult> ExecuteAsync(
+        PackRunExecutionStep step,
+        IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters,
+        CancellationToken cancellationToken);
+}
+
+public sealed record PackRunStepExecutionResult(bool Succeeded, string? Error = null);

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/PackRunExecutionGraph.cs

@@ -0,0 +1,86 @@
+using System.Collections.ObjectModel;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public sealed class PackRunExecutionGraph
+{
+    public static readonly TaskPackPlanFailurePolicy DefaultFailurePolicy = new(1, 0, ContinueOnError: false);
+
+    public PackRunExecutionGraph(IReadOnlyList<PackRunExecutionStep> steps, TaskPackPlanFailurePolicy? failurePolicy)
+    {
+        Steps = steps ?? throw new ArgumentNullException(nameof(steps));
+        FailurePolicy = failurePolicy ?? DefaultFailurePolicy;
+    }
+
+    public IReadOnlyList<PackRunExecutionStep> Steps { get; }
+
+    public TaskPackPlanFailurePolicy FailurePolicy { get; }
+}
+
+public enum PackRunStepKind
+{
+    Unknown = 0,
+    Run,
+    GateApproval,
+    GatePolicy,
+    Parallel,
+    Map
+}
+
+public sealed class PackRunExecutionStep
+{
+    public PackRunExecutionStep(
+        string id,
+        string templateId,
+        PackRunStepKind kind,
+        bool enabled,
+        string? uses,
+        IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters,
+        string? approvalId,
+        string? gateMessage,
+        int? maxParallel,
+        bool continueOnError,
+        IReadOnlyList<PackRunExecutionStep> children)
+    {
+        Id = string.IsNullOrWhiteSpace(id) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(id)) : id;
+        TemplateId = string.IsNullOrWhiteSpace(templateId) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(templateId)) : templateId;
+        Kind = kind;
+        Enabled = enabled;
+        Uses = uses;
+        Parameters = parameters ?? throw new ArgumentNullException(nameof(parameters));
+        ApprovalId = approvalId;
+        GateMessage = gateMessage;
+        MaxParallel = maxParallel;
+        ContinueOnError = continueOnError;
+        Children = children ?? throw new ArgumentNullException(nameof(children));
+    }
+
+    public string Id { get; }
+
+    public string TemplateId { get; }
+
+    public PackRunStepKind Kind { get; }
+
+    public bool Enabled { get; }
+
+    public string? Uses { get; }
+
+    public IReadOnlyDictionary<string, TaskPackPlanParameterValue> Parameters { get; }
+
+    public string? ApprovalId { get; }
+
+    public string? GateMessage { get; }
+
+    public int? MaxParallel { get; }
+
+    public bool ContinueOnError { get; }
+
+    public IReadOnlyList<PackRunExecutionStep> Children { get; }
+
+    public static IReadOnlyDictionary<string, TaskPackPlanParameterValue> EmptyParameters { get; } =
+        new ReadOnlyDictionary<string, TaskPackPlanParameterValue>(new Dictionary<string, TaskPackPlanParameterValue>(StringComparer.Ordinal));
+
+    public static IReadOnlyList<PackRunExecutionStep> EmptyChildren { get; } =
+        Array.Empty<PackRunExecutionStep>();
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/PackRunExecutionGraphBuilder.cs

@@ -0,0 +1,77 @@
+using System.Collections.ObjectModel;
+using System.Text.Json.Nodes;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public sealed class PackRunExecutionGraphBuilder
+{
+    public PackRunExecutionGraph Build(TaskPackPlan plan)
+    {
+        ArgumentNullException.ThrowIfNull(plan);
+
+        var steps = plan.Steps.Select(ConvertStep).ToList();
+        var failurePolicy = plan.FailurePolicy;
+        return new PackRunExecutionGraph(steps, failurePolicy);
+    }
+
+    private static PackRunExecutionStep ConvertStep(TaskPackPlanStep step)
+    {
+        var kind = DetermineKind(step.Type);
+        var parameters = step.Parameters is null
+            ? PackRunExecutionStep.EmptyParameters
+            : new ReadOnlyDictionary<string, TaskPackPlanParameterValue>(
+                new Dictionary<string, TaskPackPlanParameterValue>(step.Parameters, StringComparer.Ordinal));
+
+        var children = step.Children is null
+            ? PackRunExecutionStep.EmptyChildren
+            : step.Children.Select(ConvertStep).ToList();
+
+        var maxParallel = TryGetInt(parameters, "maxParallel");
+        var continueOnError = TryGetBool(parameters, "continueOnError");
+
+        return new PackRunExecutionStep(
+            step.Id,
+            step.TemplateId,
+            kind,
+            step.Enabled,
+            step.Uses,
+            parameters,
+            step.ApprovalId,
+            step.GateMessage,
+            maxParallel,
+            continueOnError,
+            children);
+    }
+
+    private static PackRunStepKind DetermineKind(string? type)
+        => type switch
+        {
+            "run" => PackRunStepKind.Run,
+            "gate.approval" => PackRunStepKind.GateApproval,
+            "gate.policy" => PackRunStepKind.GatePolicy,
+            "parallel" => PackRunStepKind.Parallel,
+            "map" => PackRunStepKind.Map,
+            _ => PackRunStepKind.Unknown
+        };
+
+    private static int? TryGetInt(IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters, string key)
+    {
+        if (!parameters.TryGetValue(key, out var value) || value.Value is not JsonValue jsonValue)
+        {
+            return null;
+        }
+
+        return jsonValue.TryGetValue<int>(out var result) ? result : null;
+    }
+
+    private static bool TryGetBool(IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters, string key)
+    {
+        if (!parameters.TryGetValue(key, out var value) || value.Value is not JsonValue jsonValue)
+        {
+            return false;
+        }
+
+        return jsonValue.TryGetValue<bool>(out var result) && result;
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/PackRunGateStateUpdater.cs

@@ -0,0 +1,159 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public static class PackRunGateStateUpdater
+{
+    public static PackRunGateStateUpdateResult Apply(
+        PackRunState state,
+        PackRunExecutionGraph graph,
+        PackRunApprovalCoordinator coordinator,
+        DateTimeOffset timestamp)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        ArgumentNullException.ThrowIfNull(graph);
+        ArgumentNullException.ThrowIfNull(coordinator);
+
+        var approvals = coordinator.GetApprovals()
+            .SelectMany(approval => approval.StepIds.Select(stepId => (stepId, approval)))
+            .GroupBy(tuple => tuple.stepId, StringComparer.Ordinal)
+            .ToDictionary(
+                group => group.Key,
+                group => group.First().approval,
+                StringComparer.Ordinal);
+
+        var mutable = new Dictionary<string, PackRunStepStateRecord>(state.Steps, StringComparer.Ordinal);
+        var changed = false;
+        var hasBlockingFailure = false;
+
+        foreach (var step in EnumerateSteps(graph.Steps))
+        {
+            if (!mutable.TryGetValue(step.Id, out var record))
+            {
+                continue;
+            }
+
+            switch (step.Kind)
+            {
+                case PackRunStepKind.GateApproval:
+                    if (!approvals.TryGetValue(step.Id, out var approvalState))
+                    {
+                        continue;
+                    }
+
+                    switch (approvalState.Status)
+                    {
+                        case PackRunApprovalStatus.Pending:
+                            break;
+
+                        case PackRunApprovalStatus.Approved:
+                            if (record.Status != PackRunStepExecutionStatus.Succeeded || record.StatusReason is not null)
+                            {
+                                mutable[step.Id] = record with
+                                {
+                                    Status = PackRunStepExecutionStatus.Succeeded,
+                                    StatusReason = null,
+                                    LastTransitionAt = timestamp,
+                                    NextAttemptAt = null
+                                };
+                                changed = true;
+                            }
+
+                            break;
+
+                        case PackRunApprovalStatus.Rejected:
+                        case PackRunApprovalStatus.Expired:
+                            var failureReason = BuildFailureReason(approvalState);
+                            if (record.Status != PackRunStepExecutionStatus.Failed ||
+                                !string.Equals(record.StatusReason, failureReason, StringComparison.Ordinal))
+                            {
+                                mutable[step.Id] = record with
+                                {
+                                    Status = PackRunStepExecutionStatus.Failed,
+                                    StatusReason = failureReason,
+                                    LastTransitionAt = timestamp,
+                                    NextAttemptAt = null
+                                };
+                                changed = true;
+                            }
+
+                            hasBlockingFailure = true;
+                            break;
+                    }
+
+                    break;
+
+                case PackRunStepKind.GatePolicy:
+                    if (record.Status == PackRunStepExecutionStatus.Pending &&
+                        string.Equals(record.StatusReason, "requires-policy", StringComparison.Ordinal))
+                    {
+                        mutable[step.Id] = record with
+                        {
+                            Status = PackRunStepExecutionStatus.Succeeded,
+                            StatusReason = null,
+                            LastTransitionAt = timestamp,
+                            NextAttemptAt = null
+                        };
+                        changed = true;
+                    }
+
+                    break;
+            }
+        }
+
+        if (!changed)
+        {
+            return new PackRunGateStateUpdateResult(state, hasBlockingFailure);
+        }
+
+        var updatedState = state with
+        {
+            UpdatedAt = timestamp,
+            Steps = new ReadOnlyDictionary<string, PackRunStepStateRecord>(mutable)
+        };
+
+        return new PackRunGateStateUpdateResult(updatedState, hasBlockingFailure);
+    }
+
+    private static IEnumerable<PackRunExecutionStep> EnumerateSteps(IReadOnlyList<PackRunExecutionStep> steps)
+    {
+        if (steps.Count == 0)
+        {
+            yield break;
+        }
+
+        foreach (var step in steps)
+        {
+            yield return step;
+
+            if (step.Children.Count > 0)
+            {
+                foreach (var child in EnumerateSteps(step.Children))
+                {
+                    yield return child;
+                }
+            }
+        }
+    }
+
+    private static string BuildFailureReason(PackRunApprovalState state)
+    {
+        var baseReason = state.Status switch
+        {
+            PackRunApprovalStatus.Rejected => "approval-rejected",
+            PackRunApprovalStatus.Expired => "approval-expired",
+            _ => "approval-invalid"
+        };
+
+        if (string.IsNullOrWhiteSpace(state.Summary))
+        {
+            return baseReason;
+        }
+
+        var summary = state.Summary.Trim();
+        return $"{baseReason}:{summary}";
+    }
+}
+
+public readonly record struct PackRunGateStateUpdateResult(PackRunState State, bool HasBlockingFailure);

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/PackRunState.cs

@@ -0,0 +1,50 @@
+using System.Collections.ObjectModel;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public sealed record PackRunState(
+    string RunId,
+    string PlanHash,
+    TaskPackPlanFailurePolicy FailurePolicy,
+    DateTimeOffset CreatedAt,
+    DateTimeOffset UpdatedAt,
+    IReadOnlyDictionary<string, PackRunStepStateRecord> Steps)
+{
+    public static PackRunState Create(
+        string runId,
+        string planHash,
+        TaskPackPlanFailurePolicy failurePolicy,
+        IReadOnlyDictionary<string, PackRunStepStateRecord> steps,
+        DateTimeOffset timestamp)
+        => new(
+            runId,
+            planHash,
+            failurePolicy,
+            timestamp,
+            timestamp,
+            new ReadOnlyDictionary<string, PackRunStepStateRecord>(new Dictionary<string, PackRunStepStateRecord>(steps, StringComparer.Ordinal)));
+}
+
+public sealed record PackRunStepStateRecord(
+    string StepId,
+    PackRunStepKind Kind,
+    bool Enabled,
+    bool ContinueOnError,
+    int? MaxParallel,
+    string? ApprovalId,
+    string? GateMessage,
+    PackRunStepExecutionStatus Status,
+    int Attempts,
+    DateTimeOffset? LastTransitionAt,
+    DateTimeOffset? NextAttemptAt,
+    string? StatusReason);
+
+public interface IPackRunStateStore
+{
+    Task<PackRunState?> GetAsync(string runId, CancellationToken cancellationToken);
+
+    Task SaveAsync(PackRunState state, CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<PackRunState>> ListAsync(CancellationToken cancellationToken);
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/PackRunStepStateMachine.cs

@@ -0,0 +1,121 @@
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution;
+
+public static class PackRunStepStateMachine
+{
+    public static PackRunStepState Create(DateTimeOffset? createdAt = null)
+        => new(PackRunStepExecutionStatus.Pending, Attempts: 0, createdAt, NextAttemptAt: null);
+
+    public static PackRunStepState Start(PackRunStepState state, DateTimeOffset startedAt)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        if (state.Status is not PackRunStepExecutionStatus.Pending)
+        {
+            throw new InvalidOperationException($"Cannot start step from status {state.Status}.");
+        }
+
+        return state with
+        {
+            Status = PackRunStepExecutionStatus.Running,
+            LastTransitionAt = startedAt,
+            NextAttemptAt = null
+        };
+    }
+
+    public static PackRunStepState CompleteSuccess(PackRunStepState state, DateTimeOffset completedAt)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        if (state.Status is not PackRunStepExecutionStatus.Running)
+        {
+            throw new InvalidOperationException($"Cannot complete step from status {state.Status}.");
+        }
+
+        return state with
+        {
+            Status = PackRunStepExecutionStatus.Succeeded,
+            Attempts = state.Attempts + 1,
+            LastTransitionAt = completedAt,
+            NextAttemptAt = null
+        };
+    }
+
+    public static PackRunStepFailureResult RegisterFailure(
+        PackRunStepState state,
+        DateTimeOffset failedAt,
+        TaskPackPlanFailurePolicy failurePolicy)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        ArgumentNullException.ThrowIfNull(failurePolicy);
+
+        if (state.Status is not PackRunStepExecutionStatus.Running)
+        {
+            throw new InvalidOperationException($"Cannot register failure from status {state.Status}.");
+        }
+
+        var attempts = state.Attempts + 1;
+        if (attempts < failurePolicy.MaxAttempts)
+        {
+            var backoff = TimeSpan.FromSeconds(Math.Max(0, failurePolicy.BackoffSeconds));
+            var nextAttemptAt = failedAt + backoff;
+            var nextState = state with
+            {
+                Status = PackRunStepExecutionStatus.Pending,
+                Attempts = attempts,
+                LastTransitionAt = failedAt,
+                NextAttemptAt = nextAttemptAt
+            };
+
+            return new PackRunStepFailureResult(nextState, PackRunStepFailureOutcome.Retry);
+        }
+
+        var finalState = state with
+        {
+            Status = PackRunStepExecutionStatus.Failed,
+            Attempts = attempts,
+            LastTransitionAt = failedAt,
+            NextAttemptAt = null
+        };
+
+        return new PackRunStepFailureResult(finalState, PackRunStepFailureOutcome.Abort);
+    }
+
+    public static PackRunStepState Skip(PackRunStepState state, DateTimeOffset skippedAt)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        if (state.Status is not PackRunStepExecutionStatus.Pending)
+        {
+            throw new InvalidOperationException($"Cannot skip step from status {state.Status}.");
+        }
+
+        return state with
+        {
+            Status = PackRunStepExecutionStatus.Skipped,
+            LastTransitionAt = skippedAt,
+            NextAttemptAt = null
+        };
+    }
+}
+
+public sealed record PackRunStepState(
+    PackRunStepExecutionStatus Status,
+    int Attempts,
+    DateTimeOffset? LastTransitionAt,
+    DateTimeOffset? NextAttemptAt);
+
+public enum PackRunStepExecutionStatus
+{
+    Pending = 0,
+    Running,
+    Succeeded,
+    Failed,
+    Skipped
+}
+
+public readonly record struct PackRunStepFailureResult(PackRunStepState State, PackRunStepFailureOutcome Outcome);
+
+public enum PackRunStepFailureOutcome
+{
+    Retry = 0,
+    Abort
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/Simulation/PackRunSimulationEngine.cs

@@ -0,0 +1,78 @@
+using System.Collections.ObjectModel;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution.Simulation;
+
+public sealed class PackRunSimulationEngine
+{
+    private readonly PackRunExecutionGraphBuilder graphBuilder;
+
+    public PackRunSimulationEngine()
+    {
+        graphBuilder = new PackRunExecutionGraphBuilder();
+    }
+
+    public PackRunSimulationResult Simulate(TaskPackPlan plan)
+    {
+        ArgumentNullException.ThrowIfNull(plan);
+
+        var graph = graphBuilder.Build(plan);
+        var steps = graph.Steps.Select(ConvertStep).ToList();
+        var outputs = BuildOutputs(plan.Outputs);
+
+        return new PackRunSimulationResult(steps, outputs, graph.FailurePolicy);
+    }
+
+    private static PackRunSimulationNode ConvertStep(PackRunExecutionStep step)
+    {
+        var status = DetermineStatus(step);
+        var children = step.Children.Count == 0
+            ? PackRunSimulationNode.Empty
+            : new ReadOnlyCollection<PackRunSimulationNode>(step.Children.Select(ConvertStep).ToList());
+
+        return new PackRunSimulationNode(
+            step.Id,
+            step.TemplateId,
+            step.Kind,
+            step.Enabled,
+            step.Uses,
+            step.ApprovalId,
+            step.GateMessage,
+            step.Parameters,
+            step.MaxParallel,
+            step.ContinueOnError,
+            status,
+            children);
+    }
+
+    private static PackRunSimulationStatus DetermineStatus(PackRunExecutionStep step)
+    {
+        if (!step.Enabled)
+        {
+            return PackRunSimulationStatus.Skipped;
+        }
+
+        return step.Kind switch
+        {
+            PackRunStepKind.GateApproval => PackRunSimulationStatus.RequiresApproval,
+            PackRunStepKind.GatePolicy => PackRunSimulationStatus.RequiresPolicy,
+            _ => PackRunSimulationStatus.Pending
+        };
+    }
+
+    private static IReadOnlyList<PackRunSimulationOutput> BuildOutputs(IReadOnlyList<TaskPackPlanOutput> outputs)
+    {
+        if (outputs.Count == 0)
+        {
+            return PackRunSimulationOutput.Empty;
+        }
+
+        var list = new List<PackRunSimulationOutput>(outputs.Count);
+        foreach (var output in outputs)
+        {
+            list.Add(new PackRunSimulationOutput(output.Name, output.Type, output.Path, output.Expression));
+        }
+
+        return new ReadOnlyCollection<PackRunSimulationOutput>(list);
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Execution/Simulation/PackRunSimulationModels.cs

@@ -0,0 +1,131 @@
+using System.Collections.ObjectModel;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Core.Execution.Simulation;
+
+public sealed class PackRunSimulationResult
+{
+    public PackRunSimulationResult(
+        IReadOnlyList<PackRunSimulationNode> steps,
+        IReadOnlyList<PackRunSimulationOutput> outputs,
+        TaskPackPlanFailurePolicy failurePolicy)
+    {
+        Steps = steps ?? throw new ArgumentNullException(nameof(steps));
+        Outputs = outputs ?? throw new ArgumentNullException(nameof(outputs));
+        FailurePolicy = failurePolicy ?? throw new ArgumentNullException(nameof(failurePolicy));
+    }
+
+    public IReadOnlyList<PackRunSimulationNode> Steps { get; }
+
+    public IReadOnlyList<PackRunSimulationOutput> Outputs { get; }
+
+    public TaskPackPlanFailurePolicy FailurePolicy { get; }
+
+    public bool HasPendingApprovals => Steps.Any(ContainsApprovalRequirement);
+
+    private static bool ContainsApprovalRequirement(PackRunSimulationNode node)
+    {
+        if (node.Status is PackRunSimulationStatus.RequiresApproval or PackRunSimulationStatus.RequiresPolicy)
+        {
+            return true;
+        }
+
+        return node.Children.Any(ContainsApprovalRequirement);
+    }
+}
+
+public sealed class PackRunSimulationNode
+{
+    public PackRunSimulationNode(
+        string id,
+        string templateId,
+        PackRunStepKind kind,
+        bool enabled,
+        string? uses,
+        string? approvalId,
+        string? gateMessage,
+        IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters,
+        int? maxParallel,
+        bool continueOnError,
+        PackRunSimulationStatus status,
+        IReadOnlyList<PackRunSimulationNode> children)
+    {
+        Id = string.IsNullOrWhiteSpace(id) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(id)) : id;
+        TemplateId = string.IsNullOrWhiteSpace(templateId) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(templateId)) : templateId;
+        Kind = kind;
+        Enabled = enabled;
+        Uses = uses;
+        ApprovalId = approvalId;
+        GateMessage = gateMessage;
+        Parameters = parameters ?? throw new ArgumentNullException(nameof(parameters));
+        MaxParallel = maxParallel;
+        ContinueOnError = continueOnError;
+        Status = status;
+        Children = children ?? throw new ArgumentNullException(nameof(children));
+    }
+
+    public string Id { get; }
+
+    public string TemplateId { get; }
+
+    public PackRunStepKind Kind { get; }
+
+    public bool Enabled { get; }
+
+    public string? Uses { get; }
+
+    public string? ApprovalId { get; }
+
+    public string? GateMessage { get; }
+
+    public IReadOnlyDictionary<string, TaskPackPlanParameterValue> Parameters { get; }
+
+    public int? MaxParallel { get; }
+
+    public bool ContinueOnError { get; }
+
+    public PackRunSimulationStatus Status { get; }
+
+    public IReadOnlyList<PackRunSimulationNode> Children { get; }
+
+    public static IReadOnlyList<PackRunSimulationNode> Empty { get; } =
+        new ReadOnlyCollection<PackRunSimulationNode>(Array.Empty<PackRunSimulationNode>());
+}
+
+public enum PackRunSimulationStatus
+{
+    Pending = 0,
+    Skipped,
+    RequiresApproval,
+    RequiresPolicy
+}
+
+public sealed class PackRunSimulationOutput
+{
+    public PackRunSimulationOutput(
+        string name,
+        string type,
+        TaskPackPlanParameterValue? path,
+        TaskPackPlanParameterValue? expression)
+    {
+        Name = string.IsNullOrWhiteSpace(name) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(name)) : name;
+        Type = string.IsNullOrWhiteSpace(type) ? throw new ArgumentException("Value cannot be null or whitespace.", nameof(type)) : type;
+        Path = path;
+        Expression = expression;
+    }
+
+    public string Name { get; }
+
+    public string Type { get; }
+
+    public TaskPackPlanParameterValue? Path { get; }
+
+    public TaskPackPlanParameterValue? Expression { get; }
+
+    public bool RequiresRuntimeValue =>
+        (Path?.RequiresRuntimeValue ?? false) ||
+        (Expression?.RequiresRuntimeValue ?? false);
+
+    public static IReadOnlyList<PackRunSimulationOutput> Empty { get; } =
+        new ReadOnlyCollection<PackRunSimulationOutput>(Array.Empty<PackRunSimulationOutput>());
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Planning/TaskPackPlan.cs

@@ -12,36 +12,40 @@ public sealed class TaskPackPlan
         IReadOnlyList<TaskPackPlanStep> steps,
         string hash,
         IReadOnlyList<TaskPackPlanApproval> approvals,
-        IReadOnlyList<TaskPackPlanSecret> secrets,
-        IReadOnlyList<TaskPackPlanOutput> outputs)
-    {
-        Metadata = metadata;
-        Inputs = inputs;
-        Steps = steps;
-        Hash = hash;
-        Approvals = approvals;
-        Secrets = secrets;
-        Outputs = outputs;
-    }
-
-    public TaskPackPlanMetadata Metadata { get; }
-
-    public IReadOnlyDictionary<string, JsonNode?> Inputs { get; }
+        IReadOnlyList<TaskPackPlanSecret> secrets,
+        IReadOnlyList<TaskPackPlanOutput> outputs,
+        TaskPackPlanFailurePolicy? failurePolicy)
+    {
+        Metadata = metadata;
+        Inputs = inputs;
+        Steps = steps;
+        Hash = hash;
+        Approvals = approvals;
+        Secrets = secrets;
+        Outputs = outputs;
+        FailurePolicy = failurePolicy;
+    }
+
+    public TaskPackPlanMetadata Metadata { get; }
+
+    public IReadOnlyDictionary<string, JsonNode?> Inputs { get; }
 
     public IReadOnlyList<TaskPackPlanStep> Steps { get; }
 
     public string Hash { get; }
 
     public IReadOnlyList<TaskPackPlanApproval> Approvals { get; }
-
-    public IReadOnlyList<TaskPackPlanSecret> Secrets { get; }
-
-    public IReadOnlyList<TaskPackPlanOutput> Outputs { get; }
-}
-
-public sealed record TaskPackPlanMetadata(string Name, string Version, string? Description, IReadOnlyList<string> Tags);
-
-public sealed record TaskPackPlanStep(
+
+    public IReadOnlyList<TaskPackPlanSecret> Secrets { get; }
+
+    public IReadOnlyList<TaskPackPlanOutput> Outputs { get; }
+
+    public TaskPackPlanFailurePolicy? FailurePolicy { get; }
+}
+
+public sealed record TaskPackPlanMetadata(string Name, string Version, string? Description, IReadOnlyList<string> Tags);
+
+public sealed record TaskPackPlanStep(
     string Id,
     string TemplateId,
     string? Name,
@@ -71,11 +75,16 @@ public sealed record TaskPackPlanApproval(
 
 public sealed record TaskPackPlanSecret(string Name, string Scope, string? Description);
 
-public sealed record TaskPackPlanOutput(
-    string Name,
-    string Type,
-    TaskPackPlanParameterValue? Path,
-    TaskPackPlanParameterValue? Expression);
+public sealed record TaskPackPlanOutput(
+    string Name,
+    string Type,
+    TaskPackPlanParameterValue? Path,
+    TaskPackPlanParameterValue? Expression);
+
+public sealed record TaskPackPlanFailurePolicy(
+    int MaxAttempts,
+    int BackoffSeconds,
+    bool ContinueOnError);
 
 public sealed class TaskPackPlanResult
 {

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Planning/TaskPackPlanHasher.cs

@@ -13,13 +13,14 @@ internal static class TaskPackPlanHasher
         IReadOnlyDictionary<string, JsonNode?> inputs,
         IReadOnlyList<TaskPackPlanStep> steps,
         IReadOnlyList<TaskPackPlanApproval> approvals,
-        IReadOnlyList<TaskPackPlanSecret> secrets,
-        IReadOnlyList<TaskPackPlanOutput> outputs)
-    {
-        var canonical = new CanonicalPlan(
-            new CanonicalMetadata(metadata.Name, metadata.Version, metadata.Description, metadata.Tags),
-            inputs.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.Ordinal),
-            steps.Select(ToCanonicalStep).ToList(),
+        IReadOnlyList<TaskPackPlanSecret> secrets,
+        IReadOnlyList<TaskPackPlanOutput> outputs,
+        TaskPackPlanFailurePolicy? failurePolicy)
+    {
+        var canonical = new CanonicalPlan(
+            new CanonicalMetadata(metadata.Name, metadata.Version, metadata.Description, metadata.Tags),
+            inputs.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.Ordinal),
+            steps.Select(ToCanonicalStep).ToList(),
             approvals
                 .OrderBy(a => a.Id, StringComparer.Ordinal)
                 .Select(a => new CanonicalApproval(a.Id, a.Grants.OrderBy(g => g, StringComparer.Ordinal).ToList(), a.ExpiresAfter, a.ReasonTemplate))
@@ -27,16 +28,19 @@ internal static class TaskPackPlanHasher
             secrets
                 .OrderBy(s => s.Name, StringComparer.Ordinal)
                 .Select(s => new CanonicalSecret(s.Name, s.Scope, s.Description))
-                .ToList(),
-            outputs
-                .OrderBy(o => o.Name, StringComparer.Ordinal)
-                .Select(ToCanonicalOutput)
-                .ToList());
-
-        var json = CanonicalJson.Serialize(canonical);
-        using var sha256 = SHA256.Create();
-        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(json));
-        return ConvertToHex(hashBytes);
+                .ToList(),
+            outputs
+                .OrderBy(o => o.Name, StringComparer.Ordinal)
+                .Select(ToCanonicalOutput)
+                .ToList(),
+            failurePolicy is null
+                ? null
+                : new CanonicalFailurePolicy(failurePolicy.MaxAttempts, failurePolicy.BackoffSeconds, failurePolicy.ContinueOnError));
+
+        var json = CanonicalJson.Serialize(canonical);
+        using var sha256 = SHA256.Create();
+        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(json));
+        return ConvertToHex(hashBytes);
     }
 
     private static string ConvertToHex(byte[] hashBytes)
@@ -66,13 +70,14 @@ internal static class TaskPackPlanHasher
             step.GateMessage,
             step.Children?.Select(ToCanonicalStep).ToList());
 
-    private sealed record CanonicalPlan(
-        CanonicalMetadata Metadata,
-        IDictionary<string, JsonNode?> Inputs,
-        IReadOnlyList<CanonicalPlanStep> Steps,
-        IReadOnlyList<CanonicalApproval> Approvals,
-        IReadOnlyList<CanonicalSecret> Secrets,
-        IReadOnlyList<CanonicalOutput> Outputs);
+    private sealed record CanonicalPlan(
+        CanonicalMetadata Metadata,
+        IDictionary<string, JsonNode?> Inputs,
+        IReadOnlyList<CanonicalPlanStep> Steps,
+        IReadOnlyList<CanonicalApproval> Approvals,
+        IReadOnlyList<CanonicalSecret> Secrets,
+        IReadOnlyList<CanonicalOutput> Outputs,
+        CanonicalFailurePolicy? FailurePolicy);
 
     private sealed record CanonicalMetadata(string Name, string Version, string? Description, IReadOnlyList<string> Tags);
 
@@ -92,13 +97,15 @@ internal static class TaskPackPlanHasher
 
     private sealed record CanonicalSecret(string Name, string Scope, string? Description);
 
-    private sealed record CanonicalParameter(JsonNode? Value, string? Expression, string? Error, bool RequiresRuntimeValue);
-
-    private sealed record CanonicalOutput(
-        string Name,
-        string Type,
-        CanonicalParameter? Path,
-        CanonicalParameter? Expression);
+    private sealed record CanonicalParameter(JsonNode? Value, string? Expression, string? Error, bool RequiresRuntimeValue);
+
+    private sealed record CanonicalOutput(
+        string Name,
+        string Type,
+        CanonicalParameter? Path,
+        CanonicalParameter? Expression);
+
+    private sealed record CanonicalFailurePolicy(int MaxAttempts, int BackoffSeconds, bool ContinueOnError);
 
     private static CanonicalOutput ToCanonicalOutput(TaskPackPlanOutput output)
         => new(

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Core/Planning/TaskPackPlanner.cs

@@ -98,14 +98,16 @@ public sealed class TaskPackPlanner
             return new TaskPackPlanResult(null, errors.ToImmutable());
         }
 
-        var hash = TaskPackPlanHasher.ComputeHash(metadata, effectiveInputs, planSteps, planApprovals, planSecrets, planOutputs);
-
-        var plan = new TaskPackPlan(metadata, effectiveInputs, planSteps, hash, planApprovals, planSecrets, planOutputs);
-        return new TaskPackPlanResult(plan, ImmutableArray<TaskPackPlanError>.Empty);
-    }
-
-    private Dictionary<string, JsonNode?> MaterializeInputs(
-        IReadOnlyList<TaskPackInput>? definitions,
+        var failurePolicy = MaterializeFailurePolicy(manifest.Spec.Failure);
+
+        var hash = TaskPackPlanHasher.ComputeHash(metadata, effectiveInputs, planSteps, planApprovals, planSecrets, planOutputs, failurePolicy);
+
+        var plan = new TaskPackPlan(metadata, effectiveInputs, planSteps, hash, planApprovals, planSecrets, planOutputs, failurePolicy);
+        return new TaskPackPlanResult(plan, ImmutableArray<TaskPackPlanError>.Empty);
+    }
+
+    private Dictionary<string, JsonNode?> MaterializeInputs(
+        IReadOnlyList<TaskPackInput>? definitions,
         IDictionary<string, JsonNode?>? providedInputs,
         ImmutableArray<TaskPackPlanError>.Builder errors)
     {
@@ -141,9 +143,22 @@ public sealed class TaskPackPlanner
             }
         }
 
-        return effective;
-    }
-
+        return effective;
+    }
+
+    private static TaskPackPlanFailurePolicy? MaterializeFailurePolicy(TaskPackFailure? failure)
+    {
+        if (failure?.Retries is not TaskPackRetryPolicy retries)
+        {
+            return null;
+        }
+
+        var maxAttempts = retries.MaxAttempts <= 0 ? 1 : retries.MaxAttempts;
+        var backoffSeconds = retries.BackoffSeconds < 0 ? 0 : retries.BackoffSeconds;
+
+        return new TaskPackPlanFailurePolicy(maxAttempts, backoffSeconds, ContinueOnError: false);
+    }
+
     private TaskPackPlanStep BuildStep(
         string packName,
         string packVersion,

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/FilePackRunStateStore.cs

@@ -0,0 +1,191 @@
+using System.Text.Json;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Infrastructure.Execution;
+
+/// <summary>
+/// File-system backed implementation of <see cref="IPackRunStateStore"/> intended for development and air-gapped smoke tests.
+/// </summary>
+public sealed class FilePackRunStateStore : IPackRunStateStore
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new(JsonSerializerDefaults.Web)
+    {
+        WriteIndented = true
+    };
+
+    private readonly string rootPath;
+    private readonly SemaphoreSlim mutex = new(1, 1);
+
+    public FilePackRunStateStore(string rootPath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(rootPath);
+
+        this.rootPath = Path.GetFullPath(rootPath);
+        Directory.CreateDirectory(this.rootPath);
+    }
+
+    public async Task<PackRunState?> GetAsync(string runId, CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
+
+        var path = GetPath(runId);
+        if (!File.Exists(path))
+        {
+            return null;
+        }
+
+        await using var stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+        var document = await JsonSerializer.DeserializeAsync<StateDocument>(stream, SerializerOptions, cancellationToken)
+            .ConfigureAwait(false);
+
+        return document?.ToDomain();
+    }
+
+    public async Task SaveAsync(PackRunState state, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+
+        var path = GetPath(state.RunId);
+        var document = StateDocument.FromDomain(state);
+
+        Directory.CreateDirectory(rootPath);
+
+        await mutex.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            await using var stream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None);
+            await JsonSerializer.SerializeAsync(stream, document, SerializerOptions, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        finally
+        {
+            mutex.Release();
+        }
+    }
+
+    public async Task<IReadOnlyList<PackRunState>> ListAsync(CancellationToken cancellationToken)
+    {
+        if (!Directory.Exists(rootPath))
+        {
+            return Array.Empty<PackRunState>();
+        }
+
+        var states = new List<PackRunState>();
+
+        var files = Directory.EnumerateFiles(rootPath, "*.json", SearchOption.TopDirectoryOnly)
+            .OrderBy(file => file, StringComparer.Ordinal);
+
+        foreach (var file in files)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await using var stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read);
+            var document = await JsonSerializer.DeserializeAsync<StateDocument>(stream, SerializerOptions, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (document is not null)
+            {
+                states.Add(document.ToDomain());
+            }
+        }
+
+        return states;
+    }
+
+    private string GetPath(string runId)
+    {
+        var safeName = SanitizeFileName(runId);
+        return Path.Combine(rootPath, $"{safeName}.json");
+    }
+
+    private static string SanitizeFileName(string value)
+    {
+        var result = value.Trim();
+        foreach (var invalid in Path.GetInvalidFileNameChars())
+        {
+            result = result.Replace(invalid, '_');
+        }
+
+        return result;
+    }
+
+    private sealed record StateDocument(
+        string RunId,
+        string PlanHash,
+        TaskPackPlanFailurePolicy FailurePolicy,
+        DateTimeOffset CreatedAt,
+        DateTimeOffset UpdatedAt,
+        IReadOnlyList<StepDocument> Steps)
+    {
+        public static StateDocument FromDomain(PackRunState state)
+        {
+            var steps = state.Steps.Values
+                .OrderBy(step => step.StepId, StringComparer.Ordinal)
+                .Select(step => new StepDocument(
+                    step.StepId,
+                    step.Kind,
+                    step.Enabled,
+                    step.ContinueOnError,
+                    step.MaxParallel,
+                    step.ApprovalId,
+                    step.GateMessage,
+                    step.Status,
+                    step.Attempts,
+                    step.LastTransitionAt,
+                    step.NextAttemptAt,
+                    step.StatusReason))
+                .ToList();
+
+            return new StateDocument(
+                state.RunId,
+                state.PlanHash,
+                state.FailurePolicy,
+                state.CreatedAt,
+                state.UpdatedAt,
+                steps);
+        }
+
+        public PackRunState ToDomain()
+        {
+            var steps = Steps.ToDictionary(
+                step => step.StepId,
+                step => new PackRunStepStateRecord(
+                    step.StepId,
+                    step.Kind,
+                    step.Enabled,
+                    step.ContinueOnError,
+                    step.MaxParallel,
+                    step.ApprovalId,
+                    step.GateMessage,
+                    step.Status,
+                    step.Attempts,
+                    step.LastTransitionAt,
+                    step.NextAttemptAt,
+                    step.StatusReason),
+                StringComparer.Ordinal);
+
+            return new PackRunState(
+                RunId,
+                PlanHash,
+                FailurePolicy,
+                CreatedAt,
+                UpdatedAt,
+                steps);
+        }
+    }
+
+    private sealed record StepDocument(
+        string StepId,
+        PackRunStepKind Kind,
+        bool Enabled,
+        bool ContinueOnError,
+        int? MaxParallel,
+        string? ApprovalId,
+        string? GateMessage,
+        PackRunStepExecutionStatus Status,
+        int Attempts,
+        DateTimeOffset? LastTransitionAt,
+        DateTimeOffset? NextAttemptAt,
+        string? StatusReason);
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/NoopPackRunStepExecutor.cs

@@ -0,0 +1,24 @@
+using System.Text.Json.Nodes;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Infrastructure.Execution;
+
+public sealed class NoopPackRunStepExecutor : IPackRunStepExecutor
+{
+    public Task<PackRunStepExecutionResult> ExecuteAsync(
+        PackRunExecutionStep step,
+        IReadOnlyDictionary<string, TaskPackPlanParameterValue> parameters,
+        CancellationToken cancellationToken)
+    {
+        if (parameters.TryGetValue("simulateFailure", out var value) &&
+            value.Value is JsonValue jsonValue &&
+            jsonValue.TryGetValue<bool>(out var failure) &&
+            failure)
+        {
+            return Task.FromResult(new PackRunStepExecutionResult(false, "Simulated failure requested."));
+        }
+
+        return Task.FromResult(new PackRunStepExecutionResult(true));
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/FilePackRunStateStoreTests.cs

@@ -0,0 +1,105 @@
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+using StellaOps.TaskRunner.Infrastructure.Execution;
+
+namespace StellaOps.TaskRunner.Tests;
+
+public sealed class FilePackRunStateStoreTests
+{
+    [Fact]
+    public async Task SaveAndGetAsync_RoundTripsState()
+    {
+        var directory = CreateTempDirectory();
+        try
+        {
+            var store = new FilePackRunStateStore(directory);
+            var original = CreateState("run:primary");
+
+            await store.SaveAsync(original, CancellationToken.None);
+
+            var reloaded = await store.GetAsync("run:primary", CancellationToken.None);
+            Assert.NotNull(reloaded);
+            Assert.Equal(original.RunId, reloaded!.RunId);
+            Assert.Equal(original.PlanHash, reloaded.PlanHash);
+            Assert.Equal(original.FailurePolicy, reloaded.FailurePolicy);
+            Assert.Equal(original.Steps.Count, reloaded.Steps.Count);
+            var step = Assert.Single(reloaded.Steps);
+            Assert.Equal("step-a", step.Key);
+            Assert.Equal(original.Steps["step-a"], step.Value);
+        }
+        finally
+        {
+            TryDelete(directory);
+        }
+    }
+
+    [Fact]
+    public async Task ListAsync_ReturnsStatesInDeterministicOrder()
+    {
+        var directory = CreateTempDirectory();
+        try
+        {
+            var store = new FilePackRunStateStore(directory);
+            var stateB = CreateState("run-b");
+            var stateA = CreateState("run-a");
+
+            await store.SaveAsync(stateB, CancellationToken.None);
+            await store.SaveAsync(stateA, CancellationToken.None);
+
+            var states = await store.ListAsync(CancellationToken.None);
+
+            Assert.Collection(states,
+                first => Assert.Equal("run-a", first.RunId),
+                second => Assert.Equal("run-b", second.RunId));
+        }
+        finally
+        {
+            TryDelete(directory);
+        }
+    }
+
+    private static PackRunState CreateState(string runId)
+    {
+        var failurePolicy = new TaskPackPlanFailurePolicy(MaxAttempts: 3, BackoffSeconds: 30, ContinueOnError: false);
+        var steps = new Dictionary<string, PackRunStepStateRecord>(StringComparer.Ordinal)
+        {
+            ["step-a"] = new PackRunStepStateRecord(
+                StepId: "step-a",
+                Kind: PackRunStepKind.Run,
+                Enabled: true,
+                ContinueOnError: false,
+                MaxParallel: null,
+                ApprovalId: null,
+                GateMessage: null,
+                Status: PackRunStepExecutionStatus.Pending,
+                Attempts: 1,
+                LastTransitionAt: DateTimeOffset.UtcNow,
+                NextAttemptAt: null,
+                StatusReason: null)
+        };
+
+        return PackRunState.Create(runId, "hash-123", failurePolicy, steps, DateTimeOffset.UtcNow);
+    }
+
+    private static string CreateTempDirectory()
+    {
+        var path = Path.Combine(Path.GetTempPath(), "stellaops-taskrunner-tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(path);
+        return path;
+    }
+
+    private static void TryDelete(string directory)
+    {
+        try
+        {
+            if (Directory.Exists(directory))
+            {
+                Directory.Delete(directory, recursive: true);
+            }
+        }
+        catch
+        {
+            // Swallow cleanup errors to avoid masking test assertions.
+        }
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/PackRunExecutionGraphBuilderTests.cs

@@ -0,0 +1,68 @@
+using System.Text.Json.Nodes;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Tests;
+
+public sealed class PackRunExecutionGraphBuilderTests
+{
+    [Fact]
+    public void Build_GeneratesParallelMetadata()
+    {
+        var manifest = TestManifests.Load(TestManifests.Parallel);
+        var planner = new TaskPackPlanner();
+
+        var result = planner.Plan(manifest);
+        Assert.True(result.Success);
+        var plan = result.Plan!;
+
+        var builder = new PackRunExecutionGraphBuilder();
+        var graph = builder.Build(plan);
+
+        Assert.Equal(2, graph.FailurePolicy.MaxAttempts);
+        Assert.Equal(10, graph.FailurePolicy.BackoffSeconds);
+
+        var parallel = Assert.Single(graph.Steps);
+        Assert.Equal(PackRunStepKind.Parallel, parallel.Kind);
+        Assert.True(parallel.Enabled);
+        Assert.Equal(2, parallel.MaxParallel);
+        Assert.True(parallel.ContinueOnError);
+        Assert.Equal(2, parallel.Children.Count);
+        Assert.All(parallel.Children, child => Assert.Equal(PackRunStepKind.Run, child.Kind));
+    }
+
+    [Fact]
+    public void Build_PreservesMapIterationsAndDisabledSteps()
+    {
+        var planner = new TaskPackPlanner();
+        var builder = new PackRunExecutionGraphBuilder();
+
+        // Map iterations
+        var mapManifest = TestManifests.Load(TestManifests.Map);
+        var inputs = new Dictionary<string, JsonNode?>
+        {
+            ["targets"] = new JsonArray("alpha", "beta", "gamma")
+        };
+
+        var mapPlan = planner.Plan(mapManifest, inputs).Plan!;
+        var mapGraph = builder.Build(mapPlan);
+
+        var mapStep = Assert.Single(mapGraph.Steps);
+        Assert.Equal(PackRunStepKind.Map, mapStep.Kind);
+        Assert.Equal(3, mapStep.Children.Count);
+        Assert.All(mapStep.Children, child => Assert.Equal(PackRunStepKind.Run, child.Kind));
+
+        // Disabled conditional step
+        var conditionalManifest = TestManifests.Load(TestManifests.Sample);
+        var conditionalInputs = new Dictionary<string, JsonNode?>
+        {
+            ["dryRun"] = JsonValue.Create(true)
+        };
+
+        var conditionalPlan = planner.Plan(conditionalManifest, conditionalInputs).Plan!;
+        var conditionalGraph = builder.Build(conditionalPlan);
+
+        var applyStep = conditionalGraph.Steps.Single(step => step.Id == "apply-step");
+        Assert.False(applyStep.Enabled);
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/PackRunGateStateUpdaterTests.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Tests;
+
+public sealed class PackRunGateStateUpdaterTests
+{
+    private static readonly DateTimeOffset RequestedAt = DateTimeOffset.UnixEpoch;
+    private static readonly DateTimeOffset UpdateTimestamp = DateTimeOffset.UnixEpoch.AddMinutes(5);
+
+    [Fact]
+    public void Apply_ApprovedGate_ClearsReasonAndSucceeds()
+    {
+        var plan = BuildApprovalPlan();
+        var graph = new PackRunExecutionGraphBuilder().Build(plan);
+        var state = CreateInitialState(plan, graph);
+        var coordinator = PackRunApprovalCoordinator.Create(plan, RequestedAt);
+        coordinator.Approve("security-review", "approver-1", UpdateTimestamp);
+
+        var result = PackRunGateStateUpdater.Apply(state, graph, coordinator, UpdateTimestamp);
+
+        Assert.False(result.HasBlockingFailure);
+        Assert.Equal(UpdateTimestamp, result.State.UpdatedAt);
+
+        var gate = result.State.Steps["approval"];
+        Assert.Equal(PackRunStepExecutionStatus.Succeeded, gate.Status);
+        Assert.Null(gate.StatusReason);
+        Assert.Equal(UpdateTimestamp, gate.LastTransitionAt);
+    }
+
+    [Fact]
+    public void Apply_RejectedGate_FlagsFailure()
+    {
+        var plan = BuildApprovalPlan();
+        var graph = new PackRunExecutionGraphBuilder().Build(plan);
+        var state = CreateInitialState(plan, graph);
+        var coordinator = PackRunApprovalCoordinator.Create(plan, RequestedAt);
+        coordinator.Reject("security-review", "approver-1", UpdateTimestamp, "not-safe");
+
+        var result = PackRunGateStateUpdater.Apply(state, graph, coordinator, UpdateTimestamp);
+
+        Assert.True(result.HasBlockingFailure);
+        Assert.Equal(UpdateTimestamp, result.State.UpdatedAt);
+
+        var gate = result.State.Steps["approval"];
+        Assert.Equal(PackRunStepExecutionStatus.Failed, gate.Status);
+        Assert.StartsWith("approval-rejected", gate.StatusReason, StringComparison.Ordinal);
+        Assert.Equal(UpdateTimestamp, gate.LastTransitionAt);
+    }
+
+    [Fact]
+    public void Apply_PolicyGate_ClearsPendingReason()
+    {
+        var plan = BuildPolicyPlan();
+        var graph = new PackRunExecutionGraphBuilder().Build(plan);
+        var state = CreateInitialState(plan, graph);
+        var coordinator = PackRunApprovalCoordinator.Create(plan, RequestedAt);
+
+        var result = PackRunGateStateUpdater.Apply(state, graph, coordinator, UpdateTimestamp);
+
+        Assert.False(result.HasBlockingFailure);
+
+        var gate = result.State.Steps["policy-check"];
+        Assert.Equal(PackRunStepExecutionStatus.Succeeded, gate.Status);
+        Assert.Null(gate.StatusReason);
+        Assert.Equal(UpdateTimestamp, gate.LastTransitionAt);
+
+        var prepare = result.State.Steps["prepare"];
+        Assert.Equal(PackRunStepExecutionStatus.Pending, prepare.Status);
+        Assert.Null(prepare.StatusReason);
+    }
+
+    private static TaskPackPlan BuildApprovalPlan()
+    {
+        var manifest = TestManifests.Load(TestManifests.Sample);
+        var planner = new TaskPackPlanner();
+        var inputs = new Dictionary<string, System.Text.Json.Nodes.JsonNode?>
+        {
+            ["dryRun"] = System.Text.Json.Nodes.JsonValue.Create(false)
+        };
+
+        return planner.Plan(manifest, inputs).Plan!;
+    }
+
+    private static TaskPackPlan BuildPolicyPlan()
+    {
+        var manifest = TestManifests.Load(TestManifests.PolicyGate);
+        var planner = new TaskPackPlanner();
+        return planner.Plan(manifest).Plan!;
+    }
+
+    private static PackRunState CreateInitialState(TaskPackPlan plan, PackRunExecutionGraph graph)
+    {
+        var steps = new Dictionary<string, PackRunStepStateRecord>(StringComparer.Ordinal);
+
+        foreach (var step in EnumerateSteps(graph.Steps))
+        {
+            var status = PackRunStepExecutionStatus.Pending;
+            string? reason = null;
+
+            if (!step.Enabled)
+            {
+                status = PackRunStepExecutionStatus.Skipped;
+                reason = "disabled";
+            }
+            else if (step.Kind == PackRunStepKind.GateApproval)
+            {
+                reason = "requires-approval";
+            }
+            else if (step.Kind == PackRunStepKind.GatePolicy)
+            {
+                reason = "requires-policy";
+            }
+
+            steps[step.Id] = new PackRunStepStateRecord(
+                step.Id,
+                step.Kind,
+                step.Enabled,
+                step.ContinueOnError,
+                step.MaxParallel,
+                step.ApprovalId,
+                step.GateMessage,
+                status,
+                Attempts: 0,
+                LastTransitionAt: null,
+                NextAttemptAt: null,
+                StatusReason: reason);
+        }
+
+        return PackRunState.Create("run-1", plan.Hash, graph.FailurePolicy, steps, RequestedAt);
+    }
+
+    private static IEnumerable<PackRunExecutionStep> EnumerateSteps(IReadOnlyList<PackRunExecutionStep> steps)
+    {
+        foreach (var step in steps)
+        {
+            yield return step;
+
+            if (step.Children.Count > 0)
+            {
+                foreach (var child in EnumerateSteps(step.Children))
+                {
+                    yield return child;
+                }
+            }
+        }
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/PackRunSimulationEngineTests.cs

@@ -0,0 +1,75 @@
+using System.Text.Json.Nodes;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Execution.Simulation;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Tests;
+
+public sealed class PackRunSimulationEngineTests
+{
+    [Fact]
+    public void Simulate_IdentifiesGateStatuses()
+    {
+        var manifest = TestManifests.Load(TestManifests.PolicyGate);
+        var planner = new TaskPackPlanner();
+        var plan = planner.Plan(manifest).Plan!;
+
+        var engine = new PackRunSimulationEngine();
+        var result = engine.Simulate(plan);
+
+        var gate = result.Steps.Single(step => step.Kind == PackRunStepKind.GatePolicy);
+        Assert.Equal(PackRunSimulationStatus.RequiresPolicy, gate.Status);
+
+        var run = result.Steps.Single(step => step.Kind == PackRunStepKind.Run);
+        Assert.Equal(PackRunSimulationStatus.Pending, run.Status);
+    }
+
+    [Fact]
+    public void Simulate_MarksDisabledStepsAndOutputs()
+    {
+        var manifest = TestManifests.Load(TestManifests.Sample);
+        var planner = new TaskPackPlanner();
+        var inputs = new Dictionary<string, JsonNode?>
+        {
+            ["dryRun"] = JsonValue.Create(true)
+        };
+
+        var plan = planner.Plan(manifest, inputs).Plan!;
+
+        var engine = new PackRunSimulationEngine();
+        var result = engine.Simulate(plan);
+
+        var applyStep = result.Steps.Single(step => step.Id == "apply-step");
+        Assert.Equal(PackRunSimulationStatus.Skipped, applyStep.Status);
+
+        Assert.Empty(result.Outputs);
+        Assert.Equal(PackRunExecutionGraph.DefaultFailurePolicy.MaxAttempts, result.FailurePolicy.MaxAttempts);
+        Assert.Equal(PackRunExecutionGraph.DefaultFailurePolicy.BackoffSeconds, result.FailurePolicy.BackoffSeconds);
+    }
+
+    [Fact]
+    public void Simulate_ProjectsOutputsAndRuntimeFlags()
+    {
+        var manifest = TestManifests.Load(TestManifests.Output);
+        var planner = new TaskPackPlanner();
+        var plan = planner.Plan(manifest).Plan!;
+
+        var engine = new PackRunSimulationEngine();
+        var result = engine.Simulate(plan);
+
+        var step = Assert.Single(result.Steps);
+        Assert.Equal(PackRunStepKind.Run, step.Kind);
+
+        Assert.Collection(result.Outputs,
+            bundle =>
+            {
+                Assert.Equal("bundlePath", bundle.Name);
+                Assert.False(bundle.RequiresRuntimeValue);
+            },
+            evidence =>
+            {
+                Assert.Equal("evidenceModel", evidence.Name);
+                Assert.True(evidence.RequiresRuntimeValue);
+            });
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/PackRunStepStateMachineTests.cs

@@ -0,0 +1,66 @@
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Tests;
+
+public sealed class PackRunStepStateMachineTests
+{
+    private static readonly TaskPackPlanFailurePolicy RetryTwicePolicy = new(MaxAttempts: 3, BackoffSeconds: 5, ContinueOnError: false);
+
+    [Fact]
+    public void Start_FromPending_SetsRunning()
+    {
+        var state = PackRunStepStateMachine.Create();
+        var started = PackRunStepStateMachine.Start(state, DateTimeOffset.UnixEpoch);
+
+        Assert.Equal(PackRunStepExecutionStatus.Running, started.Status);
+        Assert.Equal(0, started.Attempts);
+    }
+
+    [Fact]
+    public void CompleteSuccess_IncrementsAttempts()
+    {
+        var state = PackRunStepStateMachine.Create();
+        var running = PackRunStepStateMachine.Start(state, DateTimeOffset.UnixEpoch);
+        var completed = PackRunStepStateMachine.CompleteSuccess(running, DateTimeOffset.UnixEpoch.AddSeconds(1));
+
+        Assert.Equal(PackRunStepExecutionStatus.Succeeded, completed.Status);
+        Assert.Equal(1, completed.Attempts);
+        Assert.Null(completed.NextAttemptAt);
+    }
+
+    [Fact]
+    public void RegisterFailure_SchedulesRetryUntilMaxAttempts()
+    {
+        var state = PackRunStepStateMachine.Create();
+        var running = PackRunStepStateMachine.Start(state, DateTimeOffset.UnixEpoch);
+
+        var firstFailure = PackRunStepStateMachine.RegisterFailure(running, DateTimeOffset.UnixEpoch.AddSeconds(2), RetryTwicePolicy);
+        Assert.Equal(PackRunStepFailureOutcome.Retry, firstFailure.Outcome);
+        Assert.Equal(PackRunStepExecutionStatus.Pending, firstFailure.State.Status);
+        Assert.Equal(1, firstFailure.State.Attempts);
+        Assert.Equal(DateTimeOffset.UnixEpoch.AddSeconds(7), firstFailure.State.NextAttemptAt);
+
+        var restarted = PackRunStepStateMachine.Start(firstFailure.State, DateTimeOffset.UnixEpoch.AddSeconds(7));
+        var secondFailure = PackRunStepStateMachine.RegisterFailure(restarted, DateTimeOffset.UnixEpoch.AddSeconds(9), RetryTwicePolicy);
+        Assert.Equal(PackRunStepFailureOutcome.Retry, secondFailure.Outcome);
+        Assert.Equal(2, secondFailure.State.Attempts);
+
+        var finalStart = PackRunStepStateMachine.Start(secondFailure.State, DateTimeOffset.UnixEpoch.AddSeconds(9 + RetryTwicePolicy.BackoffSeconds));
+        var terminalFailure = PackRunStepStateMachine.RegisterFailure(finalStart, DateTimeOffset.UnixEpoch.AddSeconds(20), RetryTwicePolicy);
+        Assert.Equal(PackRunStepFailureOutcome.Abort, terminalFailure.Outcome);
+        Assert.Equal(PackRunStepExecutionStatus.Failed, terminalFailure.State.Status);
+        Assert.Equal(3, terminalFailure.State.Attempts);
+        Assert.Null(terminalFailure.State.NextAttemptAt);
+    }
+
+    [Fact]
+    public void Skip_FromPending_SetsSkipped()
+    {
+        var state = PackRunStepStateMachine.Create();
+        var skipped = PackRunStepStateMachine.Skip(state, DateTimeOffset.UnixEpoch.AddHours(1));
+
+        Assert.Equal(PackRunStepExecutionStatus.Skipped, skipped.Status);
+        Assert.Equal(0, skipped.Attempts);
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/TaskPackPlannerTests.cs

@@ -126,11 +126,11 @@ public sealed class TaskPackPlannerTests
     }
 
     [Fact]
-    public void Plan_WithOutputs_ProjectsResolvedValues()
-    {
-        var manifest = TestManifests.Load(TestManifests.Output);
-        var planner = new TaskPackPlanner();
-
+    public void Plan_WithOutputs_ProjectsResolvedValues()
+    {
+        var manifest = TestManifests.Load(TestManifests.Output);
+        var planner = new TaskPackPlanner();
+
         var result = planner.Plan(manifest);
         Assert.True(result.Success);
         var plan = result.Plan!;
@@ -141,11 +141,26 @@ public sealed class TaskPackPlannerTests
         Assert.False(bundle.Path!.RequiresRuntimeValue);
         Assert.Equal("artifacts/report.txt", bundle.Path.Value!.GetValue<string>());
 
-        var evidence = plan.Outputs.First(o => o.Name == "evidenceModel");
-        Assert.NotNull(evidence.Expression);
-        Assert.True(evidence.Expression!.RequiresRuntimeValue);
-        Assert.Equal("steps.generate.outputs.evidence", evidence.Expression.Expression);
-    }
+        var evidence = plan.Outputs.First(o => o.Name == "evidenceModel");
+        Assert.NotNull(evidence.Expression);
+        Assert.True(evidence.Expression!.RequiresRuntimeValue);
+        Assert.Equal("steps.generate.outputs.evidence", evidence.Expression.Expression);
+    }
+
+    [Fact]
+    public void Plan_WithFailurePolicy_PopulatesPlanFailure()
+    {
+        var manifest = TestManifests.Load(TestManifests.FailurePolicy);
+        var planner = new TaskPackPlanner();
+
+        var result = planner.Plan(manifest);
+        Assert.True(result.Success);
+        var plan = result.Plan!;
+        Assert.NotNull(plan.FailurePolicy);
+        Assert.Equal(4, plan.FailurePolicy!.MaxAttempts);
+        Assert.Equal(30, plan.FailurePolicy.BackoffSeconds);
+        Assert.False(plan.FailurePolicy.ContinueOnError);
+    }
 
     [Fact]
     public void PolicyGateHints_IncludeRuntimeMetadata()

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Tests/TestManifests.cs

@@ -138,11 +138,55 @@ spec:
     - name: bundlePath
       type: file
       path: artifacts/report.txt
-    - name: evidenceModel
-      type: object
-      expression: "{{ steps.generate.outputs.evidence }}"
-""";
-
+    - name: evidenceModel
+      type: object
+      expression: "{{ steps.generate.outputs.evidence }}"
+""";
+
+    public const string FailurePolicy = """
+apiVersion: stellaops.io/pack.v1
+kind: TaskPack
+metadata:
+  name: failure-policy-pack
+  version: 1.0.0
+spec:
+  steps:
+    - id: build
+      run:
+        uses: builtin:build
+  failure:
+    retries:
+      maxAttempts: 4
+      backoffSeconds: 30
+    message: "Build failed."
+""";
+
+    public const string Parallel = """
+apiVersion: stellaops.io/pack.v1
+kind: TaskPack
+metadata:
+  name: parallel-pack
+  version: 1.1.0
+spec:
+  steps:
+    - id: fanout
+      parallel:
+        maxParallel: 2
+        continueOnError: true
+        steps:
+          - id: lint
+            run:
+              uses: builtin:lint
+          - id: test
+            run:
+              uses: builtin:test
+  failure:
+    retries:
+      maxAttempts: 2
+      backoffSeconds: 10
+    message: "Parallel execution failed."
+""";
+
 public const string PolicyGate = """
 apiVersion: stellaops.io/pack.v1
 kind: TaskPack

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.WebService/Program.cs

@@ -1,41 +1,242 @@
-var builder = WebApplication.CreateBuilder(args);
-
-// Add services to the container.
-// Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
-builder.Services.AddOpenApi();
-
-var app = builder.Build();
-
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
-{
-    app.MapOpenApi();
-}
-
-app.UseHttpsRedirection();
-
-var summaries = new[]
-{
-    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
-};
-
-app.MapGet("/weatherforecast", () =>
-{
-    var forecast =  Enumerable.Range(1, 5).Select(index =>
-        new WeatherForecast
-        (
-            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
-            Random.Shared.Next(-20, 55),
-            summaries[Random.Shared.Next(summaries.Length)]
-        ))
-        .ToArray();
-    return forecast;
-})
-.WithName("GetWeatherForecast");
-
-app.Run();
-
-record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
-{
-    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
-}
+using System.Text.Json.Nodes;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Execution.Simulation;
+using StellaOps.TaskRunner.Core.Planning;
+using StellaOps.TaskRunner.Core.TaskPacks;
+using StellaOps.TaskRunner.Infrastructure.Execution;
+using StellaOps.TaskRunner.WebService;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.Configure<TaskRunnerServiceOptions>(builder.Configuration.GetSection("TaskRunner"));
+builder.Services.AddSingleton<TaskPackManifestLoader>();
+builder.Services.AddSingleton<TaskPackPlanner>();
+builder.Services.AddSingleton<PackRunSimulationEngine>();
+builder.Services.AddSingleton<PackRunExecutionGraphBuilder>();
+builder.Services.AddSingleton<IPackRunStateStore>(sp =>
+{
+    var options = sp.GetRequiredService<IOptions<TaskRunnerServiceOptions>>().Value;
+    return new FilePackRunStateStore(options.RunStatePath);
+});
+builder.Services.AddOpenApi();
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{
+    app.MapOpenApi();
+}
+
+app.MapPost("/v1/task-runner/simulations", async (
+    [FromBody] SimulationRequest request,
+    TaskPackManifestLoader loader,
+    TaskPackPlanner planner,
+    PackRunSimulationEngine simulationEngine,
+    CancellationToken cancellationToken) =>
+{
+    if (string.IsNullOrWhiteSpace(request.Manifest))
+    {
+        return Results.BadRequest(new { error = "Manifest is required." });
+    }
+
+    TaskPackManifest manifest;
+    try
+    {
+        manifest = loader.Deserialize(request.Manifest);
+    }
+    catch (Exception ex)
+    {
+        return Results.BadRequest(new { error = "Invalid manifest", detail = ex.Message });
+    }
+
+    var inputs = ConvertInputs(request.Inputs);
+    var planResult = planner.Plan(manifest, inputs);
+    if (!planResult.Success || planResult.Plan is null)
+    {
+        return Results.BadRequest(new
+        {
+            errors = planResult.Errors.Select(error => new { error.Path, error.Message })
+        });
+    }
+
+    var plan = planResult.Plan;
+    var simulation = simulationEngine.Simulate(plan);
+    var response = SimulationMapper.ToResponse(plan, simulation);
+    return Results.Ok(response);
+}).WithName("SimulateTaskPack");
+
+app.MapGet("/v1/task-runner/runs/{runId}", async (
+    string runId,
+    IPackRunStateStore stateStore,
+    CancellationToken cancellationToken) =>
+{
+    if (string.IsNullOrWhiteSpace(runId))
+    {
+        return Results.BadRequest(new { error = "runId is required." });
+    }
+
+    var state = await stateStore.GetAsync(runId, cancellationToken).ConfigureAwait(false);
+    if (state is null)
+    {
+        return Results.NotFound();
+    }
+
+    return Results.Ok(RunStateMapper.ToResponse(state));
+}).WithName("GetRunState");
+
+app.MapGet("/", () => Results.Redirect("/openapi"));
+
+app.Run();
+
+static IDictionary<string, JsonNode?>? ConvertInputs(JsonObject? node)
+{
+    if (node is null)
+    {
+        return null;
+    }
+
+    var dictionary = new Dictionary<string, JsonNode?>(StringComparer.Ordinal);
+    foreach (var property in node)
+    {
+        dictionary[property.Key] = property.Value?.DeepClone();
+    }
+
+    return dictionary;
+}
+
+internal sealed record SimulationRequest(string Manifest, JsonObject? Inputs);
+
+internal sealed record SimulationResponse(
+    string PlanHash,
+    FailurePolicyResponse FailurePolicy,
+    IReadOnlyList<SimulationStepResponse> Steps,
+    IReadOnlyList<SimulationOutputResponse> Outputs,
+    bool HasPendingApprovals);
+
+internal sealed record SimulationStepResponse(
+    string Id,
+    string TemplateId,
+    string Kind,
+    bool Enabled,
+    string Status,
+    string? StatusReason,
+    string? Uses,
+    string? ApprovalId,
+    string? GateMessage,
+    int? MaxParallel,
+    bool ContinueOnError,
+    IReadOnlyList<SimulationStepResponse> Children);
+
+internal sealed record SimulationOutputResponse(
+    string Name,
+    string Type,
+    bool RequiresRuntimeValue,
+    string? PathExpression,
+    string? ValueExpression);
+
+internal sealed record FailurePolicyResponse(int MaxAttempts, int BackoffSeconds, bool ContinueOnError);
+
+internal sealed record RunStateResponse(
+    string RunId,
+    string PlanHash,
+    FailurePolicyResponse FailurePolicy,
+    DateTimeOffset CreatedAt,
+    DateTimeOffset UpdatedAt,
+    IReadOnlyList<RunStateStepResponse> Steps);
+
+internal sealed record RunStateStepResponse(
+    string StepId,
+    string Kind,
+    bool Enabled,
+    bool ContinueOnError,
+    int? MaxParallel,
+    string? ApprovalId,
+    string? GateMessage,
+    string Status,
+    int Attempts,
+    DateTimeOffset? LastTransitionAt,
+    DateTimeOffset? NextAttemptAt,
+    string? StatusReason);
+
+internal static class SimulationMapper
+{
+    public static SimulationResponse ToResponse(TaskPackPlan plan, PackRunSimulationResult result)
+    {
+        var failurePolicy = result.FailurePolicy ?? PackRunExecutionGraph.DefaultFailurePolicy;
+        var steps = result.Steps.Select(MapStep).ToList();
+        var outputs = result.Outputs.Select(MapOutput).ToList();
+
+        return new SimulationResponse(
+            plan.Hash,
+            new FailurePolicyResponse(failurePolicy.MaxAttempts, failurePolicy.BackoffSeconds, failurePolicy.ContinueOnError),
+            steps,
+            outputs,
+            result.HasPendingApprovals);
+    }
+
+    private static SimulationStepResponse MapStep(PackRunSimulationNode node)
+    {
+        var children = node.Children.Select(MapStep).ToList();
+        return new SimulationStepResponse(
+            node.Id,
+            node.TemplateId,
+            node.Kind.ToString(),
+            node.Enabled,
+            node.Status.ToString(),
+            node.Status.ToString() switch
+            {
+                nameof(PackRunSimulationStatus.RequiresApproval) => "requires-approval",
+                nameof(PackRunSimulationStatus.RequiresPolicy) => "requires-policy",
+                nameof(PackRunSimulationStatus.Skipped) => "condition-false",
+                _ => null
+            },
+            node.Uses,
+            node.ApprovalId,
+            node.GateMessage,
+            node.MaxParallel,
+            node.ContinueOnError,
+            children);
+    }
+
+    private static SimulationOutputResponse MapOutput(PackRunSimulationOutput output)
+        => new(
+            output.Name,
+            output.Type,
+            output.RequiresRuntimeValue,
+            output.Path?.Expression,
+            output.Expression?.Expression);
+}
+
+internal static class RunStateMapper
+{
+    public static RunStateResponse ToResponse(PackRunState state)
+    {
+        var failurePolicy = state.FailurePolicy ?? PackRunExecutionGraph.DefaultFailurePolicy;
+        var steps = state.Steps.Values
+            .OrderBy(step => step.StepId, StringComparer.Ordinal)
+            .Select(step => new RunStateStepResponse(
+                step.StepId,
+                step.Kind.ToString(),
+                step.Enabled,
+                step.ContinueOnError,
+                step.MaxParallel,
+                step.ApprovalId,
+                step.GateMessage,
+                step.Status.ToString(),
+                step.Attempts,
+                step.LastTransitionAt,
+                step.NextAttemptAt,
+                step.StatusReason))
+            .ToList();
+
+        return new RunStateResponse(
+            state.RunId,
+            state.PlanHash,
+            new FailurePolicyResponse(failurePolicy.MaxAttempts, failurePolicy.BackoffSeconds, failurePolicy.ContinueOnError),
+            state.CreatedAt,
+            state.UpdatedAt,
+            steps);
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.WebService/TaskRunnerServiceOptions.cs

@@ -0,0 +1,6 @@
+namespace StellaOps.TaskRunner.WebService;
+
+public sealed class TaskRunnerServiceOptions
+{
+    public string RunStatePath { get; set; } = Path.Combine(AppContext.BaseDirectory, "state", "runs");
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.WebService/appsettings.json

@@ -1,9 +1,12 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
-  "AllowedHosts": "*"
-}
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "TaskRunner": {
+    "RunStatePath": "state/runs"
+  }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Worker/Program.cs

@@ -3,6 +3,7 @@ using StellaOps.AirGap.Policy;
 using StellaOps.TaskRunner.Core.Execution;
 using StellaOps.TaskRunner.Infrastructure.Execution;
 using StellaOps.TaskRunner.Worker.Services;
+using StellaOps.TaskRunner.Core.Execution.Simulation;
 
 var builder = Host.CreateApplicationBuilder(args);
 
@@ -23,10 +24,10 @@ builder.Services.AddSingleton<IPackRunJobDispatcher>(sp =>
     var egressPolicy = sp.GetRequiredService<IEgressPolicy>();
     return new FilesystemPackRunDispatcher(options.Value.QueuePath, options.Value.ArchivePath, egressPolicy);
 });
-
-builder.Services.AddSingleton<IPackRunNotificationPublisher>(sp =>
-{
-    var options = sp.GetRequiredService<IOptions<NotificationOptions>>().Value;
+
+builder.Services.AddSingleton<IPackRunNotificationPublisher>(sp =>
+{
+    var options = sp.GetRequiredService<IOptions<NotificationOptions>>().Value;
     if (options.ApprovalEndpoint is not null || options.PolicyEndpoint is not null)
     {
         return new HttpPackRunNotificationPublisher(
@@ -34,12 +35,21 @@ builder.Services.AddSingleton<IPackRunNotificationPublisher>(sp =>
             sp.GetRequiredService<IOptions<NotificationOptions>>(),
             sp.GetRequiredService<ILogger<HttpPackRunNotificationPublisher>>());
     }
-
-    return new LoggingPackRunNotificationPublisher(sp.GetRequiredService<ILogger<LoggingPackRunNotificationPublisher>>());
-});
-
-builder.Services.AddSingleton<PackRunProcessor>();
-builder.Services.AddHostedService<PackRunWorkerService>();
-
-var host = builder.Build();
-host.Run();
+
+    return new LoggingPackRunNotificationPublisher(sp.GetRequiredService<ILogger<LoggingPackRunNotificationPublisher>>());
+});
+
+builder.Services.AddSingleton<IPackRunStateStore>(sp =>
+{
+    var options = sp.GetRequiredService<IOptions<PackRunWorkerOptions>>();
+    return new FilePackRunStateStore(options.Value.RunStatePath);
+});
+
+builder.Services.AddSingleton<IPackRunStepExecutor, NoopPackRunStepExecutor>();
+builder.Services.AddSingleton<PackRunExecutionGraphBuilder>();
+builder.Services.AddSingleton<PackRunSimulationEngine>();
+builder.Services.AddSingleton<PackRunProcessor>();
+builder.Services.AddHostedService<PackRunWorkerService>();
+
+var host = builder.Build();
+host.Run();

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Worker/Services/PackRunWorkerOptions.cs

@@ -8,5 +8,7 @@ public sealed class PackRunWorkerOptions
 
     public string ArchivePath { get; set; } = Path.Combine(AppContext.BaseDirectory, "queue", "archive");
 
-    public string ApprovalStorePath { get; set; } = Path.Combine(AppContext.BaseDirectory, "approvals");
-}
+    public string ApprovalStorePath { get; set; } = Path.Combine(AppContext.BaseDirectory, "approvals");
+
+    public string RunStatePath { get; set; } = Path.Combine(AppContext.BaseDirectory, "state", "runs");
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Worker/Services/PackRunWorkerService.cs

@@ -1,49 +1,540 @@
-using StellaOps.TaskRunner.Core.Execution;
-using Microsoft.Extensions.Options;
-
-namespace StellaOps.TaskRunner.Worker.Services;
-
-public sealed class PackRunWorkerService : BackgroundService
-{
-    private readonly IPackRunJobDispatcher dispatcher;
-    private readonly PackRunProcessor processor;
-    private readonly PackRunWorkerOptions options;
-    private readonly ILogger<PackRunWorkerService> logger;
-
-    public PackRunWorkerService(
-        IPackRunJobDispatcher dispatcher,
-        PackRunProcessor processor,
-        IOptions<PackRunWorkerOptions> options,
-        ILogger<PackRunWorkerService> logger)
-    {
-        this.dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
-        this.processor = processor ?? throw new ArgumentNullException(nameof(processor));
-        this.options = options?.Value ?? throw new ArgumentNullException(nameof(options));
-        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
-    }
-
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        while (!stoppingToken.IsCancellationRequested)
-        {
-            var context = await dispatcher.TryDequeueAsync(stoppingToken).ConfigureAwait(false);
-            if (context is null)
-            {
-                await Task.Delay(options.IdleDelay, stoppingToken).ConfigureAwait(false);
-                continue;
-            }
-
-            logger.LogInformation("Processing pack run {RunId}.", context.RunId);
-            var result = await processor.ProcessNewRunAsync(context, stoppingToken).ConfigureAwait(false);
-
-            if (result.ShouldResumeImmediately)
-            {
-                logger.LogInformation("Run {RunId} is ready to resume immediately.", context.RunId);
-            }
-            else
-            {
-                logger.LogInformation("Run {RunId} is awaiting approvals.", context.RunId);
-            }
-        }
-    }
-}
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
+using System.Text.Json.Nodes;
+using Microsoft.Extensions.Options;
+using StellaOps.TaskRunner.Core.Execution;
+using StellaOps.TaskRunner.Core.Execution.Simulation;
+using StellaOps.TaskRunner.Core.Planning;
+
+namespace StellaOps.TaskRunner.Worker.Services;
+
+public sealed class PackRunWorkerService : BackgroundService
+{
+    private const string ChildFailureReason = "child-failure";
+    private const string AwaitingRetryReason = "awaiting-retry";
+
+    private readonly IPackRunJobDispatcher dispatcher;
+    private readonly PackRunProcessor processor;
+    private readonly PackRunWorkerOptions options;
+    private readonly IPackRunStateStore stateStore;
+    private readonly PackRunExecutionGraphBuilder graphBuilder;
+    private readonly PackRunSimulationEngine simulationEngine;
+    private readonly IPackRunStepExecutor executor;
+    private readonly ILogger<PackRunWorkerService> logger;
+
+    public PackRunWorkerService(
+        IPackRunJobDispatcher dispatcher,
+        PackRunProcessor processor,
+        IPackRunStateStore stateStore,
+        PackRunExecutionGraphBuilder graphBuilder,
+        PackRunSimulationEngine simulationEngine,
+        IPackRunStepExecutor executor,
+        IOptions<PackRunWorkerOptions> options,
+        ILogger<PackRunWorkerService> logger)
+    {
+        this.dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
+        this.processor = processor ?? throw new ArgumentNullException(nameof(processor));
+        this.stateStore = stateStore ?? throw new ArgumentNullException(nameof(stateStore));
+        this.graphBuilder = graphBuilder ?? throw new ArgumentNullException(nameof(graphBuilder));
+        this.simulationEngine = simulationEngine ?? throw new ArgumentNullException(nameof(simulationEngine));
+        this.executor = executor ?? throw new ArgumentNullException(nameof(executor));
+        this.options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            var context = await dispatcher.TryDequeueAsync(stoppingToken).ConfigureAwait(false);
+            if (context is null)
+            {
+                await Task.Delay(options.IdleDelay, stoppingToken).ConfigureAwait(false);
+                continue;
+            }
+
+            try
+            {
+                await ProcessRunAsync(context, stoppingToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Unhandled exception while processing run {RunId}.", context.RunId);
+            }
+        }
+    }
+
+    private async Task ProcessRunAsync(PackRunExecutionContext context, CancellationToken cancellationToken)
+    {
+        logger.LogInformation("Processing pack run {RunId}.", context.RunId);
+
+        var processorResult = await processor.ProcessNewRunAsync(context, cancellationToken).ConfigureAwait(false);
+        var graph = graphBuilder.Build(context.Plan);
+
+        var state = await stateStore.GetAsync(context.RunId, cancellationToken).ConfigureAwait(false);
+        if (state is null || !string.Equals(state.PlanHash, context.Plan.Hash, StringComparison.Ordinal))
+        {
+            state = await CreateInitialStateAsync(context, graph, cancellationToken).ConfigureAwait(false);
+        }
+
+        if (!processorResult.ShouldResumeImmediately)
+        {
+            logger.LogInformation("Run {RunId} awaiting approvals or policy gates.", context.RunId);
+            return;
+        }
+
+        var gateUpdate = PackRunGateStateUpdater.Apply(state, graph, processorResult.ApprovalCoordinator, DateTimeOffset.UtcNow);
+        state = gateUpdate.State;
+
+        if (gateUpdate.HasBlockingFailure)
+        {
+            await stateStore.SaveAsync(state, cancellationToken).ConfigureAwait(false);
+            logger.LogWarning("Run {RunId} halted because a gate failed.", context.RunId);
+            return;
+        }
+
+        var updatedState = await ExecuteGraphAsync(context, graph, state, cancellationToken).ConfigureAwait(false);
+        await stateStore.SaveAsync(updatedState, cancellationToken).ConfigureAwait(false);
+
+        if (updatedState.Steps.Values.All(step => step.Status is PackRunStepExecutionStatus.Succeeded or PackRunStepExecutionStatus.Skipped))
+        {
+            logger.LogInformation("Run {RunId} finished successfully.", context.RunId);
+        }
+        else
+        {
+            logger.LogInformation("Run {RunId} paused with pending work.", context.RunId);
+        }
+    }
+
+    private async Task<PackRunState> CreateInitialStateAsync(
+        PackRunExecutionContext context,
+        PackRunExecutionGraph graph,
+        CancellationToken cancellationToken)
+    {
+        var timestamp = DateTimeOffset.UtcNow;
+        var simulation = simulationEngine.Simulate(context.Plan);
+        var simulationIndex = IndexSimulation(simulation.Steps);
+
+        var stepRecords = new Dictionary<string, PackRunStepStateRecord>(StringComparer.Ordinal);
+        foreach (var step in EnumerateSteps(graph.Steps))
+        {
+            var simulationStatus = simulationIndex.TryGetValue(step.Id, out var node)
+                ? node.Status
+                : PackRunSimulationStatus.Pending;
+
+            var status = step.Enabled ? PackRunStepExecutionStatus.Pending : PackRunStepExecutionStatus.Skipped;
+            string? statusReason = null;
+            if (!step.Enabled)
+            {
+                statusReason = "disabled";
+            }
+            else if (simulationStatus == PackRunSimulationStatus.RequiresApproval)
+            {
+                statusReason = "requires-approval";
+            }
+            else if (simulationStatus == PackRunSimulationStatus.RequiresPolicy)
+            {
+                statusReason = "requires-policy";
+            }
+            else if (simulationStatus == PackRunSimulationStatus.Skipped)
+            {
+                status = PackRunStepExecutionStatus.Skipped;
+                statusReason = "condition-false";
+            }
+
+            var record = new PackRunStepStateRecord(
+                step.Id,
+                step.Kind,
+                step.Enabled,
+                step.ContinueOnError,
+                step.MaxParallel,
+                step.ApprovalId,
+                step.GateMessage,
+                status,
+                Attempts: 0,
+                LastTransitionAt: null,
+                NextAttemptAt: null,
+                StatusReason: statusReason);
+
+            stepRecords[step.Id] = record;
+        }
+
+        var failurePolicy = graph.FailurePolicy ?? PackRunExecutionGraph.DefaultFailurePolicy;
+        var state = PackRunState.Create(context.RunId, context.Plan.Hash, failurePolicy, stepRecords, timestamp);
+        await stateStore.SaveAsync(state, cancellationToken).ConfigureAwait(false);
+        return state;
+    }
+
+    private async Task<PackRunState> ExecuteGraphAsync(
+        PackRunExecutionContext context,
+        PackRunExecutionGraph graph,
+        PackRunState state,
+        CancellationToken cancellationToken)
+    {
+        var mutable = new ConcurrentDictionary<string, PackRunStepStateRecord>(state.Steps, StringComparer.Ordinal);
+        var failurePolicy = graph.FailurePolicy ?? PackRunExecutionGraph.DefaultFailurePolicy;
+        var executionContext = new ExecutionContext(context.RunId, failurePolicy, mutable, cancellationToken);
+
+        foreach (var step in graph.Steps)
+        {
+            var outcome = await ExecuteStepAsync(step, executionContext).ConfigureAwait(false);
+            if (outcome is StepExecutionOutcome.AbortRun or StepExecutionOutcome.Defer)
+            {
+                break;
+            }
+        }
+
+        var updated = new ReadOnlyDictionary<string, PackRunStepStateRecord>(mutable);
+        return state with
+        {
+            UpdatedAt = DateTimeOffset.UtcNow,
+            Steps = updated
+        };
+    }
+
+    private async Task<StepExecutionOutcome> ExecuteStepAsync(
+        PackRunExecutionStep step,
+        ExecutionContext executionContext)
+    {
+        executionContext.CancellationToken.ThrowIfCancellationRequested();
+
+        if (!executionContext.Steps.TryGetValue(step.Id, out var record))
+        {
+            return StepExecutionOutcome.Continue;
+        }
+
+        if (!record.Enabled)
+        {
+            return StepExecutionOutcome.Continue;
+        }
+
+        if (record.Status == PackRunStepExecutionStatus.Succeeded || record.Status == PackRunStepExecutionStatus.Skipped)
+        {
+            return StepExecutionOutcome.Continue;
+        }
+
+        if (record.NextAttemptAt is { } scheduled && scheduled > DateTimeOffset.UtcNow)
+        {
+            logger.LogInformation(
+                "Run {RunId} step {StepId} waiting until {NextAttempt} for retry.",
+                executionContext.RunId,
+                record.StepId,
+                scheduled);
+            return StepExecutionOutcome.Defer;
+        }
+
+        switch (step.Kind)
+        {
+            case PackRunStepKind.GateApproval:
+            case PackRunStepKind.GatePolicy:
+                executionContext.Steps[step.Id] = record with
+                {
+                    Status = PackRunStepExecutionStatus.Succeeded,
+                    StatusReason = null,
+                    LastTransitionAt = DateTimeOffset.UtcNow,
+                    NextAttemptAt = null
+                };
+                return StepExecutionOutcome.Continue;
+
+            case PackRunStepKind.Parallel:
+                return await ExecuteParallelStepAsync(step, executionContext).ConfigureAwait(false);
+
+            case PackRunStepKind.Map:
+                return await ExecuteMapStepAsync(step, executionContext).ConfigureAwait(false);
+
+            case PackRunStepKind.Run:
+                return await ExecuteRunStepAsync(step, executionContext).ConfigureAwait(false);
+
+            default:
+                logger.LogWarning("Run {RunId} encountered unsupported step kind '{Kind}' for step {StepId}. Marking as skipped.",
+                    executionContext.RunId,
+                    step.Kind,
+                    step.Id);
+                executionContext.Steps[step.Id] = record with
+                {
+                    Status = PackRunStepExecutionStatus.Skipped,
+                    StatusReason = "unsupported-kind",
+                    LastTransitionAt = DateTimeOffset.UtcNow
+                };
+                return StepExecutionOutcome.Continue;
+        }
+    }
+
+    private async Task<StepExecutionOutcome> ExecuteRunStepAsync(
+        PackRunExecutionStep step,
+        ExecutionContext executionContext)
+    {
+        var record = executionContext.Steps[step.Id];
+        var now = DateTimeOffset.UtcNow;
+        var currentState = new PackRunStepState(record.Status, record.Attempts, record.LastTransitionAt, record.NextAttemptAt);
+
+        if (currentState.Status == PackRunStepExecutionStatus.Pending)
+        {
+            currentState = PackRunStepStateMachine.Start(currentState, now);
+            record = record with
+            {
+                Status = currentState.Status,
+                LastTransitionAt = currentState.LastTransitionAt,
+                NextAttemptAt = currentState.NextAttemptAt,
+                StatusReason = null
+            };
+            executionContext.Steps[step.Id] = record;
+        }
+
+        var result = await executor.ExecuteAsync(step, step.Parameters ?? PackRunExecutionStep.EmptyParameters, executionContext.CancellationToken).ConfigureAwait(false);
+        if (result.Succeeded)
+        {
+            currentState = PackRunStepStateMachine.CompleteSuccess(currentState, DateTimeOffset.UtcNow);
+            executionContext.Steps[step.Id] = record with
+            {
+                Status = currentState.Status,
+                Attempts = currentState.Attempts,
+                LastTransitionAt = currentState.LastTransitionAt,
+                NextAttemptAt = currentState.NextAttemptAt,
+                StatusReason = null
+            };
+
+            return StepExecutionOutcome.Continue;
+        }
+
+        logger.LogWarning(
+            "Run {RunId} step {StepId} failed: {Error}",
+            executionContext.RunId,
+            step.Id,
+            result.Error ?? "unknown error");
+
+        var failure = PackRunStepStateMachine.RegisterFailure(currentState, DateTimeOffset.UtcNow, executionContext.FailurePolicy);
+        var updatedRecord = record with
+        {
+            Status = failure.State.Status,
+            Attempts = failure.State.Attempts,
+            LastTransitionAt = failure.State.LastTransitionAt,
+            NextAttemptAt = failure.State.NextAttemptAt,
+            StatusReason = result.Error
+        };
+
+        executionContext.Steps[step.Id] = updatedRecord;
+
+        return failure.Outcome switch
+        {
+            PackRunStepFailureOutcome.Retry => StepExecutionOutcome.Defer,
+            PackRunStepFailureOutcome.Abort when step.ContinueOnError => StepExecutionOutcome.Continue,
+            PackRunStepFailureOutcome.Abort => StepExecutionOutcome.AbortRun,
+            _ => StepExecutionOutcome.AbortRun
+        };
+    }
+
+    private async Task<StepExecutionOutcome> ExecuteParallelStepAsync(
+        PackRunExecutionStep step,
+        ExecutionContext executionContext)
+    {
+        var children = step.Children;
+        if (children.Count == 0)
+        {
+            MarkContainerSucceeded(step, executionContext);
+            return StepExecutionOutcome.Continue;
+        }
+
+        var maxParallel = step.MaxParallel is > 0 ? step.MaxParallel.Value : children.Count;
+        var queue = new Queue<PackRunExecutionStep>(children);
+        var running = new List<Task<StepExecutionOutcome>>(maxParallel);
+        var outcome = StepExecutionOutcome.Continue;
+        var childFailureDetected = false;
+
+        while (queue.Count > 0 || running.Count > 0)
+        {
+            while (queue.Count > 0 && running.Count < maxParallel)
+            {
+                var child = queue.Dequeue();
+                running.Add(ExecuteStepAsync(child, executionContext));
+            }
+
+            var completed = await Task.WhenAny(running).ConfigureAwait(false);
+            running.Remove(completed);
+            var childOutcome = await completed.ConfigureAwait(false);
+
+            switch (childOutcome)
+            {
+                case StepExecutionOutcome.AbortRun:
+                    if (step.ContinueOnError)
+                    {
+                        childFailureDetected = true;
+                        outcome = StepExecutionOutcome.Continue;
+                    }
+                    else
+                    {
+                        outcome = StepExecutionOutcome.AbortRun;
+                        running.Clear();
+                        queue.Clear();
+                    }
+                    break;
+
+                case StepExecutionOutcome.Defer:
+                    outcome = StepExecutionOutcome.Defer;
+                    running.Clear();
+                    queue.Clear();
+                    break;
+
+                default:
+                    break;
+            }
+
+            if (!step.ContinueOnError && outcome != StepExecutionOutcome.Continue)
+            {
+                break;
+            }
+        }
+
+        if (outcome == StepExecutionOutcome.Continue)
+        {
+            if (childFailureDetected)
+            {
+                MarkContainerFailure(step, executionContext, ChildFailureReason);
+            }
+            else
+            {
+                MarkContainerSucceeded(step, executionContext);
+            }
+        }
+        else if (outcome == StepExecutionOutcome.AbortRun)
+        {
+            MarkContainerFailure(step, executionContext, ChildFailureReason);
+        }
+        else if (outcome == StepExecutionOutcome.Defer)
+        {
+            MarkContainerPending(step, executionContext, AwaitingRetryReason);
+        }
+
+        return outcome;
+    }
+
+    private async Task<StepExecutionOutcome> ExecuteMapStepAsync(
+        PackRunExecutionStep step,
+        ExecutionContext executionContext)
+    {
+        foreach (var child in step.Children)
+        {
+            var outcome = await ExecuteStepAsync(child, executionContext).ConfigureAwait(false);
+            if (outcome != StepExecutionOutcome.Continue)
+            {
+                if (outcome == StepExecutionOutcome.Defer)
+                {
+                    MarkContainerPending(step, executionContext, AwaitingRetryReason);
+                    return outcome;
+                }
+
+                if (!step.ContinueOnError)
+                {
+                    MarkContainerFailure(step, executionContext, ChildFailureReason);
+                    return outcome;
+                }
+
+                MarkContainerFailure(step, executionContext, ChildFailureReason);
+            }
+        }
+
+        MarkContainerSucceeded(step, executionContext);
+        return StepExecutionOutcome.Continue;
+    }
+
+    private void MarkContainerSucceeded(PackRunExecutionStep step, ExecutionContext executionContext)
+    {
+        if (!executionContext.Steps.TryGetValue(step.Id, out var record))
+        {
+            return;
+        }
+
+        if (record.Status == PackRunStepExecutionStatus.Succeeded)
+        {
+            return;
+        }
+
+        executionContext.Steps[step.Id] = record with
+        {
+            Status = PackRunStepExecutionStatus.Succeeded,
+            StatusReason = null,
+            LastTransitionAt = DateTimeOffset.UtcNow,
+            NextAttemptAt = null
+        };
+    }
+
+    private void MarkContainerFailure(PackRunExecutionStep step, ExecutionContext executionContext, string reason)
+    {
+        if (!executionContext.Steps.TryGetValue(step.Id, out var record))
+        {
+            return;
+        }
+
+        executionContext.Steps[step.Id] = record with
+        {
+            Status = PackRunStepExecutionStatus.Failed,
+            StatusReason = reason,
+            LastTransitionAt = DateTimeOffset.UtcNow
+        };
+    }
+
+    private void MarkContainerPending(PackRunExecutionStep step, ExecutionContext executionContext, string reason)
+    {
+        if (!executionContext.Steps.TryGetValue(step.Id, out var record))
+        {
+            return;
+        }
+
+        executionContext.Steps[step.Id] = record with
+        {
+            Status = PackRunStepExecutionStatus.Pending,
+            StatusReason = reason,
+            LastTransitionAt = DateTimeOffset.UtcNow
+        };
+    }
+
+    private static Dictionary<string, PackRunSimulationNode> IndexSimulation(IReadOnlyList<PackRunSimulationNode> steps)
+    {
+        var result = new Dictionary<string, PackRunSimulationNode>(StringComparer.Ordinal);
+        foreach (var node in steps)
+        {
+            result[node.Id] = node;
+            if (node.Children.Count > 0)
+            {
+                foreach (var child in IndexSimulation(node.Children))
+                {
+                    result[child.Key] = child.Value;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private static IEnumerable<PackRunExecutionStep> EnumerateSteps(IReadOnlyList<PackRunExecutionStep> steps)
+    {
+        foreach (var step in steps)
+        {
+            yield return step;
+            if (step.Children.Count > 0)
+            {
+                foreach (var child in EnumerateSteps(step.Children))
+                {
+                    yield return child;
+                }
+            }
+        }
+    }
+
+    private sealed record ExecutionContext(
+        string RunId,
+        TaskPackPlanFailurePolicy FailurePolicy,
+        ConcurrentDictionary<string, PackRunStepStateRecord> Steps,
+        CancellationToken CancellationToken);
+
+    private enum StepExecutionOutcome
+    {
+        Continue,
+        Defer,
+        AbortRun
+    }
+}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Worker/appsettings.json

@@ -5,12 +5,13 @@
       "Microsoft.Hosting.Lifetime": "Information"
     }
   },
-  "Worker": {
-    "IdleDelay": "00:00:01",
-    "QueuePath": "queue",
-    "ArchivePath": "queue/archive",
-    "ApprovalStorePath": "state/approvals"
-  },
+  "Worker": {
+    "IdleDelay": "00:00:01",
+    "QueuePath": "queue",
+    "ArchivePath": "queue/archive",
+    "ApprovalStorePath": "state/approvals",
+    "RunStatePath": "state/runs"
+  },
   "Notifications": {
     "ApprovalEndpoint": null,
     "PolicyEndpoint": null

src/TaskRunner/StellaOps.TaskRunner/TASKS.md

@@ -3,14 +3,18 @@
 ## Sprint 41 – Foundations
 | ID | Status | Owner(s) | Depends on | Description | Exit Criteria |
 |----|--------|----------|------------|-------------|---------------|
-| TASKRUN-41-001 | DOING (2025-11-01) | Task Runner Guild | ORCH-SVC-41-101, AUTH-PACKS-41-001 | Bootstrap service, define migrations for `pack_runs`, `pack_run_logs`, `pack_artifacts`, implement run API (create/get/log stream), local executor, approvals pause, artifact capture, and provenance manifest generation. | Service builds/tests; migrations scripted; run API functional with sample pack; logs/artefacts stored; manifest signed; compliance checklist recorded. |
+| TASKRUN-41-001 | DOING (2025-11-01) | Task Runner Guild | ORCH-SVC-41-101, AUTH-PACKS-41-001 | Bootstrap service, define migrations for `pack_runs`, `pack_run_logs`, `pack_artifacts`, implement run API (create/get/log stream), local executor, approvals pause, artifact capture, and provenance manifest generation. | Service builds/tests; migrations scripted; run API functional with sample pack; logs/artefacts stored; manifest signed; compliance checklist recorded. |
 
 ## Sprint 42 – Advanced Execution
 | ID | Status | Owner(s) | Depends on | Description | Exit Criteria |
 |----|--------|----------|------------|-------------|---------------|
-| TASKRUN-42-001 | DOING (2025-10-29) | Task Runner Guild | TASKRUN-41-001 | Add loops, conditionals, `maxParallel`, outputs, simulation mode, policy gate integration, and failure recovery (retry/abort) with deterministic state. | Executor handles control flow; simulation returns plan; policy gates pause for approvals; tests cover restart/resume. |
+| TASKRUN-42-001 | DONE (2025-11-04) | Task Runner Guild | TASKRUN-41-001 | Add loops, conditionals, `maxParallel`, outputs, simulation mode, policy gate integration, and failure recovery (retry/abort) with deterministic state. | Executor handles control flow; simulation returns plan; policy gates pause for approvals; tests cover restart/resume. |
 > 2025-10-29: Initiated manifest parsing + deterministic planning core to unblock approvals pipeline; building expression engine + plan hashing to support CLI parity.
 > 2025-10-29: Landed manifest loader, planner, deterministic hash, outputs + approval/policy insights with unit tests; awaiting upstream APIs for execution-side wiring.
+> 2025-11-04: Worker now builds execution graph, enforces parallelism/continue-on-error, persists retry windows, and WebService exposes simulation/run-state APIs.
+> 2025-11-04: Resuming execution-engine enhancements (loops, conditionals, maxParallel) and simulation mode wiring; mapping failure recovery + policy gate enforcement plan.
+> 2025-11-04: Continuing wiring — fixing file-backed state store, validating retry metadata, and preparing CLI surface for the simulation preview.
+> 2025-11-04: Gate outcomes now reflect approval states; CLI `task-runner simulate` surfaces the new simulation API.
 
 ## Sprint 43 – Approvals, Notifications, Hardening
 | ID | Status | Owner(s) | Depends on | Description | Exit Criteria |
@@ -37,7 +41,7 @@
 ## Air-Gapped Mode (Epic 16)
 | ID | Status | Owner(s) | Depends on | Description | Exit Criteria |
 |----|--------|----------|------------|-------------|---------------|
-| TASKRUN-AIRGAP-56-001 | DOING (2025-11-03) | Task Runner Guild, AirGap Policy Guild | AIRGAP-POL-56-001, TASKRUN-OBS-50-001 | Enforce plan-time validation rejecting steps with non-allowlisted network calls in sealed mode and surface remediation errors. | Planner blocks disallowed steps; error contains remediation; tests cover sealed/unsealed behavior. |
+| TASKRUN-AIRGAP-56-001 | DOING (2025-11-03) | Task Runner Guild, AirGap Policy Guild | AIRGAP-POL-56-001, TASKRUN-OBS-50-001 | Enforce plan-time validation rejecting steps with non-allowlisted network calls in sealed mode and surface remediation errors. | Planner blocks disallowed steps; error contains remediation; tests cover sealed/unsealed behavior. |
 | TASKRUN-AIRGAP-56-002 | TODO | Task Runner Guild, AirGap Importer Guild | TASKRUN-AIRGAP-56-001, AIRGAP-IMP-57-002 | Add helper steps for bundle ingestion (checksum verification, staging to object store) with deterministic outputs. | Helper steps succeed deterministically; integration tests import sample bundle. |
 | TASKRUN-AIRGAP-57-001 | TODO | Task Runner Guild, AirGap Controller Guild | TASKRUN-AIRGAP-56-001, AIRGAP-CTL-56-002 | Refuse to execute plans when environment sealed=false but declared sealed install; emit advisory timeline events. | Mismatch detection works; timeline + telemetry record violation; docs updated. |
 | TASKRUN-AIRGAP-58-001 | TODO | Task Runner Guild, Evidence Locker Guild | TASKRUN-OBS-53-001, EVID-OBS-55-001 | Capture bundle import job transcripts, hashed inputs, and outputs into portable evidence bundles. | Evidence recorded; manifests deterministic; timeline references created. |