smith-agents 0.5.0 → 0.6.1

data/lib/smith/workflow/split_step_persistence/execution_authorization_issuance.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Smith
+  class Workflow
+    module SplitStepPersistence
+      module ExecutionAuthorizationIssuance
+        def authorize_prepared_step_execution!
+          authorization = nil
+          handed_off = false
+          authorization = ExecutionAuthorizationIssuance
+                          .instance_method(:interrupt_safe_prepared_step_authorization)
+                          .bind_call(self)
+          handed_off = true
+          authorization
+        ensure
+          unless handed_off
+            ExecutionLifecycle
+              .instance_method(:release_failed_execution_authorization!)
+              .bind_call(self, authorization)
+          end
+        end
+
+        private
+
+        def with_prepared_step_execution_authorization
+          Thread.handle_interrupt(Object => :never) do
+            authorization = interrupt_safe_prepared_step_authorization
+            begin
+              Thread.handle_interrupt(Object => :immediate) { yield(authorization) }
+            ensure
+              ExecutionLifecycle
+                .instance_method(:release_failed_execution_authorization!)
+                .bind_call(self, authorization)
+            end
+          end
+        end
+
+        def interrupt_safe_prepared_step_authorization
+          Thread.handle_interrupt(Object => :never) do
+            verification_token = ExecutionAuthorization
+                                 .instance_method(:claim_framework_execution_verification!)
+                                 .bind_call(self)
+            begin
+              ExecutionAuthorization
+                .instance_method(:authorize_claimed_prepared_step_execution!)
+                .bind_call(self, verification_token)
+            ensure
+              ExecutionAuthorization
+                .instance_method(:restore_framework_execution_verification!)
+                .bind_call(self, verification_token)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smith/workflow/split_step_persistence/execution_binding_collector.rb

@@ -29,6 +29,11 @@ module Smith
           end
         end
 
+        def capture_agent(name, workflow_class:, transition:, role:)
+          capture_binding(name, workflow_class:, transition:, role:)
+          self
+        end
+
         def resolve!
           @bindings = Agent::Registry.capture_bindings!(@requests.values)
 

data/lib/smith/workflow/split_step_persistence/execution_binding_snapshot.rb

@@ -14,9 +14,14 @@ module Smith
           new(transition, workflow_class:).capture
         end
 
-        def initialize(transition, workflow_class:)
+        def self.capture_agent(transition, workflow_class:, name:, role:)
+          new(transition, workflow_class:, selected_agent: { name:, role: }).capture
+        end
+
+        def initialize(transition, workflow_class:, selected_agent: nil)
           @transition = transition
           @workflow_class = workflow_class
+          @selected_agent = selected_agent
           @bindings = ExecutionBindingCollector.new
           @visited_workflows = {}.compare_by_identity
           @visited_workflows[workflow_class] = true
@@ -27,8 +32,17 @@ module Smith
         end
 
         def capture
-          capture_transition(@transition, workflow_class: @workflow_class)
-          drain_workflow_queue
+          if @selected_agent
+            @bindings.capture_agent(
+              @selected_agent.fetch(:name),
+              workflow_class: @workflow_class,
+              transition: @transition,
+              role: @selected_agent.fetch(:role)
+            )
+          else
+            capture_transition(@transition, workflow_class: @workflow_class)
+            drain_workflow_queue
+          end
           @bindings.resolve!
           @bindings.freeze
           @workflow_snapshots.freeze

data/lib/smith/workflow/split_step_persistence/execution_lifecycle.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Smith
+  class Workflow
+    module SplitStepPersistence
+      module ExecutionLifecycle
+        private
+
+        def perform_authorized_prepared_step_execution!(authorization)
+          authorization = validate_split_step_execution_authorization!(authorization)
+          execution_thread = Thread.current
+          execute_prepared_step_lifecycle!(authorization, execution_thread) { yield(execution_thread) }
+        end
+
+        def execute_prepared_step_lifecycle!(authorization, execution_thread)
+          execution_active = false
+          step = nil
+          result = nil
+          Thread.handle_interrupt(Object => :never) do
+            activate_split_step_execution!(authorization, execution_thread)
+            execution_active = true
+            Thread.handle_interrupt(Object => :immediate) do
+              step, result = yield(execution_thread)
+            end
+          ensure
+            finish_split_step_execution!(step, authorization, execution_thread) if execution_active
+          end
+          result
+        end
+
+        def activate_split_step_execution!(authorization, execution_thread)
+          Thread.handle_interrupt(Object => :never) do
+            @split_step_mutex.synchronize do
+              ensure_active_split_step_execution_authorization!(authorization)
+              ensure_split_step_definition_current!
+              ensure_prepared_split_step_transition_matches!
+              activate_prepared_step_execution_scope!(authorization)
+              publish_active_split_step_execution!(authorization, execution_thread)
+            end
+          end
+        end
+
+        def finish_split_step_execution!(step, authorization, execution_thread)
+          Thread.handle_interrupt(Object => :never) do
+            @split_step_mutex.synchronize do
+              reset_active_split_step_execution!(step) if active_split_step_execution?(execution_thread)
+            end
+          ensure
+            PreparedStepExecutionAuthorization.instance_method(:close_execution!).bind_call(authorization)
+          end
+        end
+
+        def ensure_active_split_step_execution_authorization!(authorization)
+          return if active_split_step_execution_authorization?(authorization)
+
+          raise WorkflowError, "the prepared-step execution authorization is no longer active"
+        end
+
+        def activate_prepared_step_execution_scope!(authorization)
+          PreparedStepExecutionAuthorization.instance_method(:activate_execution!).bind_call(authorization)
+        end
+
+        def publish_active_split_step_execution!(authorization, execution_thread)
+          @split_step_active_execution_authorization = authorization
+          @split_step_execution_result = nil
+          @split_step_phase = :executing
+          clear_split_step_execution_authorization!
+          @split_step_execution_thread = execution_thread
+          @split_step_advance_permit = true
+        end
+
+        def active_split_step_execution?(execution_thread)
+          @split_step_phase == :executing && @split_step_execution_thread.equal?(execution_thread)
+        end
+
+        def reset_active_split_step_execution!(step)
+          @split_step_execution_thread = nil
+          @split_step_advance_permit = false
+          @split_step_execution_previous_phase = nil
+          @split_step_active_execution_authorization = nil
+          @split_step_execution_result = nil
+          @split_step_phase = step ? :executed : :attempted
+        end
+
+        def release_failed_execution_authorization!(authorization)
+          return unless authorization
+          return unless active_split_step_execution_authorization?(authorization)
+
+          ExecutionAuthorization
+            .instance_method(:release_prepared_step_execution!)
+            .bind_call(self, authorization)
+        end
+      end
+    end
+  end
+end

data/lib/smith/workflow/split_step_persistence/execution_verification.rb

@@ -8,11 +8,18 @@ module Smith
 
         def claim_split_step_execution_verification!
           @split_step_mutex.synchronize do
-            ensure_split_step_definition_current!
-            expected = restart_safe_split_step? ? :dispatch_claimed : :prepared
+            DefinitionBoundary
+              .instance_method(:ensure_split_step_definition_current!)
+              .bind_call(self)
+            restart_safe = DefinitionBoundary
+                           .instance_method(:restart_safe_split_step?)
+                           .bind_call(self)
+            expected = restart_safe ? :dispatch_claimed : :prepared
             raise WorkflowError, "no persisted step is prepared for execution" unless @split_step_phase == expected
 
-            ensure_prepared_split_step_transition_matches!
+            ExecutionVerification
+              .instance_method(:ensure_prepared_split_step_transition_matches!)
+              .bind_call(self)
 
             token = Object.new.freeze
             @split_step_execution_previous_phase = expected
@@ -23,8 +30,13 @@ module Smith
         end
 
         def verify_claimed_split_step_execution!(verification_token)
-          if restart_safe_split_step?
-            verify_split_step_dispatch_available!(verification_token)
+          restart_safe = DefinitionBoundary
+                         .instance_method(:restart_safe_split_step?)
+                         .bind_call(self)
+          if restart_safe
+            DispatchVerification
+              .instance_method(:verify_split_step_dispatch_available!)
+              .bind_call(self, verification_token)
           else
             verify_split_step_preparation_available!
           end

data/lib/smith/workflow/split_step_persistence/preparation_claim.rb

@@ -33,6 +33,8 @@ module Smith
         def finalize_split_step_preparation!(transition, transition_name, key, adapter, persistence_ttl)
           transaction_identity = TransactionIdentity.capture(adapter)
           transition_signature = TransitionContract.capture(transition)
+          namespace_preparer = PreparationClaim.instance_method(:prepare_composite_execution_namespace!)
+          namespace_preparer.bind_call(self, transition)
           @split_step_mutex.synchronize do
             unless active_split_step_preparation_claim?
               raise WorkflowError, "the split-step preparation claim is no longer active"
@@ -65,6 +67,12 @@ module Smith
             @split_step_preparation_thread.equal?(Thread.current)
         end
 
+        def prepare_composite_execution_namespace!(transition)
+          return unless transition&.parallel? || transition&.fanout?
+
+          ArtifactIntegration.instance_method(:execution_namespace).bind_call(self)
+        end
+
         def mark_split_step_prepared!(_adapter)
           @split_step_mutex.synchronize do
             phase = @split_step_transaction_identity ? :prepared_uncommitted : :prepared

data/lib/smith/workflow/split_step_persistence/subclass_boundary.rb

@@ -68,15 +68,31 @@ module Smith
           super
         end
 
+        def authorize_prepared_step_execution!(...)
+          ExecutionAuthorizationIssuance.instance_method(:authorize_prepared_step_execution!).bind_call(self, ...)
+        end
+
+        def prepare_composite_step!(...)
+          CompositeExecution.instance_method(:prepare_composite_step!).bind_call(self, ...)
+        end
+
+        def execute_prepared_composite_branch!(...)
+          CompositeExecution.instance_method(:execute_prepared_composite_branch!).bind_call(self, ...)
+        end
+
+        def reduce_prepared_composite_step!(...)
+          CompositeExecution.instance_method(:reduce_prepared_composite_step!).bind_call(self, ...)
+        end
+
         private
 
         def smith_prepared_execution_active?
-          root_execution = @split_step_phase == :executing &&
-                           @split_step_execution_thread.equal?(Thread.current)
-          return true if root_execution
-
           authorization = @split_step_active_execution_authorization
-          authorization&.active_in_current_execution? == true
+          return true if authorization&.active_in_current_execution? == true
+
+          authorization = @split_step_execution_authorization
+          @split_step_phase == :execution_authorized &&
+            authorization&.issued_in_current_process? == true
         end
 
         def effective_persistence_ttl

data/lib/smith/workflow/split_step_persistence.rb

@@ -36,7 +36,14 @@ require_relative "split_step_persistence/dispatch_confirmation"
 require_relative "split_step_persistence/execution_verification"
 require_relative "split_step_persistence/execution_binding_snapshot"
 require_relative "split_step_persistence/execution_authorization"
+require_relative "split_step_persistence/execution_authorization_issuance"
 require_relative "split_step_persistence/execution_result_capture"
+require_relative "split_step_persistence/execution_lifecycle"
+require_relative "split_step_persistence/composite_preparation"
+require_relative "split_step_persistence/composite_branch_authorization"
+require_relative "split_step_persistence/composite_branch_execution"
+require_relative "split_step_persistence/composite_reduction_execution"
+require_relative "split_step_persistence/composite_execution"
 require_relative "split_step_persistence/execution"
 require_relative "split_step_persistence/checkpoint_state"
 require_relative "split_step_persistence/checkpoint"
@@ -69,7 +76,14 @@ module Smith
       include DispatchConfirmation
       include ExecutionVerification
       include ExecutionAuthorization
+      include ExecutionAuthorizationIssuance
       include ExecutionResultCapture
+      include ExecutionLifecycle
+      include CompositePreparation
+      include CompositeBranchAuthorization
+      include CompositeBranchExecution
+      include CompositeReductionExecution
+      include CompositeExecution
       include Execution
       include CheckpointState
       include Checkpoint

data/lib/smith/workflow/step_context.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "thread_context_snapshot"
+
+module Smith
+  class Workflow
+    module StepContext
+      private
+
+      def with_step_context(transition, &block)
+        ThreadContextSnapshot.new.around do
+          setup_step_context
+          Thread.handle_interrupt(Object => :immediate, &block)
+        rescue StandardError => e
+          @outcome = nil
+          GuardrailIntegration.instance_method(:handle_step_failure).bind_call(self, transition, e)
+        ensure
+          teardown_step_context
+        end
+      end
+
+      def within_raw_step_context(&block)
+        ThreadContextSnapshot.new.around do
+          setup_step_context
+          Thread.handle_interrupt(Object => :immediate, &block)
+        ensure
+          teardown_step_context
+        end
+      end
+
+      def setup_step_context
+        Tool.current_deadline = wall_clock_deadline
+        Tool.current_ledger = @ledger
+        Tool.current_tool_result_collector = tool_result_collector
+      end
+
+      def teardown_step_context
+        Tool.current_guardrails = nil
+        Tool.current_deadline = nil
+        Tool.current_ledger = nil
+        Tool.current_tool_result_collector = nil
+        Smith.scoped_artifacts = nil
+      end
+    end
+  end
+end

data/lib/smith/workflow/thread_context_snapshot.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "dry-initializer"
+
+require_relative "process_local"
+
+module Smith
+  class Workflow
+    class ThreadContextSnapshot
+      extend Dry::Initializer
+      include ProcessLocal
+
+      TOOL_ATTRIBUTES = %i[
+        current_guardrails
+        current_deadline
+        current_ledger
+        current_tool_call_allowance
+        current_tool_result_collector
+      ].freeze
+      THREAD_KEYS = %i[
+        smith_call_deadline
+        smith_call_ledger
+        smith_failed_agent_results
+        smith_last_agent_result
+        smith_parallel_agent_binding
+      ].freeze
+
+      option :tool_attributes, default: proc { TOOL_ATTRIBUTES }
+      option :thread_keys, default: proc { THREAD_KEYS }
+      option :scoped_artifacts, default: proc { true }
+
+      def initialize(...)
+        super
+        @tool_attributes = tool_attributes.dup.freeze
+        @thread_keys = thread_keys.dup.freeze
+        validate_selection!
+        @tool_values = capture_tool_values
+        @thread_values = capture_thread_values
+        @artifact_store = Smith.scoped_artifacts if scoped_artifacts
+        @process_id = Process.pid
+        @thread = Thread.current
+        @fiber = Fiber.current
+        @restored = false
+      end
+
+      def restore!
+        ensure_owner!
+        Thread.handle_interrupt(Object => :never) { restore_context! }
+        self
+      end
+
+      def around
+        ensure_owner!
+        Thread.handle_interrupt(Object => :never) do
+          raise WorkflowError, "thread context snapshot has already been restored" if @restored
+
+          begin
+            yield
+          ensure
+            restore_context!
+          end
+        end
+      end
+
+      private
+
+      def restore_context!
+        raise WorkflowError, "thread context snapshot has already been restored" if @restored
+
+        @tool_values.each { |attribute, value| Tool.public_send("#{attribute}=", value) }
+        @thread_values.each { |key, value| Thread.current[key] = value }
+        Smith.scoped_artifacts = @artifact_store if scoped_artifacts
+        @restored = true
+      end
+
+      def capture_tool_values
+        tool_attributes.to_h { |attribute| [attribute, Tool.public_send(attribute)] }.freeze
+      end
+
+      def capture_thread_values
+        thread_keys.to_h { |key| [key, Thread.current[key]] }.freeze
+      end
+
+      def ensure_owner!
+        owner = @process_id == Process.pid && @thread.equal?(Thread.current) && @fiber.equal?(Fiber.current)
+        return if owner
+
+        raise WorkflowError, "thread context snapshot belongs to another process, thread, or fiber"
+      end
+
+      def validate_selection!
+        unless (tool_attributes - TOOL_ATTRIBUTES).empty?
+          raise ArgumentError, "thread context snapshot contains unsupported tool attributes"
+        end
+        return if (thread_keys - THREAD_KEYS).empty?
+
+        raise ArgumentError, "thread context snapshot contains unsupported thread keys"
+      end
+    end
+
+    private_constant :ThreadContextSnapshot
+  end
+end

data/lib/smith/workflow/transition.rb

@@ -111,7 +111,11 @@ module Smith
       def fan_out(branches:)
         validate_execution_primitive_conflict!("fan_out")
 
-        config = { branches: normalize_fanout_branches!(branches) }.freeze
+        normalized = normalize_fanout_branches!(branches)
+        @fanout_branch_lookup = normalized.to_h do |key, agent|
+          [key.to_s.freeze, [key, agent].freeze]
+        end.freeze
+        config = { branches: normalized }.freeze
 
         @fanout_config = config
         commit_execution_primitive!("fan_out")
@@ -156,6 +160,17 @@ module Smith
         !@fanout_config.nil?
       end
 
+      def fetch_fanout_agent!(branch_key)
+        fetch_fanout_branch!(branch_key).last
+      end
+
+      def fetch_fanout_branch!(branch_key)
+        @fanout_branch_lookup.fetch(branch_key.to_s) do
+          raise WorkflowError, "fan_out branch #{branch_key.inspect} is not declared"
+        end
+      end
+      private :fetch_fanout_agent!, :fetch_fanout_branch!
+
       def optimized?
         !@optimization_config.nil?
       end

data/lib/smith/workflow.rb

@@ -52,6 +52,9 @@ module Smith
       "Smith::AgentError"        => ->(s) { Smith::AgentError.new(s[:error_message]) },
       "Smith::DeadlineExceeded"  => ->(s) { Smith::DeadlineExceeded.new(s[:error_message]) },
       "Smith::WorkflowError"     => ->(s) { Smith::WorkflowError.new(s[:error_message]) },
+      "Smith::Workflow::Composite::BranchFailure" => lambda { |s|
+        Smith::Workflow::Composite::BranchFailure.from_details(s[:error_details])
+      },
       # Smith errors with non-message constructors map to compatible
       # superclass — message preserved, original metadata (agent_name,
       # model_used, requested_name, workflow_class, origin_state) lossy
@@ -493,5 +496,22 @@ Smith::Workflow::SplitStepPersistence::SubclassBoundary.protect_execution_path!(
   Smith::Workflow::EventIntegration,
   Smith::Workflow::ArtifactIntegration,
   Smith::Workflow::DataVolumePolicy,
-  Smith::Workflow::DeadlineEnforcement
+  Smith::Workflow::DeadlineEnforcement,
+  Smith::Workflow::SplitStepPersistence::DefinitionBoundary,
+  Smith::Workflow::SplitStepPersistence::ExecutionVerification,
+  Smith::Workflow::SplitStepPersistence::ExecutionAuthorization,
+  Smith::Workflow::SplitStepPersistence::ExecutionAuthorizationIssuance,
+  Smith::Workflow::SplitStepPersistence::ExecutionLifecycle,
+  Smith::Workflow::Composite::Contract,
+  Smith::Workflow::Composite::BranchContract,
+  Smith::Workflow::Composite::FanoutBranchContract,
+  Smith::Workflow::Composite::BranchBudgetContract,
+  Smith::Workflow::Composite::ExecutionContract,
+  Smith::Workflow::SplitStepPersistence::CompositeBranchEffects,
+  Smith::Workflow::SplitStepPersistence::CompositeBranchOutcome,
+  Smith::Workflow::SplitStepPersistence::CompositePreparation,
+  Smith::Workflow::SplitStepPersistence::CompositeBranchAuthorization,
+  Smith::Workflow::SplitStepPersistence::CompositeBranchExecution,
+  Smith::Workflow::SplitStepPersistence::CompositeReductionExecution,
+  Smith::Workflow::SplitStepPersistence::CompositeExecution
 )

data/lib/smith.rb

@@ -267,6 +267,8 @@ require_relative "smith/workflow/graph_dsl"
 require_relative "smith/workflow/run_result"
 require_relative "smith/workflow/agent_result"
 require_relative "smith/workflow/usage_entry"
+require_relative "smith/workflow/process_local"
+require_relative "smith/workflow/thread_context_snapshot"
 require_relative "smith/workflow/branch_env"
 require_relative "smith/workflow/optimization_state"
 require_relative "smith/workflow/orchestration_state"
@@ -274,6 +276,7 @@ require_relative "smith/workflow/worker_execution"
 require_relative "smith/workflow/dsl"
 require_relative "smith/workflow/definition_identity"
 require_relative "smith/workflow/prepared_step_dispatch"
+require_relative "smith/workflow/prepared_branch_execution"
 require_relative "smith/workflow/message_value_normalizer"
 require_relative "smith/workflow/message_admission"
 require_relative "smith/workflow/message_batch"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smith-agents
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Samuel Ralak
@@ -257,6 +257,38 @@ files:
 - lib/smith/workflow/branch_env.rb
 - lib/smith/workflow/budget_integration.rb
 - lib/smith/workflow/claim.rb
+- lib/smith/workflow/composite/branch.rb
+- lib/smith/workflow/composite/branch_budget_contract.rb
+- lib/smith/workflow/composite/branch_contract.rb
+- lib/smith/workflow/composite/branch_execution.rb
+- lib/smith/workflow/composite/branch_failure.rb
+- lib/smith/workflow/composite/branch_outcome.rb
+- lib/smith/workflow/composite/budget_allocator.rb
+- lib/smith/workflow/composite/budget_math.rb
+- lib/smith/workflow/composite/contract.rb
+- lib/smith/workflow/composite/effects.rb
+- lib/smith/workflow/composite/effects_application.rb
+- lib/smith/workflow/composite/effects_baseline.rb
+- lib/smith/workflow/composite/effects_preflight.rb
+- lib/smith/workflow/composite/encoded_value_budget.rb
+- lib/smith/workflow/composite/enums.rb
+- lib/smith/workflow/composite/error.rb
+- lib/smith/workflow/composite/error_evidence.rb
+- lib/smith/workflow/composite/execution_contract.rb
+- lib/smith/workflow/composite/fanout_branch_contract.rb
+- lib/smith/workflow/composite/input.rb
+- lib/smith/workflow/composite/outcome_accumulator.rb
+- lib/smith/workflow/composite/outcome_set.rb
+- lib/smith/workflow/composite/payload.rb
+- lib/smith/workflow/composite/payload_digest.rb
+- lib/smith/workflow/composite/plan.rb
+- lib/smith/workflow/composite/plan_integrity.rb
+- lib/smith/workflow/composite/planner.rb
+- lib/smith/workflow/composite/preparation.rb
+- lib/smith/workflow/composite/reducer.rb
+- lib/smith/workflow/composite/reduction.rb
+- lib/smith/workflow/composite/value_budget.rb
+- lib/smith/workflow/composite_branch_execution_authorization.rb
 - lib/smith/workflow/data_volume_policy.rb
 - lib/smith/workflow/deadline_enforcement.rb
 - lib/smith/workflow/definition_identity.rb
@@ -325,12 +357,14 @@ files:
 - lib/smith/workflow/parallel_execution.rb
 - lib/smith/workflow/persistence.rb
 - lib/smith/workflow/pipeline.rb
+- lib/smith/workflow/prepared_branch_execution.rb
 - lib/smith/workflow/prepared_step.rb
 - lib/smith/workflow/prepared_step_dispatch.rb
 - lib/smith/workflow/prepared_step_execution_authorization.rb
 - lib/smith/workflow/prepared_step_execution_result.rb
 - lib/smith/workflow/prepared_step_execution_scope.rb
 - lib/smith/workflow/prepared_step_recovery.rb
+- lib/smith/workflow/process_local.rb
 - lib/smith/workflow/retry_execution.rb
 - lib/smith/workflow/router.rb
 - lib/smith/workflow/run_result.rb
@@ -340,6 +374,13 @@ files:
 - lib/smith/workflow/split_step_persistence/canonical_payload_digest.rb
 - lib/smith/workflow/split_step_persistence/checkpoint.rb
 - lib/smith/workflow/split_step_persistence/checkpoint_state.rb
+- lib/smith/workflow/split_step_persistence/composite_branch_authorization.rb
+- lib/smith/workflow/split_step_persistence/composite_branch_effects.rb
+- lib/smith/workflow/split_step_persistence/composite_branch_execution.rb
+- lib/smith/workflow/split_step_persistence/composite_branch_outcome.rb
+- lib/smith/workflow/split_step_persistence/composite_execution.rb
+- lib/smith/workflow/split_step_persistence/composite_preparation.rb
+- lib/smith/workflow/split_step_persistence/composite_reduction_execution.rb
 - lib/smith/workflow/split_step_persistence/definition_boundary.rb
 - lib/smith/workflow/split_step_persistence/dispatch_boundary.rb
 - lib/smith/workflow/split_step_persistence/dispatch_claim.rb
@@ -347,8 +388,10 @@ files:
 - lib/smith/workflow/split_step_persistence/dispatch_verification.rb
 - lib/smith/workflow/split_step_persistence/execution.rb
 - lib/smith/workflow/split_step_persistence/execution_authorization.rb
+- lib/smith/workflow/split_step_persistence/execution_authorization_issuance.rb
 - lib/smith/workflow/split_step_persistence/execution_binding_collector.rb
 - lib/smith/workflow/split_step_persistence/execution_binding_snapshot.rb
+- lib/smith/workflow/split_step_persistence/execution_lifecycle.rb
 - lib/smith/workflow/split_step_persistence/execution_result_capture.rb
 - lib/smith/workflow/split_step_persistence/execution_verification.rb
 - lib/smith/workflow/split_step_persistence/execution_workflow_snapshot.rb
@@ -371,7 +414,9 @@ files:
 - lib/smith/workflow/split_step_persistence/transition_contract_signature.rb
 - lib/smith/workflow/split_step_persistence/transition_contract_structured_values.rb
 - lib/smith/workflow/step_completion.rb
+- lib/smith/workflow/step_context.rb
 - lib/smith/workflow/string_snapshot.rb
+- lib/smith/workflow/thread_context_snapshot.rb
 - lib/smith/workflow/transition.rb
 - lib/smith/workflow/transition_actionability.rb
 - lib/smith/workflow/usage_entry.rb