change_requests 0.2.5 → 0.3.0

data/lib/change_requests/guards/execute.rb

@@ -4,8 +4,8 @@ module ChangeRequests
   module Guards
     # May this actor execute this request (§7.2, §8)?
     #
-    # **Guard only.** `Commands::Execute`, the claim-then-invoke machinery and the §8.1 override
-    # branch are M3a (decision D2). The guard's inputs are all M1 state; the claim is not.
+    # The §8.1 override branch is M3a-5. `Execution::Runner` drives the claim behind
+    # `Commands::Execute`.
     #
     # Separation of duties is the one rule here with no counterpart in the other guards. `Approve`
     # refuses the requester by identity and consults nothing (I5); `Execute` refuses them *unless*
@@ -17,8 +17,13 @@ module ChangeRequests
       refuses_with NotExecutable
 
       def refusal
+        return override_refusal if override?
+
         # `successful` is final, and "already done" is a better answer than "not approved".
         return :already_finalized if request.final?
+        # Ahead of :not_approved, which would be untrue of a request that is approved and mid-flight.
+        # T1's conditional UPDATE is the invariant beneath this, raising ExecutionInProgress (§8).
+        return :executing if request.executing?
         return :not_approved unless EXECUTABLE_STATUSES.include?(request.status)
         return :attempts_exhausted if request.failed? && !request.retryable?
         return :not_permitted unless actor_type.may_execute
@@ -28,8 +33,41 @@ module ChangeRequests
         nil
       end
 
+      # §8.1, and deliberately not a variation on the branch above. An override is not a lenient
+      # execute: it asks whether this actor may suspend the gem's central promise on this action.
+      #
+      # Narrowed to `pending` on purpose. An approved or failed request executes by the ordinary
+      # path, so recording an override for it would put a badge, an event and an `overridden_at` on
+      # a request that needed none - and T1's conditional UPDATE takes `WHERE status = 'pending'`
+      # for an override, which would otherwise refuse it far less clearly.
+      def override_refusal
+        return :already_finalized if request.final?
+        return :executing if request.executing?
+        return :override_not_permitted unless operation.overridable?
+        return :not_pending unless request.pending?
+        return :not_permitted unless actor_type.may_execute
+        return :requester if requester? && !config.requester_may_override
+        return :override_not_permitted unless satisfies_override_permissions?
+
+        nil
+      end
+
+      def override?
+        options[:override] ? true : false
+      end
+
       private
 
+      # An override declaring no permissions is open to anyone whose type may_execute, which the
+      # branch above has already established (§8.1).
+      def satisfies_override_permissions?
+        policy = operation.override_policy
+
+        return true if policy.unrestricted?
+
+        Authorization::Permissions.held_by(actor, actor_type).intersect?(policy.permissions)
+      end
+
       def actor_type
         config.actor_types.fetch(actor_ref[:type])
       end

data/lib/change_requests/models/quorum.rb

@@ -42,7 +42,7 @@ module ChangeRequests
     validates :position, numericality: { only_integer: true, greater_than_or_equal_to: 1 },
                          uniqueness: { scope: :change_request_stage_id }
 
-    # Null when the stage holds exactly one quorum - the `op.approvals` shorthand - because "which
+    # Null when the stage holds exactly one quorum - `w.stage` without a block - because "which
     # quorum" is then not a meaningful question (§5.9).
     validates :name, format: { with: NAME_FORMAT }, allow_nil: true
     validates :name, uniqueness: { scope: :change_request_stage_id }, allow_nil: true

data/lib/change_requests/operation/override.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ChangeRequests
+  class Operation
+    # §8.1's break-glass declaration: who may take it, and whether they must say why.
+    #
+    #   op.override permissions: %w(security_officer), require_reason: true
+    #
+    # An empty permission list is a declaration, not an oversight: the override is then open to any
+    # actor whose registered type `may_execute`. §8.1 calls the override separately permissioned,
+    # and a host declaring none has said that its execute permission is the separation.
+    Override = Data.define(:permissions, :require_reason) do
+      def require_reason?
+        require_reason
+      end
+
+      def unrestricted?
+        permissions.empty?
+      end
+    end
+  end
+end

data/lib/change_requests/operation.rb

@@ -5,24 +5,21 @@ module ChangeRequests
   # workflow it materialises (§6.4). Declaring this is what buys the dispatch allowlist, the
   # snapshot-on-create and the policy-not-caller-input guarantee of §6.12.
   #
-  # M2 adds `op.workflow`, `op.cooldown`, `op.override` and `Operations#verify!`.
+  # `op.cooldown` arrives with M9b.
   class Operation
-    # change_request_stages.name is NOT NULL, and the shorthand declares no stage of its own.
-    DEFAULT_STAGE_NAME = "approval"
-
-    attr_reader :key, :workflow
-    attr_accessor :version, :service, :payload_labels, :idempotent
+    attr_reader :key, :override_policy
+    attr_accessor :version, :service, :payload_labels
     attr_writer :method_name, :max_attempts
 
     def initialize(key)
       @key            = key.to_s
       @method_name    = :call
-      @idempotent     = false
       @payload_labels = nil
       @max_attempts   = nil
       @expires_in     = nil
       @expires_in_set = false
-      @workflow       = Workflow.new
+      @override_policy = nil
+      @workflow = Workflow.new
     end
 
     def method_name
@@ -48,16 +45,29 @@ module ChangeRequests
       @expires_in     = value
     end
 
-    # The §6.4 shorthand: one stage, one quorum, no ceremony. Replaces any previous description -
-    # it is "the approval rule for this operation", not one of several.
-    def approvals(permissions: nil, actor_type: nil, eligible_actors: nil, match: nil, required: 1)
-      quorum = build_quorum(permissions: permissions, actor_type: actor_type,
-                            eligible_actors: eligible_actors, match: match, required: required)
+    # Without a block, the reader `Commands::Create` walks. With one, the §6.4 / §6.9 declaration -
+    # the only way to say who approves: ordered stages, each holding one inline quorum or a block of
+    # named ones.
+    #
+    # Replaces any previous description - it is "the approval rule for this operation", not one of
+    # several - and the new one is only installed once it has built without refusing.
+    def workflow(&block)
+      return @workflow unless block
+
+      @workflow = Workflow::Builder.build(operation_key: key, &block)
+    end
 
-      @workflow = Workflow.new(
-        [Workflow::Stage.new(name: DEFAULT_STAGE_NAME, position: 1, satisfied_by: :any_quorum,
-                             quorums: [quorum])]
-      )
+    # §6.10's break-glass opt-in. Declared, never defaulted: no override exists until a host
+    # writes this line. The reader is `override_policy` rather than this method - with no block to
+    # disambiguate, one name cannot both declare and report, and a bare `op.override` that read
+    # instead of declaring would silently leave the gate shut.
+    def override(permissions: nil, require_reason: false)
+      @override_policy = Override.new(permissions: list(permissions).map(&:to_s),
+                                      require_reason: require_reason ? true : false)
+    end
+
+    def overridable?
+      !override_policy.nil?
     end
 
     def validate!
@@ -69,8 +79,20 @@ module ChangeRequests
            "ChangeRequests operation #{key.inspect} is misconfigured:\n- #{problems.join("\n- ")}"
     end
 
+    # Everything checkable without loading the host's classes. One implementation, three readers:
+    # `validate!` at declaration, `Commands::Create` at creation and `Operations#verify!` at boot,
+    # so none of them can disagree about what a complete declaration is (§7.2 †, §6.12 point 6).
     def problems
-      [version_problem].compact
+      [version_problem, service_problem, method_name_problem, workflow_problem,
+       *threshold_problems].compact
+    end
+
+    # What needs the host's classes loaded, so it runs at boot and nowhere else: the §6.12 target
+    # contract, in the words `Execution::Dispatcher` would use for the same defect.
+    def target_problems
+      return [] if service.blank? || !method_name_declared?
+
+      [Execution::TargetContract.problem(service: service, method_name: method_name)].compact
     end
 
     private
@@ -82,59 +104,57 @@ module ChangeRequests
         "every request as a NOT NULL column, and the gem never judges its content (§5.10)."
     end
 
-    def build_quorum(permissions:, actor_type:, eligible_actors:, match:, required:)
-      rows   = permission_rows(permissions, actor_type)
-      actors = list(eligible_actors)
-
-      refuse_empty_eligibility if rows.empty? && actors.empty?
-      refuse_threshold(required) unless required.is_a?(Integer) && required >= 1
-      refuse_match(match) unless match.nil? || Configuration::PERMISSION_MATCHES.include?(match)
+    # Array() would splat a Struct or a Hash into its members. Only a real array is one.
+    def list(value)
+      return [] if value.nil?
 
-      Workflow::Quorum.new(name: nil, position: 1, threshold: required, permission_match: match,
-                           permissions: rows, eligible_actors: actors)
+      Array.try_convert(value) || [value]
     end
 
-    def permission_rows(permissions, actor_type)
-      entries = list(permissions)
+    def service_problem
+      return if service.present?
 
-      return [Workflow::Permission.new(permission: nil, actor_type: actor_type.to_s)] \
-        if entries.empty? && actor_type
-
-      entries.map { |entry| permission_row(entry, actor_type) }
+      "it declares no service, so nothing could ever execute it - set `op.service`"
     end
 
-    def permission_row(entry, actor_type)
-      return Workflow::Permission.new(permission: entry.to_s, actor_type: actor_type&.to_s) \
-        unless entry.is_a?(Hash)
+    # `attr_writer :method_name` can assign the documented :call default away (§6.12). Reported
+    # here, so verify! names the declaration rather than respond_to? raising on nil.
+    def method_name_problem
+      return if method_name_declared?
 
-      Workflow::Permission.new(permission: entry[:permission]&.to_s,
-                               actor_type: (entry[:actor_type] || actor_type)&.to_s)
+      "op.method_name is #{@method_name.inspect}. Dispatch calls the public singleton method of " \
+        "that name, and it defaults to :call - assigning nil takes the default away (§6.12)."
     end
 
-    # Array() would splat a Struct or a Hash into its members. Only a real array is one.
-    def list(value)
-      return [] if value.nil?
+    def method_name_declared?
+      method_name.to_s.strip.present?
+    end
 
-      Array.try_convert(value) || [value]
+    def workflow_problem
+      return unless workflow.empty?
+
+      "it declares no approvals, so a request could never be approved - declare `op.workflow`"
     end
 
-    def refuse_empty_eligibility
-      fail ConfigurationError,
-           "ChangeRequests operation #{key.inspect}: op.approvals needs `permissions:`, " \
-           "`actor_type:` or `eligible_actors:`. A quorum nobody qualifies for can never be " \
-           "satisfied, and the request would sit pending until it expired (§5.3)."
+    # The DSL refuses these at declaration. Re-checked so one call reports everything, and so a
+    # hand-built description cannot enter the registry unnoticed.
+    def threshold_problems
+      workflow.stages.flat_map do |stage|
+        stage.quorums.filter_map { |quorum| threshold_problem(stage, quorum) }
+      end
     end
 
-    def refuse_threshold(required)
-      fail ConfigurationError,
-           "ChangeRequests operation #{key.inspect}: op.approvals required: #{required.inspect}. " \
-           "It must be an integer of at least 1 - one approval is the minimum, not zero."
+    def threshold_problem(stage, quorum)
+      return if quorum.threshold.is_a?(Integer) && quorum.threshold >= 1
+
+      "#{describe(stage, quorum)} has threshold #{quorum.threshold.inspect}. " \
+        "One approval is the minimum, not zero (§5.3)."
     end
 
-    def refuse_match(match)
-      fail ConfigurationError,
-           "ChangeRequests operation #{key.inspect}: op.approvals match: #{match.inspect}. " \
-           "Expected #{Configuration::PERMISSION_MATCHES.map(&:inspect).join(" or ")} (§5.3)."
+    def describe(stage, quorum)
+      return "stage #{stage.name.to_sym.inspect}" if quorum.name.nil?
+
+      "stage #{stage.name.to_sym.inspect} quorum #{quorum.name.to_sym.inspect}"
     end
   end
 end

data/lib/change_requests/operations.rb

@@ -41,6 +41,24 @@ module ChangeRequests
       @operations.clear
     end
 
+    # Boot-time verification (§6.12 point 6), run by `rake change_requests:verify` and by the
+    # engine's to_prepare hook in development. One raised error listing every problem, the shape
+    # `Configuration#validate!` already uses (Q4).
+    def verify!
+      problems = self.problems
+
+      return true if problems.empty?
+
+      fail ConfigurationError,
+           "ChangeRequests operations are misconfigured:\n- #{problems.join("\n- ")}"
+    end
+
+    def problems
+      @operations.each_value.flat_map do |operation|
+        (operation.problems + operation.target_problems).map { |problem| "#{operation.key}: #{problem}" }
+      end
+    end
+
     private
 
     def initialize_copy(source)

data/lib/change_requests/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChangeRequests
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/lib/change_requests/workflow/builder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ChangeRequests
+  class Workflow
+    # The `w` of `op.workflow do |w| … end` (§6.4, §6.9). It builds a description and nothing else:
+    # `Commands::Create` materialises whatever it is handed, and this is the only producer.
+    #
+    # Everything it refuses, it refuses at declaration time - in an initializer, where the mistake
+    # was made - rather than at creation time, where a unique index or a NOT NULL column would.
+    class Builder
+      def self.build(operation_key:)
+        builder = new(operation_key)
+        yield(builder)
+
+        builder.to_workflow
+      end
+
+      def initialize(operation_key)
+        @operation_key = operation_key
+        @stages        = []
+      end
+
+      def stage(name, satisfied_by: :any_quorum, **quorum_options, &)
+        stage_name = normalized_name(name)
+        mode       = normalized_satisfied_by(stage_name, satisfied_by)
+        builder    = StageBuilder.new(operation_key: operation_key, stage_name: stage_name)
+
+        collect(builder, stage_name, quorum_options, &)
+
+        stages << Stage.new(name: stage_name, position: stages.size + 1, satisfied_by: mode,
+                            quorums: builder.quorums)
+      end
+
+      def to_workflow
+        refuse_empty_workflow if stages.empty?
+
+        Workflow.new(stages)
+      end
+
+      private
+
+      attr_reader :operation_key, :stages
+
+      def collect(builder, stage_name, quorum_options, &block)
+        return builder.quorum(**quorum_options) unless block
+
+        refuse_mixed(stage_name) if quorum_options.any?
+
+        block.call(builder)
+
+        refuse_empty_stage(stage_name) if builder.quorums.empty?
+      end
+
+      def normalized_name(name)
+        stage_name = name.to_s
+
+        refuse_nameless_stage(name) if stage_name.strip.empty?
+        refuse_duplicate_stage(stage_name) if stages.any? { |stage| stage.name == stage_name }
+
+        stage_name
+      end
+
+      def normalized_satisfied_by(stage_name, satisfied_by)
+        mode = satisfied_by&.to_sym
+
+        refuse_satisfied_by(stage_name, satisfied_by) unless SATISFIED_BY.include?(mode)
+
+        mode
+      end
+
+      def prefix
+        "ChangeRequests operation #{operation_key.inspect}"
+      end
+
+      def refuse_nameless_stage(name)
+        fail ConfigurationError,
+             "#{prefix}: op.workflow stage #{name.inspect} needs a name. change_request_stages.name is " \
+             "NOT NULL, and the name is the identifier the timeline and the locale file read (§5.2, §5.9)."
+      end
+
+      def refuse_duplicate_stage(stage_name)
+        fail ConfigurationError,
+             "#{prefix}: op.workflow declares stage #{stage_name.to_sym.inspect} twice. Stage names are " \
+             "unique within a request, and the unique index would refuse the second row (§5.2)."
+      end
+
+      def refuse_satisfied_by(stage_name, satisfied_by)
+        fail ConfigurationError,
+             "#{prefix}: op.workflow stage #{stage_name.to_sym.inspect} satisfied_by: #{satisfied_by.inspect}. " \
+             "Expected #{SATISFIED_BY.map(&:inspect).join(" or ")} (§5.2)."
+      end
+
+      def refuse_mixed(stage_name)
+        fail ConfigurationError,
+             "#{prefix}: op.workflow stage #{stage_name.to_sym.inspect} takes either a block of quorums or " \
+             "one inline quorum, not both. Move the inline keywords into a `q.quorum` (§6.9)."
+      end
+
+      def refuse_empty_stage(stage_name)
+        fail ConfigurationError,
+             "#{prefix}: op.workflow stage #{stage_name.to_sym.inspect} declares no quorum. A stage nobody " \
+             "can satisfy would leave the request pending until it expired (§5.3)."
+      end
+
+      def refuse_empty_workflow
+        fail ConfigurationError,
+             "#{prefix}: op.workflow declares no stage, so a request against this operation could never " \
+             "be approved. Declare at least one `w.stage` (§6.4)."
+      end
+    end
+  end
+end

data/lib/change_requests/workflow/quorum.rb

@@ -3,7 +3,7 @@
 module ChangeRequests
   class Workflow
     # One counting rule of the described workflow (§5.3). `name` is null when its stage holds
-    # exactly one quorum - the `op.approvals` shorthand (§5.9).
+    # exactly one quorum - `w.stage` without a block (§5.9).
     #
     # `eligible_actors` holds the actor objects as the host declared them. Resolving them to
     # (type, id) here would call `actor_attributes` from an initializer, before the file that

data/lib/change_requests/workflow/stage_builder.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ChangeRequests
+  class Workflow
+    # The `q` of `w.stage :name do |q| … end`, and the one place a declared quorum becomes a
+    # Workflow::Quorum. The single-quorum stage shorthand routes through it too, so one
+    # normalisation and one set of refusals serve both forms (§5.3, §6.9).
+    class StageBuilder
+      attr_reader :quorums
+
+      def initialize(operation_key:, stage_name:)
+        @operation_key = operation_key
+        @stage_name    = stage_name
+        @quorums       = []
+      end
+
+      def quorum(name = nil, permissions: nil, actor_type: nil, eligible_actors: nil, match: nil, threshold: 1)
+        quorum_name = name&.to_s
+        rows        = permission_rows(permissions, actor_type)
+        actors      = list(eligible_actors)
+
+        refuse_name(quorum_name)
+        refuse_empty_eligibility(quorum_name) if rows.empty? && actors.empty?
+        refuse_threshold(quorum_name, threshold) unless threshold.is_a?(Integer) && threshold >= 1
+        refuse_match(quorum_name, match) unless match.nil? || Configuration::PERMISSION_MATCHES.include?(match)
+
+        @quorums << Quorum.new(name: quorum_name, position: @quorums.size + 1, threshold: threshold,
+                               permission_match: match, permissions: rows, eligible_actors: actors)
+      end
+
+      private
+
+      attr_reader :operation_key, :stage_name
+
+      def permission_rows(permissions, actor_type)
+        entries = list(permissions)
+
+        return [Permission.new(permission: nil, actor_type: actor_type.to_s)] if entries.empty? && actor_type
+
+        entries.map { |entry| permission_row(entry, actor_type) }
+      end
+
+      def permission_row(entry, actor_type)
+        return Permission.new(permission: entry.to_s, actor_type: actor_type&.to_s) unless entry.is_a?(Hash)
+
+        Permission.new(permission: entry[:permission]&.to_s,
+                       actor_type: (entry[:actor_type] || actor_type)&.to_s)
+      end
+
+      # Array() would splat a Struct or a Hash into its members. Only a real array is one.
+      def list(value)
+        return [] if value.nil?
+
+        Array.try_convert(value) || [value]
+      end
+
+      # A nameless quorum is the single-quorum shorthand written out (§5.9). Once a stage holds a
+      # second one, "which quorum was satisfied" becomes a question the metadata has to answer.
+      def refuse_name(quorum_name)
+        return if quorums.empty? && quorum_name.nil?
+
+        refuse_unnamed if quorum_name.nil? || quorums.any? { |declared| declared.name.nil? }
+        refuse_duplicate(quorum_name) if quorums.any? { |declared| declared.name == quorum_name }
+      end
+
+      def context(quorum_name = nil)
+        return "op.workflow stage #{stage_name.to_sym.inspect}" if quorum_name.nil?
+
+        "op.workflow stage #{stage_name.to_sym.inspect} quorum #{quorum_name.to_sym.inspect}"
+      end
+
+      def prefix
+        "ChangeRequests operation #{operation_key.inspect}"
+      end
+
+      def refuse_unnamed
+        fail ConfigurationError,
+             "#{prefix}: #{context} holds more than one quorum, so each of them needs a name. " \
+             "That name is what a stage_satisfied event reports and what a test matcher asks for (§5.9)."
+      end
+
+      def refuse_duplicate(quorum_name)
+        fail ConfigurationError,
+             "#{prefix}: #{context} declares quorum #{quorum_name.to_sym.inspect} twice. Quorum names are " \
+             "unique within their stage, and the unique index would refuse the second row (§5.3)."
+      end
+
+      def refuse_empty_eligibility(quorum_name)
+        fail ConfigurationError,
+             "#{prefix}: #{context(quorum_name)} needs `permissions:`, `actor_type:` or " \
+             "`eligible_actors:`. A quorum nobody qualifies for can never be satisfied, and the " \
+             "request would sit pending until it expired (§5.3)."
+      end
+
+      def refuse_threshold(quorum_name, threshold)
+        fail ConfigurationError,
+             "#{prefix}: #{context(quorum_name)} threshold: #{threshold.inspect}. " \
+             "It must be an integer of at least 1 - one approval is the minimum, not zero."
+      end
+
+      def refuse_match(quorum_name, match)
+        fail ConfigurationError,
+             "#{prefix}: #{context(quorum_name)} match: #{match.inspect}. " \
+             "Expected #{Configuration::PERMISSION_MATCHES.map(&:inspect).join(" or ")} (§5.3)."
+      end
+    end
+  end
+end

data/lib/change_requests/workflow.rb

@@ -8,6 +8,10 @@ module ChangeRequests
   # are the frozen snapshot - editing an operation afterwards never reaches an in-flight request
   # (§6.12 point 4).
   class Workflow
+    # The declaration-side vocabulary of change_request_stages.satisfied_by, as
+    # Configuration::PERMISSION_MATCHES is for the quorum column (§5.2).
+    SATISFIED_BY = %i(any_quorum all_quorums).freeze
+
     attr_reader :stages
 
     def initialize(stages = [])

data/lib/change_requests.rb

@@ -49,6 +49,14 @@ module ChangeRequests
       { type: type, id: actor.id.to_s, label: registered.label.call(actor).to_s }
     end
 
+    # The host-facing entry point (§6.5), wrapping Commands::Create. The key is positional and the
+    # rest are keywords because this is the call every host writes, and it reads better that way.
+    # It adds nothing else: the errors are Create's, unrescued.
+    def request!(operation_key, requester:, payload: {}, tenant: nil)
+      Commands::Create.call(operation_key: operation_key, requester: requester,
+                            payload: payload, tenant: tenant)
+    end
+
     def configure
       yield(config)
 
@@ -75,7 +83,9 @@ module ChangeRequests
     def setup_loader
       @loader = Zeitwerk::Loader.for_gem.tap do |loader|
         # Generators go through Rails' generator lookup; the test kit is required by the host.
+        # lib/tasks holds .rake files the engine loads, not constants under a Tasks namespace.
         loader.ignore("#{__dir__}/generators")
+        loader.ignore("#{__dir__}/tasks")
         loader.ignore("#{__dir__}/change_requests/rspec.rb")
 
         # Filing convention, not a namespace: models/request.rb defines ChangeRequests::Request.

data/lib/tasks/change_requests.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Loaded by the engine's lib/tasks path, so a host gets these from its own `Rails.application
+# .load_tasks` with nothing to require. M3b adds the maintenance sweepers to this namespace.
+namespace :change_requests do
+  desc "Verify every declared operation: its version, target and workflow (§6.12 point 6)"
+  task verify: :environment do
+    count = ChangeRequests.operations.keys.size
+
+    begin
+      ChangeRequests.operations.verify!
+    rescue ChangeRequests::ConfigurationError => e
+      warn e.message
+
+      # Non-zero so CI fails on it. `exit` rather than `abort`, whose message would repeat e.
+      exit 1
+    end
+
+    puts "ChangeRequests: #{count} #{"operation".pluralize(count)} verified."
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: change_requests
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Andreas Finger
@@ -339,11 +339,15 @@ files:
 - lib/change_requests/commands/approve.rb
 - lib/change_requests/commands/base.rb
 - lib/change_requests/commands/cancel.rb
+- lib/change_requests/commands/claim_execution.rb
 - lib/change_requests/commands/comment.rb
 - lib/change_requests/commands/create.rb
 - lib/change_requests/commands/evaluate_workflow.rb
+- lib/change_requests/commands/execute.rb
 - lib/change_requests/commands/expire.rb
+- lib/change_requests/commands/override.rb
 - lib/change_requests/commands/reject.rb
+- lib/change_requests/commands/settle_execution.rb
 - lib/change_requests/commands/unapprove.rb
 - lib/change_requests/configuration.rb
 - lib/change_requests/configuration/actor_type.rb
@@ -351,6 +355,9 @@ files:
 - lib/change_requests/configuration/tenant_type.rb
 - lib/change_requests/engine.rb
 - lib/change_requests/errors.rb
+- lib/change_requests/execution/dispatcher.rb
+- lib/change_requests/execution/runner.rb
+- lib/change_requests/execution/target_contract.rb
 - lib/change_requests/guards/.keep
 - lib/change_requests/guards/approve.rb
 - lib/change_requests/guards/base.rb
@@ -377,17 +384,21 @@ files:
 - lib/change_requests/models/request.rb
 - lib/change_requests/models/stage.rb
 - lib/change_requests/operation.rb
+- lib/change_requests/operation/override.rb
 - lib/change_requests/operations.rb
 - lib/change_requests/presenters/.keep
 - lib/change_requests/testing.rb
 - lib/change_requests/translation.rb
 - lib/change_requests/version.rb
 - lib/change_requests/workflow.rb
+- lib/change_requests/workflow/builder.rb
 - lib/change_requests/workflow/permission.rb
 - lib/change_requests/workflow/quorum.rb
 - lib/change_requests/workflow/stage.rb
+- lib/change_requests/workflow/stage_builder.rb
 - lib/generators/.keep
 - lib/generators/change_requests/install/templates/migration.rb.tt
+- lib/tasks/change_requests.rake
 - sig/change_requests.rbs
 homepage: https://github.com/mediafinger/change_requests
 licenses: