ruby_reactor 0.7.0 → 0.7.1

data/lib/ruby_reactor/context.rb

@@ -103,6 +103,13 @@ module RubyReactor
       @current_step = old_step
     end
 
+    # Appends an execution-trace event stamped with whether this process is the
+    # worker (`inline_async_execution`). Traces written before this field
+    # existed stay unlabeled on deserialize.
+    def append_execution_trace(entry)
+      @execution_trace << entry.merge(background: !!@inline_async_execution)
+    end
+
     def to_h
       {
         inputs: @inputs,

data/lib/ruby_reactor/context_serializer.rb

@@ -36,6 +36,11 @@ module RubyReactor
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def serialize_value(value)
         case value
+        when RubyReactor::Halt
+          { "_type" => "Halt", "reason" => value.reason, "period_key" => value.period_key,
+            "step_name" => value.step_name }
+        when RubyReactor::Skipped
+          { "_type" => "Skipped", "value" => serialize_value(value.value), "reason" => value.reason }
         when RubyReactor::Success
           { "_type" => "Success", "value" => serialize_value(value.value) }
         when RubyReactor::Failure
@@ -112,6 +117,14 @@ module RubyReactor
           if value.key?("_type")
             # Special serialized types (Time, BigDecimal, etc.)
             case value["_type"]
+            when "Halt"
+              RubyReactor::Halt.new(
+                reason: value["reason"],
+                period_key: value["period_key"],
+                step_name: value["step_name"]
+              )
+            when "Skipped"
+              RubyReactor::Skipped.new(deserialize_value(value["value"]), reason: value["reason"])
             when "Success"
               RubyReactor::Success(deserialize_value(value["value"]))
             when "Failure"

data/lib/ruby_reactor/dsl/lockable.rb

@@ -53,7 +53,7 @@ module RubyReactor
 
         # Configure a calendar-aligned dedup window for this reactor. The
         # reactor will run at most once per bucket per key; subsequent calls
-        # in the same bucket return `RubyReactor::Skipped` without executing
+        # in the same bucket return `RubyReactor::Halt` without executing
         # any steps.
         #
         # Note: `with_period` is *dedup*, not *concurrency*. Two concurrent
@@ -93,7 +93,7 @@ module RubyReactor
         #   assign. Only fully-drained sequences GC themselves.
         # @param strict [Boolean] When true (default), if any nonce in the
         #   sequence terminates with a `Failure`, all subsequent nonces are
-        #   short-circuited with `Skipped(reason: :ordered_lock_chain_failed)`
+        #   short-circuited with `Halt(reason: :ordered_lock_chain_failed)`
         #   instead of executing. This models "stop the line on the first
         #   problem" pipelines (e.g. ledger transactions). When false, the
         #   sequence keeps executing every nonce in order regardless of prior

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
@@ -33,9 +35,15 @@ module RubyReactor
       end
 
       # rubocop:disable Naming/MethodName
-      def Skipped(reason: nil, **kwargs)
+      def Halt(reason: nil, **kwargs)
+        # rubocop:enable Naming/MethodName
+        RubyReactor.Halt(reason: reason, **kwargs)
+      end
+
+      # rubocop:disable Naming/MethodName
+      def Skipped(...)
         # rubocop:enable Naming/MethodName
-        RubyReactor.Skipped(reason: reason, **kwargs)
+        RubyReactor.Skipped(...)
       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
 

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

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
@@ -336,15 +340,17 @@ module RubyReactor
       end
 
       def run_step_implementation(step_config, arguments)
-        @context.execution_trace << { type: :run, step: step_config.name, timestamp: Time.now, arguments: arguments }
+        @context.append_execution_trace(
+          { type: :run, step: step_config.name, timestamp: Time.now, 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)
+          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",

data/lib/ruby_reactor/executor.rb

@@ -110,9 +110,9 @@ module RubyReactor
       # is a fast path; this one closes the race where two callers both passed
       # it and then serialized on the lock — without it the second caller would
       # re-run work the first already marked. (No-op when no lock is configured.)
-      if (skipped = check_period_gate)
+      if (halted = check_period_gate)
         completed = true
-        return finalize_skipped(skipped)
+        return finalize_halt(halted)
       end
 
       @context.status = :running
@@ -218,9 +218,9 @@ module RubyReactor
 
       # Post-lock re-check (see execute) — closes the period race for the
       # first run of a locked async reactor.
-      if first_run && (skipped = check_period_gate)
+      if first_run && (halted = check_period_gate)
         completed = true
-        return finalize_skipped(skipped)
+        return finalize_halt(halted)
       end
 
       prepare_for_resume
@@ -393,16 +393,16 @@ module RubyReactor
       @context.current_step.nil? && @context.intermediate_results.empty?
     end
 
-    # Record and persist a Skipped result, then return it. Shared by the
+    # Record and persist a Halt result, then return it. Shared by the
     # pre-lock and post-lock period gates in both execute and resume.
-    def finalize_skipped(skipped)
-      @result = skipped
+    def finalize_halt(halted)
+      @result = halted
       update_context_status(@result)
       save_context
       @result
     end
 
-    # Returns a Skipped result if the period bucket is already marked, else nil.
+    # Returns a Halt result if the period bucket is already marked, else nil.
     # Consulted before AND after lock acquisition on a first execution; genuine
     # resumes never re-check (a paused run must not skip itself when its own
     # marker eventually appears).
@@ -413,13 +413,13 @@ module RubyReactor
       key = period_key(config)
       return nil unless RubyReactor.configuration.storage_adapter.period_seen?(key)
 
-      RubyReactor::Skipped.new(reason: :period, period_key: key)
+      RubyReactor::Halt.new(reason: :period, period_key: key)
     end
 
     def mark_period_on_success(result)
       return unless @reactor_class.respond_to?(:period_config) && @reactor_class.period_config
       return unless result.is_a?(RubyReactor::Success)
-      return if result.is_a?(RubyReactor::Skipped)
+      return if result.is_a?(RubyReactor::Halt)
 
       config = @reactor_class.period_config
       ttl = RubyReactor::Period.ttl_seconds(config[:every])
@@ -662,8 +662,8 @@ module RubyReactor
       case result
       when RubyReactor::DispatchResult
         @context.status = :running
-      when RubyReactor::Skipped
-        @context.status = :skipped
+      when RubyReactor::Halt
+        @context.status = :halted
       when RubyReactor::Success
         @context.status = :completed
       when RubyReactor::Failure
@@ -696,14 +696,16 @@ module RubyReactor
         @result = @step_executor.execute_all_steps
       else
         case result
-        # Skipped must be listed before Success (Skipped < Success) so the
+        # Halt must be listed before Success (Halt < Success) so the
         # halt path wins over the "continue with remaining steps" path.
-        when RubyReactor::Skipped,
+        # Skipped is NOT listed here — it is a Success subclass and must
+        # continue with the remaining steps, same as a plain Success.
+        when RubyReactor::Halt,
              RetryQueuedResult,
              RubyReactor::Failure,
              RubyReactor::DispatchResult,
              RubyReactor::InterruptResult
-          # Terminal: step was skipped, requeued, failed, paused, or handed
+          # Terminal: step halted, requeued, failed, paused, or handed
           # off to async. Return the result as-is.
           @result = result
         when RubyReactor::Success

data/lib/ruby_reactor/map/element_executor.rb

@@ -141,7 +141,13 @@ module RubyReactor
         index = arguments[:index]
         parent_class = arguments[:parent_reactor_class_name] # Using short name for variable
 
-        if result.success?
+        if result.halted?
+          # A Halt must not be collected as a (nil) value indistinguishable
+          # from an ordinary success — mark it so the enumerator reconstructs
+          # a real Halt for the consumer.
+          storage.store_map_result(map_id, index, { _halt: true, reason: result.reason },
+                                   parent_class, strict_ordering: arguments[:strict_ordering])
+        elsif result.success?
           storage.store_map_result(map_id, index, ContextSerializer.serialize_value(result.value),
                                    parent_class, strict_ordering: arguments[:strict_ordering])
         else

data/lib/ruby_reactor/map/helpers.rb

@@ -96,13 +96,15 @@ module RubyReactor
           # Manually update execution trace to reflect completion
           # This is necessary because resume_execution continues from the NEXT step
           # and the async step (which returned DispatchResult) needs to be marked as done with actual value
-          parent_context.execution_trace << {
-            type: :result,
-            step: step_name_sym,
-            timestamp: Time.now,
-            value: final_result.value,
-            status: :success
-          }
+          parent_context.append_execution_trace(
+            {
+              type: :result,
+              step: step_name_sym,
+              timestamp: Time.now,
+              value: final_result.value,
+              status: :success
+            }
+          )
 
           parent_context.current_step = nil
           executor.resume_execution

data/lib/ruby_reactor/map/result_enumerator.rb

@@ -101,6 +101,8 @@ module RubyReactor
           # whoever happened to materialize the enumerator (the JSON encoder, in
           # the dashboard's case) instead of the stack of the step that failed.
           RubyReactor::Failure.new(result["_error"], backtrace: [])
+        elsif result.is_a?(Hash) && result.key?("_halt")
+          RubyReactor::Halt.new(reason: result["reason"])
         else
           RubyReactor::Success.new(ContextSerializer.deserialize_value(result))
         end

data/lib/ruby_reactor/map/sweeper.rb

@@ -92,7 +92,7 @@ module RubyReactor
 
         results = data["intermediate_results"] || {}
         status = data["status"].to_s
-        results.key?(meta["step_name"].to_s) || %w[completed failed skipped].include?(status)
+        results.key?(meta["step_name"].to_s) || %w[completed failed halted skipped].include?(status)
       end
 
       def retrigger_collector(meta)

data/lib/ruby_reactor/open_telemetry.rb

@@ -502,9 +502,9 @@ module RubyReactor
 
       case result
       when RubyReactor::Success
-        if result.skipped?
-          span.set_attribute("reactor.status", "skipped")
-          span.set_attribute("reactor.skipped_reason", result.reason.to_s)
+        if result.halted?
+          span.set_attribute("reactor.status", "halted")
+          span.set_attribute("reactor.halt_reason", result.reason.to_s)
           span.status = ::OpenTelemetry::Trace::Status.ok
         else
           span.set_attribute("reactor.status", "completed")
@@ -578,7 +578,10 @@ module RubyReactor
 
       case result
       when RubyReactor::Success
-        if result.skipped?
+        if result.halted?
+          span.set_attribute("step.status", "halted")
+          span.set_attribute("step.halt_reason", result.reason.to_s)
+        elsif result.skipped?
           span.set_attribute("step.status", "skipped")
           span.set_attribute("step.skipped_reason", result.reason.to_s)
         else

data/lib/ruby_reactor/ordered_lock.rb

@@ -62,11 +62,11 @@ module RubyReactor
     #   via the stored context status.
     # - `:skip_chain_failed` — only in strict mode: an earlier nonce in this
     #   sequence terminated with a Failure, so this run is short-circuited
-    #   with `Skipped(reason: :ordered_lock_chain_failed)` without executing.
+    #   with `Halt(reason: :ordered_lock_chain_failed)` without executing.
     # - `:stale_batch` — this run's epoch no longer matches the key's current
     #   generation: its batch fully drained and the numbering was reused by a
     #   newer batch. The run is short-circuited with
-    #   `Skipped(reason: :ordered_lock_stale_batch)` and must not participate.
+    #   `Halt(reason: :ordered_lock_stale_batch)` and must not participate.
     # - `:poison_advance` is collapsed to `:go` from the caller's perspective.
     def check!
       raise ArgumentError, "OrderedLock#check! requires a nonce" unless @nonce
@@ -111,7 +111,7 @@ module RubyReactor
     #
     # `failed:` records this nonce as the chain-failure marker (only the FIRST
     # failure sticks). In strict mode the marker causes subsequent nonces to
-    # short-circuit with Skipped.
+    # short-circuit with Halt.
     def advance!(failed: false)
       raise ArgumentError, "OrderedLock#advance! requires a nonce" unless @nonce