ruby_reactor 0.7.0 → 0.8.0

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -25,17 +25,38 @@ module RubyReactor
         @args_validator = nil
         @output_validator = nil
         @retry_config = {}
+        @inline_contract = nil
+        @rule_sites = []
+      end
+
+      # Deprecation notices print once per declaration site for the process.
+      def self.deprecation_sites
+        @deprecation_sites ||= Set.new
       end
 
       def argument(name, source, type = nil, transform: nil, **predicates)
         @arguments[name] = {
           source: source,
-          transform: transform
+          transform: transform,
+          origin: :explicit
         }
 
         return unless type || predicates.any?
 
         @arg_validations << [name, type, false, predicates]
+        @rule_sites << [name, caller_locations(1, 1).first]
+      end
+
+      # An inline step's input contract. Inside the block `input` declares, as
+      # in a step class; outside it `input(:x)` stays the template reference.
+      def inputs(&block)
+        if @impl
+          raise Error::ValidationError,
+                "step :#{@name}: `inputs` is for inline steps; declare `input` inside #{@impl} instead."
+        end
+
+        @inline_contract ||= RubyReactor::Step::InputContract.new(owner: @name)
+        @inline_contract.instance_eval(&block)
       end
 
       def run(&block)
@@ -67,6 +88,7 @@ module RubyReactor
       # pre-built schema) is applied last and wins on conflicts.
       def validate_args(schema_or_validator = nil, &block)
         @validate_args_input = block || schema_or_validator
+        @validate_args_site = caller_locations(1, 1).first
       end
 
       # Scalar-aware output validation.
@@ -114,6 +136,9 @@ module RubyReactor
       # unit rather than run inline — `:step` for `async_step`, `:reactor` for
       # `async_reactor`. Nil for an ordinary step.
       def build(async_dispatch: nil)
+        check_contract_conflicts!
+        warn_deprecated_rules
+
         step_config = {
           async_dispatch: async_dispatch,
           name: @name,
@@ -127,16 +152,78 @@ module RubyReactor
           dependencies: @dependencies,
           args_validator: @args_validator || build_args_validator(@arg_validations, @validate_args_input),
           output_validator: @output_validator,
+          inline_contract: @inline_contract,
           retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
         }
 
         RubyReactor::Dsl::StepConfig.new(step_config)
       end
+
+      private
+
+      # A step that owns its input contract takes wiring only from the
+      # reactor: rules here would be a second, overlapping rule set.
+      def check_contract_conflicts!
+        contract = owned_contract
+        return unless contract
+
+        owner = @impl || "its `inputs do ... end` block"
+        if (arg = @arg_validations.first&.first)
+          raise Error::ValidationError,
+                "#{reactor_label} step :#{@name} declares rules on argument :#{arg}, but #{owner} owns its input " \
+                "contract. Move the rule into #{owner} (`input :#{arg}, ...`) and keep only the wiring here: " \
+                "`argument :#{arg}, <source>`."
+        end
+        if @validate_args_input
+          raise Error::ValidationError,
+                "#{reactor_label} step :#{@name} declares `validate_args`, but #{owner} owns its input contract. " \
+                "Move the rule into #{owner} (`validate_inputs ...`) and keep only the wiring here."
+        end
+
+        unknown = @arguments.keys.find { |name| !contract.declares?(name) }
+        return unless unknown
+
+        raise Error::ValidationError,
+              "#{reactor_label} step :#{@name} wires argument :#{unknown}, which #{owner} does not declare. " \
+              "Declared inputs: #{contract.declarations.keys.join(", ")}."
+      end
+
+      # Rules on `argument` / `validate_args` still work for a step without a
+      # contract; they now belong on the step itself.
+      def warn_deprecated_rules
+        target = @impl || "an `inputs do ... end` block"
+        @rule_sites.each do |arg, site|
+          warn_deprecation(site, "step :#{@name} declares rules on `argument :#{arg}`. Declare them on the step " \
+                                 "instead (`input :#{arg}, ...` in #{target}) and keep `argument :#{arg}, <source>` " \
+                                 "for wiring.")
+        end
+        return unless @validate_args_site
+
+        warn_deprecation(@validate_args_site, "step :#{@name} declares rules with `validate_args`. Declare them on " \
+                                              "the step instead (`validate_inputs` in #{target}).")
+      end
+
+      def warn_deprecation(site, message)
+        location = "#{site.path}:#{site.lineno}"
+        return unless StepBuilder.deprecation_sites.add?(location)
+
+        warn "[RubyReactor] DEPRECATION: #{location} #{reactor_label} #{message} " \
+             "Removal no earlier than the next MAJOR."
+      end
+
+      def owned_contract
+        @inline_contract || (@impl.input_contract if @impl.respond_to?(:declares_inputs?) && @impl.declares_inputs?)
+      end
+
+      def reactor_label
+        @reactor&.name || @reactor.inspect
+      end
     end
 
     class StepConfig
       attr_reader :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
-                  :dependencies, :args_validator, :output_validator, :retry_config, :async_dispatch
+                  :dependencies, :args_validator, :output_validator, :retry_config, :async_dispatch,
+                  :inline_contract
 
       def initialize(config)
         @async_dispatch = config[:async_dispatch]
@@ -151,6 +238,7 @@ module RubyReactor
         @dependencies = config[:dependencies] || []
         @args_validator = config[:args_validator]
         @output_validator = config[:output_validator]
+        @inline_contract = config[:inline_contract]
         @retry_config = { max_attempts: 1 }.merge(config[:retry_config] || {})
       end
 
@@ -165,6 +253,11 @@ module RubyReactor
         !@impl.nil?
       end
 
+      # The contract that governs this step's inputs, or nil when it has none.
+      def input_contract
+        @inline_contract || (@impl.input_contract if @impl.respond_to?(:declares_inputs?) && @impl.declares_inputs?)
+      end
+
       def has_run_block?
         !@run_block.nil?
       end

data/lib/ruby_reactor/dsl/template_helpers.rb

@@ -3,6 +3,8 @@
 module RubyReactor
   module Dsl
     module TemplateHelpers
+      include RubyReactor::StepSignals
+
       def input(name, path = nil)
         RubyReactor::Template::Input.new(name, path)
       end
@@ -19,7 +21,7 @@ module RubyReactor
         RubyReactor::Template::Element.new(map_name, path)
       end
 
-      # Make Success, Failure, and Skipped available in DSL contexts
+      # Make Success, Failure, Halt, and Skipped available in DSL contexts
       # rubocop:disable Naming/MethodName
       def Success(value = nil)
         # rubocop:enable Naming/MethodName
@@ -27,15 +29,21 @@ module RubyReactor
       end
 
       # rubocop:disable Naming/MethodName
-      def Failure(error)
+      def Failure(...)
+        # rubocop:enable Naming/MethodName
+        RubyReactor.Failure(...)
+      end
+
+      # rubocop:disable Naming/MethodName
+      def Halt(reason: nil, **kwargs)
         # rubocop:enable Naming/MethodName
-        RubyReactor.Failure(error)
+        RubyReactor.Halt(reason: reason, **kwargs)
       end
 
       # rubocop:disable Naming/MethodName
-      def Skipped(reason: nil, **kwargs)
+      def Skipped(...)
         # rubocop:enable Naming/MethodName
-        RubyReactor.Skipped(reason: reason, **kwargs)
+        RubyReactor.Skipped(...)
       end
     end
   end

data/lib/ruby_reactor/dsl/validation_helpers.rb

@@ -36,6 +36,23 @@ module RubyReactor
         RubyReactor::Validation::InputValidator.new(schema)
       end
 
+      # Dispatch across the layered `input` forms, shared by reactor inputs and
+      # step input contracts:
+      #   Form 3 — pre-built schema / contract (`validate:`)
+      #   Form 2 — block bound to the value macro (`do |i| ... end`)
+      #   legacy — single-key schema block (`do required(:name)... end`)
+      #   Form 1 / 1b — inline scalar or class type
+      #   Form 0 — declaration only (no validator)
+      def build_declaration_validator(name, type, optional, validate, predicates, &block)
+        if validate
+          create_input_validator(validate)
+        elsif block
+          block.arity.nonzero? ? build_macro_validator(name, optional, &block) : create_input_validator(block)
+        elsif type || predicates.any?
+          build_inline_validator(name, type, optional, predicates)
+        end
+      end
+
       # Compose per-argument inline rules with an optional `validate_args`
       # block / pre-built schema. Returns nil when there is nothing to validate.
       def build_args_validator(inline_rules, validate_input)

data/lib/ruby_reactor/error/input_validation_error.rb

@@ -28,6 +28,10 @@ module RubyReactor
       def to_s
         @message || build_message
       end
+
+      def retryable?
+        false
+      end
     end
   end
 end

data/lib/ruby_reactor/error/step_failure_error.rb

@@ -3,18 +3,25 @@
 module RubyReactor
   module Error
     class StepFailureError < Base
-      attr_reader :step_arguments, :exception_class
+      attr_reader :step_arguments, :exception_class, :validation_errors
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(message, step: nil, context: nil, original_error: nil, step_arguments: {}, exception_class: nil)
+      def initialize(message, step: nil, context: nil, original_error: nil, step_arguments: {}, exception_class: nil,
+                     validation_errors: nil)
         # rubocop:enable Metrics/ParameterLists
         super(message, step: step, context: context, original_error: original_error)
         @step_arguments = step_arguments
         @exception_class = exception_class
+        @validation_errors = validation_errors
       end
 
+      # Defers to the original error when it has an opinion (e.g. a step's own
+      # `Error::InputValidationError`, always non-retryable) so that opinion
+      # survives being wrapped into a StepFailureError — the same
+      # `respond_to?(:retryable?)` protocol `RubyReactor::Failure` itself uses.
+      # Defaults to `true` for an ordinary step failure, unchanged from before.
       def retryable?
-        true
+        original_error.respond_to?(:retryable?) ? original_error.retryable? : true
       end
     end
   end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -55,33 +55,44 @@ module RubyReactor
         @context.middlewares || RubyReactor::MiddlewareRunner.new([])
       end
 
+      # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
+      def loggable_value(result)
+        if result.respond_to?(:value)
+          result.value
+        elsif result.respond_to?(:error)
+          result.error
+        else
+          result
+        end
+      end
+
+      def skipped_result?(result)
+        result.respond_to?(:skipped?) && result.skipped?
+      end
+
       def compensate_step(step_config, error, arguments)
         middlewares.on(:start_compensation, step_config.name, error, arguments, @context)
         begin
-          compensate_result = if step_config.compensate_block
-                                step_config.compensate_block.call(error, arguments, @context)
-                              elsif step_config.has_impl?
-                                step_config.impl.compensate(error, arguments, @context)
-                              else
-                                RubyReactor.Success() # Default compensation
-                              end
-
-          # Ensure we have a value to log
-          logged_result = if compensate_result.respond_to?(:value)
-                            compensate_result.value
-                          elsif compensate_result.respond_to?(:error)
-                            compensate_result.error
-                          else
-                            compensate_result
-                          end
-
-          @context.execution_trace << {
-            type: :compensate,
-            step: step_config.name,
-            timestamp: Time.now,
-            result: logged_result,
-            arguments: arguments
-          }
+          compensate_result = catch(StepSignals::TAG) do
+            if step_config.compensate_block
+              step_config.compensate_block.call(error, arguments, @context)
+            elsif step_config.has_impl?
+              step_config.impl.compensate(error, arguments, @context)
+            else
+              RubyReactor.Skipped() # Default: nothing defined, rollback continues
+            end
+          end
+
+          @context.append_execution_trace(
+            {
+              type: :compensate,
+              step: step_config.name,
+              timestamp: Time.now,
+              result: loggable_value(compensate_result),
+              arguments: arguments,
+              skipped: skipped_result?(compensate_result)
+            }
+          )
           @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
 
           if compensate_result.is_a?(RubyReactor::Failure)
@@ -100,25 +111,26 @@ module RubyReactor
       def undo_step(step_config, result, arguments)
         middlewares.on(:start_undo, step_config.name, result, arguments, @context)
         begin
-          undo_result = if step_config.undo_block
-                          step_config.undo_block.call(result.value, arguments, @context)
-                        elsif step_config.has_impl?
-                          step_config.impl.undo(result.value, arguments, @context)
-                        else
-                          RubyReactor.Success()
-                        end
-
-          # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
-          logged_result = if undo_result.respond_to?(:value)
-                            undo_result.value
-                          elsif undo_result.respond_to?(:error)
-                            undo_result.error
-                          else
-                            undo_result
-                          end
-
-          @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: logged_result,
-                                        arguments: arguments }
+          undo_result = catch(StepSignals::TAG) do
+            if step_config.undo_block
+              step_config.undo_block.call(result.value, arguments, @context)
+            elsif step_config.has_impl?
+              step_config.impl.undo(result.value, arguments, @context)
+            else
+              RubyReactor.Skipped() # Default: nothing defined, rollback continues
+            end
+          end
+
+          @context.append_execution_trace(
+            {
+              type: :undo,
+              step: step_config.name,
+              timestamp: Time.now,
+              result: loggable_value(undo_result),
+              arguments: arguments,
+              skipped: skipped_result?(undo_result)
+            }
+          )
 
           if undo_result.is_a?(RubyReactor::Failure)
             middlewares.on(:failed_undo, step_config.name, undo_result, @context)
@@ -130,8 +142,9 @@ module RubyReactor
         rescue StandardError => e
           middlewares.on(:failed_undo, step_config.name, e, @context)
           # Log undo failure but don't halt the rollback process
-          @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
-                                        error: e.message }
+          @context.append_execution_trace(
+            { type: :undo_failure, step: step_config.name, timestamp: Time.now, error: e.message }
+          )
           RubyReactor.Failure(e)
         end
       end

data/lib/ruby_reactor/executor/ordered_lock_support.rb

@@ -117,14 +117,14 @@ module RubyReactor
         @ordered_lock_drained_replay == true
       end
 
-      # Terminal Skipped result when the ordered-lock gate short-circuits this
+      # Terminal Halt result when the ordered-lock gate short-circuits this
       # run (stale batch, strict chain failure, or a drained-batch redelivery of
       # an already-terminal context), or nil to continue. Shared by `execute`
       # and `resume_execution`.
       def ordered_lock_short_circuit
-        return RubyReactor::Skipped.new(reason: :ordered_lock_stale_batch) if ordered_lock_stale_batch?
-        return RubyReactor::Skipped.new(reason: :ordered_lock_drained_replay) if ordered_lock_drained_replay?
-        return RubyReactor::Skipped.new(reason: :ordered_lock_chain_failed) if ordered_lock_chain_skip?
+        return RubyReactor::Halt.new(reason: :ordered_lock_stale_batch) if ordered_lock_stale_batch?
+        return RubyReactor::Halt.new(reason: :ordered_lock_drained_replay) if ordered_lock_drained_replay?
+        return RubyReactor::Halt.new(reason: :ordered_lock_chain_failed) if ordered_lock_chain_skip?
 
         nil
       end
@@ -138,12 +138,12 @@ module RubyReactor
       def short_circuit!(result)
         @result = result
 
-        # A stale-batch or drained-batch-redelivery skip means this run's epoch
+        # A stale-batch or drained-batch-redelivery halt means this run's epoch
         # belongs to a drained generation — typically a slow straggler or a
         # Sidekiq at-least-once redelivery. If the redelivery is of a job that
         # ALREADY reached a terminal status, its stored context is the source of
-        # truth; writing :skipped over a :completed/:failed record would silently
-        # corrupt the outcome. Return the skip to the worker (so it stops)
+        # truth; writing :halted over a :completed/:failed record would silently
+        # corrupt the outcome. Return the halt to the worker (so it stops)
         # without saving. The `@skip_context_persist` flag also suppresses the
         # ensure-block save in execute / resume_execution, which would otherwise
         # clobber the stored terminal record with this run's stale in-memory
@@ -169,14 +169,14 @@ module RubyReactor
       # set when the status was terminal, but re-checking keeps both paths
       # uniform and self-guarding.
       def redelivery_of_terminal?(result)
-        return false unless result.is_a?(RubyReactor::Skipped)
+        return false unless result.is_a?(RubyReactor::Halt)
         return false unless %i[ordered_lock_stale_batch ordered_lock_drained_replay].include?(result.reason)
 
         stored_status_terminal?
       end
 
       def stored_status_terminal?
-        %w[completed failed skipped].include?(stored_context_status)
+        %w[completed failed halted skipped].include?(stored_context_status)
       end
 
       def stored_context_status

data/lib/ruby_reactor/executor/result_handler.rb

@@ -14,9 +14,13 @@ module RubyReactor
 
       def handle_step_result(step_config, result, resolved_arguments)
         case result
+        when RubyReactor::Halt
+          # Important: must come before Skipped and Success — both are Halt's
+          # siblings under Success, and Halt takes precedence over either.
+          handle_halt(step_config, result)
         when RubyReactor::Skipped
-          # Important: must come before the Success branch — Skipped < Success.
-          handle_skipped(step_config, result)
+          # Must come before the Success branch — Skipped < Success.
+          handle_skipped(step_config, result, resolved_arguments)
         when RubyReactor::Success
           handle_success(step_config, result, resolved_arguments)
         when RubyReactor::MaxRetriesExhaustedFailure
@@ -78,19 +82,40 @@ module RubyReactor
         )
       end
 
-      # A step returned `RubyReactor.Skipped(...)`. Halt cleanly: record the
+      # A step returned `RubyReactor.Halt(...)`. Halt cleanly: record the
       # event in the trace, do NOT push to the undo stack (so existing
       # completed steps stay as-is — no compensation), and stamp the step
       # name on the result so the caller can see who halted.
-      def handle_skipped(step_config, result)
+      def handle_halt(step_config, result)
         @step_results[step_config.name] = result
         result.instance_variable_set(:@step_name, step_config.name) if result.step_name.nil?
-        @context.execution_trace << {
-          type: :skipped,
-          step: step_config.name,
-          timestamp: Time.now,
-          reason: result.reason
-        }
+        @context.append_execution_trace(
+          {
+            type: :halt,
+            step: step_config.name,
+            timestamp: Time.now,
+            reason: result.reason
+          }
+        )
+        result
+      end
+
+      # A step returned `RubyReactor.Skipped(...)`. The reactor continues:
+      # validate and record the value exactly like a Success, but do NOT push
+      # to the undo stack (nothing happened, so there is nothing to undo).
+      def handle_skipped(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result.value, resolved_arguments)
+        @step_results[step_config.name] = result
+        @context.set_result(step_config.name, result.value)
+        @dependency_graph.complete_step(step_config.name)
+        @context.append_execution_trace(
+          {
+            type: :skipped,
+            step: step_config.name,
+            timestamp: Time.now,
+            reason: result.reason
+          }
+        )
         result
       end
 
@@ -118,7 +143,8 @@ module RubyReactor
         orig_err = result.original_error.is_a?(Exception) ? result.original_error : nil
         error = Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
                                                           original_error: orig_err,
-                                                          step_arguments: resolved_arguments)
+                                                          step_arguments: resolved_arguments,
+                                                          validation_errors: result.validation_errors)
         if result.respond_to?(:backtrace) && result.backtrace
           error.set_backtrace(result.backtrace)
         elsif orig_err
@@ -130,9 +156,12 @@ module RubyReactor
       def handle_failure(step_config, result, resolved_arguments)
         failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
         orig_err = result.error.is_a?(Exception) ? result.error : nil
+        # A step that propagates another unit's validation failure (an
+        # async_step reader) keeps its field errors on the reactor's failure.
         error = Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
                                                                   original_error: orig_err,
-                                                                  step_arguments: resolved_arguments)
+                                                                  step_arguments: resolved_arguments,
+                                                                  validation_errors: result.validation_errors)
         if result.respond_to?(:backtrace) && result.backtrace
           error.set_backtrace(result.backtrace)
         elsif orig_err
@@ -197,7 +226,9 @@ module RubyReactor
           exception_class: exception_class,
           file_path: file_path,
           line_number: line_number,
-          code_snippet: code_snippet
+          code_snippet: code_snippet,
+          validation_errors: error.validation_errors,
+          retryable: error.retryable?
         )
       end
 

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -94,7 +94,10 @@ module RubyReactor
 
       def handle_retry_result(step_config, reactor_class, result)
         case result
-        when RubyReactor::Success
+        when RubyReactor::Halt, RubyReactor::Skipped, RubyReactor::Success
+          # Halt and Skipped are Success subclasses, so they already take this
+          # path via inheritance; the explicit arms are readability plus a
+          # guard against a future hierarchy change (R5).
           clear_retry_state
           result
         when RubyReactor::Failure
@@ -182,7 +185,8 @@ module RubyReactor
                            []
                          end,
           reactor_name: reactor_class.name,
-          step_arguments: result.respond_to?(:step_arguments) ? result.step_arguments : {}
+          step_arguments: result.respond_to?(:step_arguments) ? result.step_arguments : {},
+          validation_errors: result.validation_errors
         )
       end
 

data/lib/ruby_reactor/executor/step_executor.rb

@@ -37,10 +37,10 @@ module RubyReactor
             # If a step returns RetryQueuedResult, we need to stop and return it
             return result if result.is_a?(RetryQueuedResult)
 
-            # If a step returns Skipped, halt the reactor cleanly (no
+            # If a step returns Halt, stop the reactor cleanly (no
             # compensation). Must be checked BEFORE Failure / Success because
-            # Skipped is a Success subclass.
-            return result if result.is_a?(RubyReactor::Skipped)
+            # Halt is a Success subclass.
+            return result if result.is_a?(RubyReactor::Halt)
 
             # If a step returns Failure, we need to stop execution and return it
             return result if result.is_a?(RubyReactor::Failure)
@@ -48,13 +48,17 @@ module RubyReactor
             # If a step returns InterruptResult, we need to stop execution and return it
             return result if result.is_a?(RubyReactor::InterruptResult)
 
-            # Only a continue-Success reaches here (Async/Retry/Skipped/Failure/
-            # Interrupt all returned above; nil is inline-async test mode). It is
-            # the one outcome where the loop proceeds to more steps with no other
-            # save in between — every terminal/handoff result persists via its own
-            # path. Write a durable checkpoint so a crash re-runs at most this one
-            # step. Ordering: side-effect -> record result (inside execute_step) ->
-            # checkpoint here.
+            # A Skipped step (or a plain Success) continues the loop — Skipped
+            # is a Success subclass, so this also fires the durable checkpoint
+            # for it, same as a plain success.
+            #
+            # Only a continue-Success/Skipped reaches here (Async/Retry/Halt/
+            # Failure/Interrupt all returned above; nil is inline-async test
+            # mode). It is the one outcome where the loop proceeds to more
+            # steps with no other save in between — every terminal/handoff
+            # result persists via its own path. Write a durable checkpoint so
+            # a crash re-runs at most this one step. Ordering: side-effect ->
+            # record result (inside execute_step) -> checkpoint here.
             @on_step_complete&.call if result.is_a?(RubyReactor::Success)
           end
         end
@@ -179,9 +183,13 @@ module RubyReactor
       def safe_execute_step_sync(step_config, resolved_arguments = nil)
         resolved_arguments ||= resolve_arguments(step_config)
         execute_step_sync_without_result_handling(step_config, resolved_arguments)
-      rescue Error::InputValidationError
+      rescue Error::InputValidationError => e
         # Validation failures are not retryable and must surface as a structured
         # InputValidationError (with field_errors), so let them propagate.
+        # A step class stamps its own class name; inside a reactor the step's
+        # name there is the useful attribution, so it overwrites.
+        e.step_name = step_config.name
+        e.step_arguments ||= resolved_arguments
         raise
       rescue StandardError => e
         # Identify redacted inputs
@@ -336,15 +344,20 @@ module RubyReactor
       end
 
       def run_step_implementation(step_config, arguments)
-        @context.execution_trace << { type: :run, step: step_config.name, timestamp: Time.now, arguments: arguments }
+        contract = step_config.input_contract
+        @context.append_execution_trace(
+          { type: :run, step: step_config.name, timestamp: Time.now,
+            arguments: contract ? contract.redact(arguments) : arguments }
+        )
         if step_config.has_run_block?
           # Execute inline block
           # If no arguments are defined for the step, pass the reactor inputs as arguments
           args_to_pass = arguments.empty? ? @context.inputs : arguments
-          step_config.run_block.call(args_to_pass, @context)
+          args_to_pass = step_config.inline_contract.enforce!(args_to_pass) if step_config.inline_contract
+          catch(StepSignals::TAG) { step_config.run_block.call(args_to_pass, @context) }
         elsif step_config.has_impl?
           # Execute step class
-          step_config.impl.run(arguments, @context)
+          catch(StepSignals::TAG) { step_config.impl.run(arguments, @context) }
         else
           raise Error::ValidationError.new(
             "Step '#{step_config.name}' has no implementation",