phronomy 0.27.0 → 0.28.0

data/lib/phronomy/agent/execution/execution_metadata.rb

@@ -27,6 +27,7 @@ module Phronomy
             "arguments" => serializable_value(child.raw_arguments || {}),
             "status" => child.status.to_s
           }
+          entry["validated_arguments"] = serializable_value(child.arguments) if child.arguments
           if child.execution_completed?
             entry["result"] = serializable_value(child.result)
           end

data/lib/phronomy/agent/execution/execution_outcome_committer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 module Phronomy
   module Agent
@@ -10,10 +10,6 @@ module Phronomy
     class ExecutionOutcomeCommitter
       include Phronomy::Concurrency::WorkerInputRestricted
 
-      HandoffTerminalView = Data.define(
-        :target_agent_id, :responsibility, :selection_intent,
-        :llm_call_id, :tool_call_id, :policy
-      )
       TerminalView = Data.define(
         :phase, :output, :usage, :approval_request, :rejected,
         :input_blocked, :output_blocked, :block_error,
@@ -22,7 +18,7 @@ module Phronomy
       Command = Data.define(
         :execution_id, :fsm_session_id, :expected_execution_revision,
         :root, :journal_records, :execution, :runtime_snapshot,
-        :terminal_view, :state_required
+        :terminal_view, :state_required, :wiring
       )
       Outcome = Data.define(
         :type, :execution, :root, :appended_records,
@@ -40,121 +36,88 @@ module Phronomy
         view = operation.terminal_view
         error = view.callback_failure&.to_stream_callback_error || view.source_error ||
           view.block_error || view.invocation_error
-        if operation.execution.metadata["multi_agent_coordination_ref"] &&
-            (error.is_a?(Phronomy::ExecutionRehydrationRequiredError) || view.cancel_requested)
-          waiting = commit_coordination_wait(operation, error)
-          return waiting if waiting
+        change = ExecutionChange.new(agent: @agent, current: operation.execution,
+          root: operation.root, kind: :terminal, terminal: view, config: operation.wiring) do |tx, state, receipt, pending|
+          if pending
+            waiting = operation.execution.with(metadata: extension_metadata(operation.execution, state).merge(
+              "cancellation_requested" => change.cancel_requested || operation.execution.metadata["cancellation_requested"] == true
+            ))
+            save_execution(tx, operation.execution, waiting)
+            Outcome.new(type: :coordination_wait, execution: waiting, root: operation.root,
+              appended_records: [].freeze, result: nil,
+              error: error || Phronomy::ExecutionRehydrationRequiredError.new("Execution retains unfinished participant work"), approval_request: nil)
+          else
+            raise error if error.is_a?(Phronomy::ExecutionRehydrationRequiredError)
+            commit_terminal(tx, operation, state, receipt, error)
+          end
         end
-        raise error if error.is_a?(Phronomy::ExecutionRehydrationRequiredError)
-        return commit_failed_outcome(operation, error) if error
-        return commit_suspended(operation) if view.phase == :suspended
-        commit_completed(operation)
-      rescue => caught
-        reconcile_terminal_error(operation, caught)
+        change.perform
       end
 
       private
 
-      # Reuse the Agent barrier to retain unfinished owned children. This is an
-      # active AgentExecution snapshot, not a second scheduler or terminal state.
-      def commit_coordination_wait(operation, error)
-        current = operation.execution
-        waiting = nil
-        @persistence.transaction do |tx|
-          refreshed = @agent.__prepare_coordination_record(current, tx: tx)
-          snapshot = tx.contents.fetch_json(refreshed.metadata.fetch("multi_agent_coordination_ref"))
-          unresolved = snapshot.fetch("children").any? do |child|
-            !%w[completed failed cancelled rejected blocked handed_off].include?(child.fetch("state")) &&
-              !(operation.terminal_view.cancel_requested && child.fetch("state") == "reserved")
-          end
-          next unless unresolved
-          waiting = current.with(metadata: refreshed.metadata.merge(
-            "coordination_cancel_requested" => operation.terminal_view.cancel_requested || current.metadata["coordination_cancel_requested"] == true
-          ))
-          tx.executions.save(current.execution_id, expected_revision: current.execution_revision, execution: waiting)
+      def commit_terminal(tx, operation, state, receipt, error)
+        view = operation.terminal_view
+        if !error && view.phase == :suspended
+          suspended = encode_suspension(tx, operation)
+          suspended = with_extension(suspended, state)
+          save_execution(tx, operation.execution, suspended)
+          root = save_suspended_root(tx, operation.root)
+          return Outcome.new(type: :suspended, execution: suspended, root: root,
+            appended_records: [].freeze,
+            result: result_base(suspended, root).merge(suspended: true, approval_request: view.approval_request).freeze,
+            error: nil, approval_request: view.approval_request)
         end
-        return unless waiting
-        coordination_wait_outcome(operation, waiting, error)
-      rescue => failure
-        confirmed = @persistence.executions.load(current.execution_id)
-        raise failure unless waiting && confirmed.to_h == waiting.to_h
-        coordination_wait_outcome(operation, confirmed, error)
-      end
-
-      def coordination_wait_outcome(operation, execution, error)
-        Outcome.new(type: :coordination_wait, execution: execution, root: operation.root,
-          appended_records: [].freeze, result: nil,
-          error: error.is_a?(Phronomy::ExecutionRehydrationRequiredError) ? error :
-            Phronomy::ExecutionRehydrationRequiredError.new("Execution #{execution.execution_id} retains unfinished children for cancellation/recovery"),
-          approval_request: nil)
-      end
-
-      # F1: terminal atomicity alone does not establish commit outcome certainty.
-      # Reuse an exact committed outcome; an absent/active/read-failed result is
-      # never permission to write a second terminal transition.
-      def reconcile_terminal_error(operation, error)
-        confirmed = @persistence.executions.load(operation.execution_id)
-        raise error unless confirmed.terminal? &&
-          confirmed.agent_id == @agent.agent_id &&
-          confirmed.execution_revision == operation.expected_execution_revision + 1
-        root = @persistence.agents.load(@agent.agent_id)
-        records = @persistence.journals.read(@agent.agent_id,
-          after: operation.root.journal_position, limit: root.journal_position - operation.root.journal_position)
-        result = @persistence.execution_result(confirmed.execution_id)
-        failure = result[:error] && RecoverySupport.error_from_failure(result[:error])
-        type = if failure
-          :failed
+        records, execution = if error
+          encode_failure(tx, operation, error)
+        elsif view.handoff
+          raise Phronomy::ConfigurationError, "Control transfer needs a transaction participant" unless receipt
+          encode_transfer(tx, operation, receipt)
         else
-          ((confirmed.status == :handed_off) ? :handed_off : :completed)
+          encode_completion(tx, operation)
         end
-        Outcome.new(type: type, execution: confirmed, root: root,
-          appended_records: records.freeze,
-          result: failure ? nil : result_base(confirmed, root).merge(output: result[:result]).freeze,
-          error: failure, approval_request: nil)
-      end
-
-      def commit_suspended(operation)
-        suspended = next_root = nil
-        @persistence.transaction do |tx|
-          suspended = encode_suspension(tx, operation)
-          save_execution(tx, operation.execution, suspended)
-          next_root = save_suspended_root(tx, operation.root)
+        execution = with_extension(execution, state)
+        appended = append_journal(tx, operation.root, records)
+        save_execution(tx, operation.execution, execution)
+        root = save_terminal_root(tx, operation.root, appended)
+        if error
+          Outcome.new(type: :failed, execution: execution, root: root, appended_records: appended.freeze,
+            result: nil, error: error, approval_request: nil)
+        elsif view.handoff
+          Outcome.new(type: :handed_off, execution: execution, root: root, appended_records: appended.freeze,
+            result: result_base(execution, root).freeze, error: nil, approval_request: nil)
+        else
+          messages = transcript_messages(root, operation.journal_records + appended, persistence: tx)
+          completed_outcome(view, execution, root, appended, messages)
         end
-        request = operation.terminal_view.approval_request
-        Outcome.new(type: :suspended, execution: suspended, root: next_root,
-          appended_records: [].freeze,
-          result: result_base(suspended, next_root).merge(suspended: true, approval_request: request).freeze,
-          error: nil, approval_request: request)
       end
 
-      def commit_completed(operation)
-        completed = next_root = appended = messages = nil
-        @persistence.transaction do |tx|
-          records, completed = encode_completion(tx, operation)
-          appended = append_journal(tx, operation.root, records)
-          completed = save_coordinated_execution(tx, operation.execution, completed)
-          next_root = save_terminal_root(tx, operation.root, appended)
+      def extension_metadata(execution, state)
+        execution.metadata.merge("execution_extension" => state&.to_h).compact
+      end
 
-          # Materialization stays inside the transaction. A failure rolls back
-          # the terminal transition instead of writing again from a stale base.
-          messages = transcript_messages(next_root,
-            operation.journal_records + Array(appended), persistence: tx)
-        end
-        completed_outcome(operation.terminal_view, completed, next_root, appended, messages)
+      def with_extension(execution, state)
+        execution.with(execution_revision: execution.execution_revision, metadata: extension_metadata(execution, state))
       end
 
-      def commit_failed_outcome(operation, error)
-        translated_error = @agent.send(:_translated_error, error)
-        failed = next_root = appended = nil
-        @persistence.transaction do |tx|
-          records, failed = encode_failure(tx, operation, translated_error)
-          appended = append_journal(tx, operation.root, records)
-          failed = save_coordinated_execution(tx, operation.execution, failed)
-          next_root = save_terminal_root(tx, operation.root, appended)
+      def encode_transfer(tx, operation, receipt)
+        request = operation.terminal_view.handoff
+        unless receipt.fetch("target_agent_id") == request.target_agent_id &&
+            !receipt.fetch("target_execution_id").to_s.empty? && !receipt.fetch("context_ref").to_s.empty?
+          raise Phronomy::Persistence::StateConflictError, "Control transfer receipt mismatch"
         end
-        Outcome.new(type: :failed, execution: failed, root: next_root,
-          appended_records: Array(appended).freeze,
-          result: nil, error: translated_error, approval_request: nil)
+        current = operation.execution
+        encoded, calls = encode_runtime_records(tx, operation, context_candidate: false)
+        audit_ref = tx.contents.put_json("target_agent_id" => request.target_agent_id,
+          "responsibility" => request.responsibility, "selection" => request.selection.transform_keys(&:to_s))
+        audit = JournalRecord.new(agent_id: @agent.agent_id, execution_id: current.execution_id,
+          llm_call_id: request.llm_call_id, kind: :execution_handed_off, channel: :audit,
+          content_ref: audit_ref, context_generation: operation.root.transcript_generation, context_candidate: false,
+          metadata: {"target_agent_id" => request.target_agent_id, "handoff_tool_call_id" => request.tool_call_id}.compact)
+        updated = current.with(status: :handed_off, phase: :handed_off, working_records: [],
+          llm_calls: current.llm_calls + calls, approval_request: nil, terminal_reason: "handed_off",
+          metadata: current.metadata.merge("transfer_receipt" => receipt))
+        [current.working_records + encoded + [audit], updated]
       end
 
       def encode_suspension(tx, operation)
@@ -264,25 +227,6 @@ module Phronomy
           expected_position: root.journal_position, records: records)
       end
 
-      def save_coordinated_execution(tx, current, updated)
-        coordinated = @agent.__prepare_coordination_record(updated, tx: tx)
-        synchronize_handoff_target(tx, coordinated)
-        save_execution(tx, current, coordinated)
-        coordinated
-      end
-
-      def synchronize_handoff_target(tx, execution)
-        coordination = execution.metadata["coordination"]
-        return unless coordination && coordination["kind"] == "handoff"
-        routing = tx.handoff_states.load(coordination.fetch("main_agent_id"))
-        return unless routing && routing.pending_target_execution_id == execution.execution_id && routing.phase != "stable"
-        unless routing.active_agent_id == execution.agent_id
-          raise Phronomy::Storage::ConflictError, "Handoff Target owner mismatch"
-        end
-        tx.handoff_states.save(routing.main_agent_id, expected_revision: routing.handoff_revision,
-          state: routing.with(phase: "stable"))
-      end
-
       def save_execution(tx, current, updated)
         tx.executions.save(current.execution_id,
           expected_revision: current.execution_revision, execution: updated)
@@ -318,7 +262,7 @@ module Phronomy
       end
 
       def transcript_messages(root, journal_records, persistence: @persistence)
-        materializer = RubyLLMMaterializer.new(
+        materializer = RuntimeInput.new(
           agent: @agent,
           persistence: persistence
         )

data/lib/phronomy/agent/execution/execution_registry.rb

@@ -6,6 +6,10 @@ module Phronomy
     # The EventLoop remains the sole writer during execution.
     # @api private
     class ExecutionRegistry < Phronomy::ExecutionReceiver
+      def self.existing_current
+        ExecutionEnvironment.current.existing_registry
+      end
+
       # Immutable Agent-owned value. The map containing these records is the
       # mutable authority; records are replaced rather than mutated in place.
       AgentExecutionState = Data.define(
@@ -36,7 +40,7 @@ module Phronomy
       PhysicalCompletion = Data.define(:execution_id, :token)
       private_constant :UNSET, :PhysicalCompletion
 
-      def initialize(event_loop:)
+      def initialize(channel:)
         super
         @agent_admissions = {}
         @agent_executions = {}
@@ -364,7 +368,7 @@ module Phronomy
         callback = lambda do
           accepted = post_message(PhysicalCompletion.new(execution_id: key, token: token))
           unless accepted
-            Phronomy.configuration.logger&.warn(
+            Phronomy::RuntimeSettings.current.logger&.warn(
               "[Phronomy] EventLoop rejected physical-completion delivery for #{key}"
             )
           end

data/lib/phronomy/agent/execution/execution_session_runner.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 module Phronomy
   module Agent
@@ -11,10 +11,9 @@ module Phronomy
     class ExecutionSessionRunner
       include Phronomy::Concurrency::WorkerInputRestricted
 
-      def initialize(runtime:, on_complete:)
+      def initialize(environment:, on_complete:)
         @on_complete = on_complete
-        @runtime = runtime
-        @event_loop = runtime.event_loop
+        @environment = environment
       end
 
       def register(session, result_task, source_name: "#{result_task.name}-source")
@@ -29,20 +28,19 @@ module Phronomy
             fsm_session_id: session.id
           )
         end
-        @event_loop.register(session, completion: source)
+        @environment.register_session(session, completion: source)
         session
       end
 
       def resume(invocation, result_task, resume_event:, resume_phase:,
         source_name: "#{result_task.name}-source")
         assert_event_loop!
-        session = AgentInvocationSessionBuilder.build_for_resume(
-          agent_invocation: invocation,
+        session = @environment.build_agent_session(
+          invocation: invocation,
           resume_event: resume_event,
-          resume_phase: resume_phase,
-          runtime: @runtime
+          resume_phase: resume_phase
         )
-        ExecutionRegistry.for(@event_loop).replace_agent_execution(
+        @environment.registry.replace_agent_execution(
           invocation.execution_id,
           invocation: invocation,
           fsm_session_id: session.id
@@ -58,20 +56,18 @@ module Phronomy
           resume_event: :resume, resume_phase: :suspended)
         invocation.tool_invocations.each do |child|
           session = if child.awaiting_approval?
-            ToolInvocationSessionBuilder.build_for_resume(
-              tool_invocation: child,
-              parent_event_sink: parent.event_sink,
+            @environment.build_tool_session(
+              invocation: child,
+              parent_sink: parent.event_sink,
               resume_event: approved ? :approve : :reject,
-              resume_phase: :awaiting_approval,
-              runtime: @runtime
+              resume_phase: :awaiting_approval
             )
           elsif !approved && child.authorized?
-            ToolInvocationSessionBuilder.build_for_resume(
-              tool_invocation: child,
-              parent_event_sink: parent.event_sink,
+            @environment.build_tool_session(
+              invocation: child,
+              parent_sink: parent.event_sink,
               resume_event: :cancel,
-              resume_phase: :authorized,
-              runtime: @runtime
+              resume_phase: :authorized
             )
           end
           register_child(child, session, parent.event_sink) if session
@@ -84,12 +80,11 @@ module Phronomy
           resume_event: :resume, resume_phase: :suspended,
           source_name: "framework-tool-recovery-source")
         invocation.tool_invocations.select(&:authorized?).each do |child|
-          session = ToolInvocationSessionBuilder.build_for_resume(
-            tool_invocation: child,
-            parent_event_sink: parent.event_sink,
+          session = @environment.build_tool_session(
+            invocation: child,
+            parent_sink: parent.event_sink,
             resume_event: :dispatch,
-            resume_phase: :authorized,
-            runtime: @runtime
+            resume_phase: :authorized
           )
           register_child(child, session, parent.event_sink)
         end
@@ -105,11 +100,11 @@ module Phronomy
           child.mark_framework_failed!(error)
           parent_event_sink.post(:tool_failed, {tool_invocation_id: child.id})
         end
-        @event_loop.register(session, completion: completion)
+        @environment.register_session(session, completion: completion)
       end
 
       def assert_event_loop!
-        return if @event_loop.current?
+        return if @environment.executing?
 
         raise Phronomy::Error, "Agent session registration must run on EventLoop"
       end

data/lib/phronomy/agent/execution/initial_preparation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 require "securerandom"
 require "time"
@@ -49,9 +49,9 @@ module Phronomy
           # A durable nonterminal execution keeps Runtime admission fail-closed
           # until recovery can establish its lineage, including after F4 loss.
           return unadmitted_result(operation, error, :recovery_required)
-        rescue Phronomy::Storage::ConflictError,
-          Phronomy::Storage::NotFoundError,
-          Phronomy::Storage::SerializationError,
+        rescue Phronomy::Persistence::ConflictError,
+          Phronomy::Persistence::NotFoundError,
+          Phronomy::Persistence::SerializationError,
           ArgumentError,
           Phronomy::ConfigurationError => error
           return unadmitted_result(operation, error, :not_established)
@@ -97,7 +97,7 @@ module Phronomy
           filtered_input: nil,
           config: operation.config,
           appended_records: [].freeze,
-          error: translated(error),
+          error: error,
           admission_outcome: outcome
         )
       end
@@ -114,7 +114,7 @@ module Phronomy
           # Advance the failure base only after the commit response is known.
           # F1 response loss must not be reported as a confirmed terminal result.
           current_execution = active_execution
-          projection = RubyLLMMaterializer.new(
+          projection = RuntimeInput.new(
             agent: @agent, persistence: @persistence
           ).materialize(manifest: manifest, manifest_ref: manifest_ref)
           Result.new(
@@ -166,7 +166,7 @@ module Phronomy
       end
 
       def prepare_context(staged, root, input, config, journal_records)
-        assembler = ContextAssembler.new(
+        assembler = ContextPreparation.new(
           agent: @agent, persistence: @persistence, journal_records: journal_records
         )
         prepared = assembler.prepare_initial(
@@ -184,7 +184,7 @@ module Phronomy
         active = manifest = manifest_ref = nil
         @persistence.transaction do |tx|
           assert_local_durable_base!(tx, root)
-          manifest, manifest_ref = assembler.finalize(prepared, persistence: tx)
+          manifest, manifest_ref = Phronomy::Context::Assembly.new.store(prepared, contents: tx.contents)
           active = execution_with_initial_manifest(staged, manifest_ref)
           tx.executions.save(
             staged.execution_id,
@@ -208,26 +208,15 @@ module Phronomy
       end
 
       def admit_execution(raw_message, root:, mode: :invoke, config: {}, preparation_replayable: false)
-        if root.lifecycle_status == :closed
-          raise Phronomy::Error, "agent is closed: #{@agent.agent_id}"
+        admission = Admission.new(persistence: @persistence, root: root,
+          input: raw_message, config: config,
+          preparation_metadata: initial_preparation_metadata(mode.to_sym, preparation_replayable))
+        participant = config[:phronomy_admission]
+        if admission.correlation && !participant
+          raise Phronomy::ConfigurationError, "Coordinated admission requires its current owner"
         end
-
-        execution = next_root = nil
-        preparation_metadata = initial_preparation_metadata(mode.to_sym, preparation_replayable)
-        @persistence.transaction do |tx|
-          execution = build_admitted_execution(
-            tx, raw_message, root: root, config: config,
-            preparation_metadata: preparation_metadata
-          )
-          validate_coordination_admission!(tx, execution)
-          tx.executions.create_active(execution)
-          next_root = root.with(
-            agent_revision: root.agent_revision + 1,
-            lifecycle_status: :active
-          )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-        end
-        [execution, next_root]
+        participant ? participant.admit(admission) : admission.accept
+        admission.result
       end
 
       def initial_preparation_metadata(mode, replayable)
@@ -240,92 +229,9 @@ module Phronomy
         }
       end
 
-      def build_admitted_execution(tx, raw_message, root:, config:, preparation_metadata:)
-        input_ref = tx.contents.put_text(raw_message)
-        durable_context_ref = if config.key?(:durable_context)
-          tx.contents.put_json(config.fetch(:durable_context))
-        end
-        input_record = JournalRecord.new(
-          agent_id: @agent.agent_id,
-          kind: :input_received,
-          channel: :external,
-          role: :user,
-          content_ref: input_ref,
-          context_generation: root.transcript_generation,
-          context_candidate: false
-        )
-        execution = AgentExecution.start(
-          agent_root: root,
-          input_record: input_record,
-          execution_id: config[:phronomy_reserved_execution_id] || SecureRandom.uuid,
-          metadata: {
-            "coordination" => config[:phronomy_coordination],
-            "current_input_ref" => input_ref,
-            "durable_context_ref" => durable_context_ref
-          }.merge(preparation_metadata).compact
-        )
-        input_record = JournalRecord.from_h(input_record.to_h.merge("execution_id" => execution.execution_id))
-        execution.with(execution_revision: 0, working_records: [input_record])
-      end
-
-      def validate_coordination_admission!(tx, execution)
-        owner = execution.metadata["coordination"]
-        return unless owner
-
-        case owner.fetch("kind")
-        when "team" then validate_team_admission!(tx, execution, owner)
-        when "subagent" then validate_subagent_admission!(tx, execution, owner)
-        when "handoff" then validate_handoff_admission!(tx, execution, owner)
-        else
-          raise Phronomy::ConfigurationError, "Unknown coordination owner kind"
-        end
-      end
-
-      def validate_team_admission!(tx, execution, owner)
-        team = tx.team_executions.load(owner.fetch("team_execution_id"))
-        unless team.team_id == owner.fetch("team_id") && team.active? && !team.metadata["cancel_requested"]
-          raise Phronomy::CancellationError, "Team run is no longer dispatchable"
-        end
-        slot = if owner.fetch("slot") == "coordinator"
-          team.coordinator
-        else
-          assignment = team.assignments.find { |entry| entry.fetch("task_id") == owner.fetch("slot") }
-          worker = assignment && team.workers.fetch(assignment.fetch("worker"))
-          worker&.merge("execution_id" => assignment.fetch("execution_id"))
-        end
-        unless slot && slot.fetch("execution_id") == execution.execution_id && slot.fetch("agent_id") == execution.agent_id
-          raise Phronomy::Storage::ConflictError, "Team reserved child identity mismatch"
-        end
-      end
-
-      def validate_subagent_admission!(tx, execution, owner)
-        parent = tx.executions.load(owner.fetch("parent_execution_id"))
-        unless parent.agent_id == owner.fetch("parent_agent_id") && parent.active? && !parent.metadata["coordination_cancel_requested"]
-          raise Phronomy::CancellationError, "Parent run is no longer dispatchable"
-        end
-        snapshot = tx.contents.fetch_json(parent.metadata.fetch("multi_agent_coordination_ref"))
-        slot = snapshot.fetch("children").find { |entry| entry.fetch("slot") == owner.fetch("slot") }
-        unless slot && slot.fetch("agent_id") == execution.agent_id && slot.fetch("execution_id") == execution.execution_id
-          raise Phronomy::Storage::ConflictError, "Parent reserved child identity mismatch"
-        end
-      end
-
-      def validate_handoff_admission!(tx, execution, owner)
-        routing = tx.handoff_states.load(owner.fetch("main_agent_id"))
-        unless routing && routing.active_agent_id == execution.agent_id
-          raise Phronomy::Storage::ConflictError, "Handoff responsibility changed before admission"
-        end
-        if Array(routing.metadata["cancelled_execution_ids"]).include?(execution.execution_id)
-          raise Phronomy::CancellationError, "Handoff reservation was cancelled"
-        end
-        if routing.phase != "stable" && routing.pending_target_execution_id != execution.execution_id
-          raise Phronomy::Storage::ConflictError, "Handoff reserved Target identity mismatch"
-        end
-      end
-
       def recovered_config(execution)
         mode = (execution.metadata[ExecutionMetadata::INVOCATION_MODE_KEY] || "invoke").to_sym
-        config = {phronomy_recovery_mode: mode}.merge(@agent.__coordination_config)
+        config = {phronomy_recovery_mode: mode}.merge(@agent.__execution_wiring)
         if execution.metadata.key?("durable_context_ref")
           context = @persistence.contents.fetch_json(execution.metadata.fetch("durable_context_ref"))
           unless context.is_a?(Hash)
@@ -353,7 +259,7 @@ module Phronomy
       end
 
       def commit_preparation_failure(execution, root, error)
-        translated_error = translated(error)
+        translated_error = error
         failed = next_root = appended = nil
         @persistence.transaction do |tx|
           error_ref = tx.contents.put_json(
@@ -412,10 +318,6 @@ module Phronomy
           journal_position: root.journal_position
         )
       end
-
-      def translated(error)
-        @agent.send(:_translated_error, error)
-      end
     end
   end
 end