phronomy 0.22.0 → 0.24.0

data/lib/phronomy/agent/execution_coordinator.rb

@@ -1,48 +1,158 @@
 # frozen_string_literal: true
 
 require "time"
+require "securerandom"
 
 module Phronomy
   module Agent
     class ExecutionCoordinator
-      Prepared = Data.define(:execution, :runtime_projection, :filtered_input, :config)
-      AgentTerminalCommand = Struct.new(:coordinator, :activation, :result_task, :outcome, :commit_error)
-      PrepFailureCommand = Struct.new(:coordinator, :on_event_listener, :result_task, :error)
+      # External/API -> EventLoop control messages.
+      StartCommand = Data.define(
+        :coordinator, :input, :config, :mode,
+        :approval_policy, :approval_listener, :on_event, :result_task,
+        :admission_token
+      )
+      ResumeCommand = Data.define(
+        :coordinator, :execution_id, :approval_request_id,
+        :approved, :config, :result_task
+      )
+
+      # EventLoop -> Offload operation-specific immutable snapshots.
+      InitialPreparationCommand = Data.define(
+        :root, :journal_records, :input, :config, :preparation_replayable
+      )
+      ProviderDispatchPreparationCommand = Data.define(
+        :execution_id, :fsm_session_id, :expected_execution_revision,
+        :root, :journal_records, :execution, :base_manifest,
+        :invocation_config, :runtime_snapshot, :streaming,
+        :pending_llm_call_id, :pending_llm_started_at
+      )
+      ToolDispatchPreparationCommand = Data.define(
+        :execution_id, :fsm_session_id, :expected_execution_revision,
+        :root, :execution, :runtime_snapshot, :tool_batch_snapshot
+      )
+      ProviderDispatchPreparationReconciliationCommand = Data.define(
+        :operation, :intended_result, :original_error
+      )
+      ToolDispatchPreparationReconciliationCommand = Data.define(
+        :operation, :intended_result, :original_error
+      )
+      ResumeCommitCommand = Data.define(
+        :execution_id, :expected_execution_revision,
+        :root, :execution, :approval_request_id, :approved
+      )
+      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,
+        :invocation_error, :handoff, :callback_failure, :source_error, :cancel_requested
+      )
+      TerminalCommitCommand = Data.define(
+        :execution_id, :fsm_session_id, :expected_execution_revision,
+        :root, :journal_records, :execution, :runtime_snapshot,
+        :terminal_view, :state_required
+      )
+      TerminalDelivery = Data.define(
+        :result_task, :application_listener, :approval_listener,
+        :handoff_request, :handoff_manifest
+      )
+
+      # Offload -> EventLoop operation results. No live Agent/Invocation object is
+      # mutated by a worker; these values are validated and applied on EventLoop.
+      InitialPreparationResult = Data.define(
+        :execution, :root, :runtime_projection, :filtered_input,
+        :config, :appended_records, :error, :admission_outcome
+      )
+      ProviderDispatchPreparationResult = Data.define(:execution, :runtime_projection, :error)
+      ToolDispatchPreparationResult = Data.define(:execution)
+      ProviderDispatchPreparationReconciliationResult = Data.define(
+        :disposition, :preparation_result
+      )
+      ToolDispatchPreparationReconciliationResult = Data.define(
+        :disposition, :preparation_result
+      )
+      ResumeCommitResult = Data.define(:execution, :root)
+      TerminalOutcome = Data.define(
+        :type, :execution, :root, :appended_records,
+        :result, :error, :approval_request
+      )
+
+      InitialPreparationReady = Data.define(
+        :coordinator, :request, :result, :error
+      )
+      InitialPreparationRecoveryReady = Data.define(
+        :coordinator, :execution_id, :expected_execution_revision,
+        :result_task, :load_completion, :result, :error
+      )
+      ProviderDispatchPreparationReady = Data.define(
+        :coordinator, :operation, :result, :error
+      )
+      ToolDispatchPreparationReady = Data.define(
+        :coordinator, :operation, :result, :error
+      )
+      ProviderDispatchPreparationReconciliationReady = Data.define(
+        :coordinator, :command, :result, :error
+      )
+      ToolDispatchPreparationReconciliationReady = Data.define(
+        :coordinator, :command, :result, :error
+      )
+      ResumeCommitReady = Data.define(
+        :coordinator, :request, :operation, :result, :error
+      )
+      TerminalCommitReady = Data.define(
+        :coordinator, :operation, :delivery, :outcome, :error
+      )
+      DeferredTerminalCommand = Data.define(
+        :coordinator, :execution_id, :result_task, :invocation,
+        :source_error, :fsm_session_id
+      )
+
+      class PreparationOutcomeUnknownError < Phronomy::Error
+        attr_reader :original_error, :intended_result
+
+        def initialize(original_error, intended_result)
+          @original_error = original_error
+          @intended_result = intended_result
+          super(
+            "durable dispatch preparation outcome is uncertain: " \
+              "#{original_error.class}: #{original_error.message}"
+          )
+          set_backtrace(original_error.backtrace)
+        end
+      end
+      private_constant :PreparationOutcomeUnknownError
 
       def initialize(agent)
         @agent = agent
       end
 
       def start(
-        input, thread_id: nil, config: {}, mode: :invoke,
+        input, config: {}, mode: :invoke,
         approval_policy: nil, approval_listener: nil, on_event: nil
       )
+        @agent.send(:__assert_live_agent!)
+        @agent.send(:_reject_removed_generic_identity_keys!, config)
         result_task = Phronomy::Task.deferred(name: "agent-#{@agent.agent_id}-#{mode}")
-        runtime = Phronomy::Runtime.instance
-        preparation = runtime.offload.submit(on_full: :raise) do
-          prepare(input, thread_id: thread_id, config: config)
-        end
-        preparation.on_complete do |prepared, error|
-          if error
-            post_prep_failure(runtime, on_event, result_task, translated(error))
-          else
-            register(
-              prepared,
-              result_task,
-              mode: mode,
-              approval_policy: approval_policy,
-              approval_listener: approval_listener,
-              on_event: on_event
-            )
-          end
+        command = StartCommand.new(
+          coordinator: self,
+          input: input,
+          config: @agent.__invocation_config(config).dup.freeze,
+          mode: mode.to_sym,
+          approval_policy: approval_policy,
+          approval_listener: approval_listener,
+          on_event: on_event,
+          result_task: result_task,
+          admission_token: Object.new.freeze
+        )
+        unless post_control(Phronomy::Runtime.instance, command)
+          fail_task(result_task, runtime_rejected_error(:start))
         end
         result_task
       rescue => error
-        if defined?(runtime) && runtime
-          post_prep_failure(runtime, on_event, result_task, translated(error))
-        else
-          fail_task(result_task, translated(error))
-        end
+        fail_task(result_task, translated(error)) if defined?(result_task) && result_task
         result_task
       end
 
@@ -52,156 +162,393 @@ module Phronomy
         approved:,
         config: {}
       )
+        @agent.send(:__assert_live_agent!)
+        @agent.send(:_reject_removed_generic_identity_keys!, config)
         result_task = Phronomy::Task.deferred(
           name: "agent-approval-resume:#{execution_id}"
         )
+        command = ResumeCommand.new(
+          coordinator: self,
+          execution_id: execution_id.to_s.freeze,
+          approval_request_id: approval_request_id.to_s.freeze,
+          approved: !!approved,
+          config: config.dup.freeze,
+          result_task: result_task
+        )
+        unless post_control(Phronomy::Runtime.instance, command)
+          fail_task(result_task, runtime_rejected_error(:resume))
+        end
+        result_task
+      rescue => error
+        fail_task(result_task, translated(error)) if defined?(result_task) && result_task
+        result_task
+      end
+
+      # Called only from an Agent FSMSession external-operation dispatch state on
+      # EventLoop. Each method captures one operation-specific immutable snapshot
+      # and sends only that snapshot to OffloadPool.
+      # @api private
+      def prepare_provider_dispatch(invocation, event_sink:, streaming:)
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        assert_event_loop!(event_loop)
+        state = event_loop.agent_execution_state(invocation.execution_id)
+        validate_live_session!(state, invocation, event_sink.fsm_session_id)
+        unless event_loop.fsm_session_state(event_sink.fsm_session_id) == :calling_llm
+          raise Phronomy::Error,
+            "Provider dispatch preparation requires the owning FSMSession to be in :calling_llm"
+        end
+
+        operation = ProviderDispatchPreparationCommand.new(
+          execution_id: state.execution_id,
+          fsm_session_id: event_sink.fsm_session_id.to_s.freeze,
+          expected_execution_revision: state.execution.execution_revision,
+          root: @agent.agent_root,
+          journal_records: @agent.send(:_journal_records_snapshot),
+          execution: state.execution,
+          base_manifest: state.base_manifest,
+          invocation_config: invocation.config.dup.freeze,
+          runtime_snapshot: invocation.runtime_snapshot,
+          streaming: !!streaming,
+          pending_llm_call_id: SecureRandom.uuid.to_s.freeze,
+          pending_llm_started_at: Time.now.utc.iso8601(6).freeze
+        )
+        submit_provider_dispatch_preparation(operation)
+        nil
+      rescue => error
+        event_sink.post(:llm_setup_failed, translated(error))
+        nil
+      end
+
+      # @api private
+      def prepare_tool_dispatch(invocation, event_sink:)
         runtime = Phronomy::Runtime.instance
-        activation = runtime.__agent_activations.fetch(execution_id)
-        unless activation
-          fail_task(
-            result_task,
-            Phronomy::ExecutionRehydrationRequiredError.new(
-              "no live activation for #{execution_id}; durable rehydration is required"
+        event_loop = runtime.event_loop
+        assert_event_loop!(event_loop)
+        state = event_loop.agent_execution_state(invocation.execution_id)
+        validate_live_session!(state, invocation, event_sink.fsm_session_id)
+        unless event_loop.fsm_session_state(event_sink.fsm_session_id) == :dispatching_tools
+          raise Phronomy::Error,
+            "Tool dispatch preparation requires the owning FSMSession to be in :dispatching_tools"
+        end
+
+        tool_batch_snapshot = RecoverySupport.build_tool_batch_snapshot(invocation)
+        if tool_batch_snapshot.empty?
+          raise Phronomy::Error, "Tool dispatch preparation requires a non-empty Tool batch"
+        end
+
+        operation = ToolDispatchPreparationCommand.new(
+          execution_id: state.execution_id,
+          fsm_session_id: event_sink.fsm_session_id.to_s.freeze,
+          expected_execution_revision: state.execution.execution_revision,
+          root: @agent.agent_root,
+          execution: state.execution,
+          runtime_snapshot: invocation.runtime_snapshot,
+          tool_batch_snapshot: tool_batch_snapshot
+        )
+        submit_tool_dispatch_preparation(operation)
+        nil
+      rescue => error
+        event_sink.post(:tool_setup_failed, translated(error))
+        nil
+      end
+
+      def submit_provider_dispatch_preparation(operation)
+        runtime = Phronomy::Runtime.instance
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_provider_dispatch_preparation(operation)
+        end
+        task.on_complete do |result, error|
+          ready = ProviderDispatchPreparationReady.new(
+            coordinator: self,
+            operation: operation,
+            result: result,
+            error: error
+          )
+          unless post_control(runtime, ready)
+            Phronomy.configuration.logger&.warn(
+              "[Phronomy] EventLoop rejected Provider dispatch preparation result for " \
+              "#{operation.execution_id}"
             )
-          )
-          return result_task
+          end
         end
+      end
 
-        unless activation.agent.equal?(@agent) &&
-            activation.execution.status == :suspended
-          fail_task(
-            result_task,
-            ArgumentError.new(
-              "execution is not a suspended execution of this agent: #{execution_id}"
+      def submit_tool_dispatch_preparation(operation)
+        runtime = Phronomy::Runtime.instance
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_tool_dispatch_preparation(operation)
+        end
+        task.on_complete do |result, error|
+          ready = ToolDispatchPreparationReady.new(
+            coordinator: self,
+            operation: operation,
+            result: result,
+            error: error
+          )
+          unless post_control(runtime, ready)
+            Phronomy.configuration.logger&.warn(
+              "[Phronomy] EventLoop rejected Tool dispatch preparation result for " \
+              "#{operation.execution_id}"
             )
-          )
-          return result_task
+          end
         end
+      end
 
-        preparation = runtime.offload.submit(on_full: :raise) do
-          mark_resuming!(
-            activation,
-            approval_request_id: approval_request_id,
-            approved: approved
-          )
-          activation
+      def submit_provider_dispatch_preparation_reconciliation(operation, uncertainty)
+        # simplecov:disable
+        runtime = Phronomy::Runtime.instance
+        command = ProviderDispatchPreparationReconciliationCommand.new(
+          operation: operation,
+          intended_result: uncertainty.intended_result,
+          original_error: uncertainty.original_error
+        )
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_provider_dispatch_preparation_reconciliation(command)
         end
-        preparation.on_complete do |prepared_activation, error|
-          if error
-            fail_task(result_task, translated(error))
-            next
+        task.on_complete do |result, error|
+          ready = ProviderDispatchPreparationReconciliationReady.new(
+            coordinator: self,
+            command: command,
+            result: result,
+            error: error
+          )
+          unless post_control(runtime, ready)
+            Phronomy.configuration.logger&.warn(
+              "[Phronomy] EventLoop rejected Provider dispatch reconciliation result for #{operation.execution_id}"
+            )
           end
+        end
+      rescue => error
+        mark_barrier_recovery_required(operation, error)
+        # simplecov:enable
+      end
 
-          begin
-            start_resume(
-              prepared_activation,
-              result_task,
-              approved: approved,
-              config: config
+      def submit_tool_dispatch_preparation_reconciliation(operation, uncertainty)
+        # simplecov:disable
+        runtime = Phronomy::Runtime.instance
+        command = ToolDispatchPreparationReconciliationCommand.new(
+          operation: operation,
+          intended_result: uncertainty.intended_result,
+          original_error: uncertainty.original_error
+        )
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_tool_dispatch_preparation_reconciliation(command)
+        end
+        task.on_complete do |result, error|
+          ready = ToolDispatchPreparationReconciliationReady.new(
+            coordinator: self,
+            command: command,
+            result: result,
+            error: error
+          )
+          unless post_control(runtime, ready)
+            Phronomy.configuration.logger&.warn(
+              "[Phronomy] EventLoop rejected Tool dispatch reconciliation result for #{operation.execution_id}"
             )
-          rescue => start_error
-            commit = runtime.offload.submit(on_full: :raise) do
-              commit_failed(
-                prepared_activation,
-                prepared_activation.invocation,
-                start_error
-              )
-            end
-            commit.on_complete do |terminal, commit_error|
-              if commit_error
-                fail_task(result_task, commit_error)
-              else
-                runtime.__agent_activations.delete(execution_id)
-                fail_task(result_task, terminal.fetch(:error))
-              end
-            end
           end
         end
-        result_task
       rescue => error
-        fail_task(result_task, translated(error)) if result_task
-        result_task
+        mark_barrier_recovery_required(operation, error)
+        # simplecov:enable
       end
 
-      # Persists facts from the previous Provider/Tool cycle and fixes the next
-      # Manifest from the current local Agent state. This runs on OffloadPool.
-      def prepare_next_llm_call(activation)
-        snapshot = activation.runtime_snapshot
-        root = @agent.agent_root
-        current = activation.execution
-        journal_records = @agent.send(:_journal_records_snapshot)
-        manifest = manifest_ref = updated = nil
+      # Every control message is delivered by EventLoop. This method is the only
+      # coordinator entry point allowed to advance Phronomy-managed live state.
+      # @api private
+      def deliver_on_event_loop(command)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        assert_event_loop!(event_loop)
 
-        @agent.persistence.transaction do |tx|
-          assert_local_durable_base!(tx, root)
-          encoded_records, call_records = encode_runtime_records(
-            activation,
-            tx: tx,
-            snapshot: snapshot,
-            context_candidate: true,
-            agent_root: root
-          )
-          staged = current.with(
-            execution_revision: current.execution_revision,
-            phase: :preparing_llm_call,
-            working_records: current.working_records + encoded_records,
-            llm_calls: current.llm_calls + call_records
+        case command
+        when StartCommand
+          begin_start_on_event_loop(command)
+        when InitialPreparationReady
+          apply_initial_preparation_on_event_loop(command)
+        when InitialPreparationRecoveryReady
+          apply_initial_preparation_recovery_on_event_loop(command)
+        when ProviderDispatchPreparationReady
+          apply_provider_dispatch_preparation_on_event_loop(command)
+        when ToolDispatchPreparationReady
+          apply_tool_dispatch_preparation_on_event_loop(command)
+        when ProviderDispatchPreparationReconciliationReady
+          apply_provider_dispatch_preparation_reconciliation_on_event_loop(command)
+        when ToolDispatchPreparationReconciliationReady
+          apply_tool_dispatch_preparation_reconciliation_on_event_loop(command)
+        when ResumeCommand
+          begin_resume_on_event_loop(command)
+        when ResumeCommitReady
+          apply_resume_commit_on_event_loop(command)
+        when TerminalCommitReady
+          apply_terminal_commit_on_event_loop(command)
+        when DeferredTerminalCommand
+          resume_deferred_terminal_on_event_loop(command)
+        else
+          raise Phronomy::Error, "unknown Agent control command: #{command.class}"
+        end
+      end
+
+      private
+
+      # ----------------------------------------------------------------------
+      # Initial preparation
+      # ----------------------------------------------------------------------
+
+      def begin_start_on_event_loop(request)
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        root = @agent.agent_root
+        if root.lifecycle_status == :closed
+          deliver_start_failure_on_event_loop(
+            request,
+            Phronomy::Error.new("agent is closed: #{@agent.agent_id}")
           )
-          invocation_config = activation.invocation&.config || {}
-          patch = @agent.send(
-            :run_before_llm_input_hooks,
-            call_sequence: staged.llm_calls.length + 1,
-            config: invocation_config
+          return
+        end
+
+        @agent.send(:__assert_live_agent!)
+        admitted = false
+        submitted = false
+        event_loop.admit_agent_execution(
+          @agent.agent_id,
+          owner_token: request.admission_token
+        )
+        admitted = true
+
+        # Ownership purge may begin on an application thread between the first
+        # live-owner check and EventLoop admission. Re-check after the slot is
+        # installed: once this check succeeds, purge observes the admission and
+        # must abort instead of deleting the Agent underneath this start.
+        @agent.send(:__assert_live_agent!)
+
+        operation = InitialPreparationCommand.new(
+          root: root,
+          journal_records: @agent.send(:_journal_records_snapshot),
+          input: request.input,
+          config: request.config,
+          preparation_replayable: initial_preparation_replayable?(
+            request.input,
+            request.config,
+            request.approval_policy
           )
-          manifest, manifest_ref = ContextAssembler.new(
-            agent: @agent,
-            persistence: tx,
-            policy: context_policy_for(staged),
-            journal_records: journal_records
-          ).build_followup(
-            base_manifest: activation.base_manifest,
-            agent_root: root,
-            execution: staged,
-            config: invocation_config,
-            patch: patch
-          )
-          refs = Array(staged.metadata["manifest_refs"]) + [manifest_ref]
-          updated = staged.with(
-            phase: :calling_llm,
-            metadata: staged.metadata.merge(
-              "manifest_ref" => manifest_ref,
-              "manifest_refs" => refs
+        )
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_initial_preparation(operation)
+        end
+        submitted = true
+        task.on_complete do |result, error|
+          ready = InitialPreparationReady.new(
+            coordinator: self,
+            request: request,
+            result: result,
+            error: error
+          )
+          fail_task(request.result_task, runtime_rejected_error(:initial_preparation)) unless
+            post_control(runtime, ready)
+        end
+      rescue => error
+        if admitted
+          if submitted
+            event_loop.mark_agent_admission_recovery_required(
+              @agent.agent_id,
+              owner_token: request.admission_token
             )
-          )
-          tx.executions.save(
-            current.execution_id,
-            expected_revision: current.execution_revision,
-            execution: updated
+          else
+            event_loop.release_agent_execution_admission(
+              @agent.agent_id,
+              owner_token: request.admission_token
+            )
+          end
+        end
+        deliver_start_failure_on_event_loop(request, translated(error))
+      end
+
+      def perform_initial_preparation(operation)
+        begin
+          raw_message = @agent.send(:extract_message, operation.input)
+        rescue => error
+          return InitialPreparationResult.new(
+            execution: nil,
+            root: operation.root,
+            runtime_projection: nil,
+            filtered_input: nil,
+            config: operation.config,
+            appended_records: [].freeze,
+            error: translated(error),
+            admission_outcome: :not_established
           )
         end
 
-        activation.replace_execution(updated)
-        activation.acknowledge_runtime_snapshot(snapshot)
+        begin
+          execution, active_root = admit_execution(
+            raw_message,
+            root: operation.root,
+            mode: (operation.config[:phronomy_recovery_mode] || :invoke).to_sym,
+            config: operation.config,
+            preparation_replayable: operation.preparation_replayable
+          )
+        rescue Phronomy::AgentBusyError => error
+          # A durable busy conflict proves that another nonterminal logical
+          # Execution already exists for this agent_id. Process loss does not
+          # make that execution terminal; keep Runtime admission fail-closed
+          # until ACS-15 recovery/reconciliation can establish current lineage.
+          return InitialPreparationResult.new(
+            execution: nil,
+            root: operation.root,
+            runtime_projection: nil,
+            filtered_input: nil,
+            config: operation.config,
+            appended_records: [].freeze,
+            error: translated(error),
+            admission_outcome: :recovery_required
+          )
+        rescue Phronomy::Persistence::ConflictError,
+          Phronomy::Persistence::NotFoundError,
+          Phronomy::Persistence::SerializationError,
+          ArgumentError,
+          Phronomy::ConfigurationError => error
+          return InitialPreparationResult.new(
+            execution: nil,
+            root: operation.root,
+            runtime_projection: nil,
+            filtered_input: nil,
+            config: operation.config,
+            appended_records: [].freeze,
+            error: translated(error),
+            admission_outcome: :not_established
+          )
+        rescue => error
+          return InitialPreparationResult.new(
+            execution: nil,
+            root: operation.root,
+            runtime_projection: nil,
+            filtered_input: nil,
+            config: operation.config,
+            appended_records: [].freeze,
+            error: translated(error),
+            admission_outcome: :outcome_unknown
+          )
+        end
 
-        projection = RubyLLMMaterializer.new(
-          agent: @agent,
-          persistence: @agent.persistence
-        ).materialize(manifest: manifest, manifest_ref: manifest_ref)
-        activation.replace_runtime_projection(projection)
-        projection
+        perform_admitted_initial_preparation(
+          input: operation.input,
+          config: operation.config,
+          execution: execution,
+          active_root: active_root,
+          journal_records: operation.journal_records
+        )
       end
 
-      def prepare(input, thread_id:, config:)
-        raw_message = @agent.send(:extract_message, input)
-        execution, active_root = admit_execution(
-          raw_message,
-          thread_id: thread_id
-        )
-        @agent.__replace_root(active_root)
+      def perform_admitted_initial_preparation(
+        input:,
+        config:,
+        execution:,
+        active_root:,
+        journal_records:
+      )
         current_execution = execution
-
         begin
-          effective_config = thread_id ? config.merge(thread_id: thread_id) : config
+          effective_config = config
           @agent.send(
             :check_cancellation!,
             effective_config,
@@ -215,46 +562,56 @@ module Phronomy
           )
           filtered_message = @agent.send(:extract_message, filtered_input)
           manifest = manifest_ref = active_execution = nil
-          local_journal = @agent.send(:_journal_records_snapshot)
 
-          @agent.persistence.transaction do |tx|
-            assert_local_durable_base!(tx, active_root)
-            filtered_ref = tx.contents.put_text(filtered_message)
-            input_record = JournalRecord.new(
-              agent_id: @agent.agent_id,
-              execution_id: current_execution.execution_id,
-              kind: :external_message,
-              channel: :external,
-              role: :user,
-              content_ref: filtered_ref,
-              correlation_id: thread_id,
-              context_generation: active_root.transcript_generation,
-              context_candidate: true
-            )
-            staged = current_execution.with(
-              execution_revision: current_execution.execution_revision,
-              working_records: current_execution.working_records + [input_record],
-              metadata: current_execution.metadata.merge(
-                "current_input_ref" => filtered_ref,
-                "current_input_record_id" => input_record.record_id
-              )
+          # Content-addressed source material may be written before the Policy call.
+          # No mutable Agent/Execution repository state is committed here.
+          filtered_ref = @agent.persistence.contents.put_text(filtered_message)
+          input_record = JournalRecord.new(
+            agent_id: @agent.agent_id,
+            execution_id: current_execution.execution_id,
+            kind: :external_message,
+            channel: :external,
+            role: :user,
+            content_ref: filtered_ref,
+            context_generation: active_root.transcript_generation,
+            context_candidate: true,
+            metadata: {"handoff_policy_category" => "current_request"}
+          )
+          staged = current_execution.with(
+            execution_revision: current_execution.execution_revision,
+            working_records: current_execution.working_records + [input_record],
+            metadata: current_execution.metadata.merge(
+              "current_input_ref" => filtered_ref,
+              "current_input_record_id" => input_record.record_id
             )
-            manifest, manifest_ref = ContextAssembler.new(
-              agent: @agent,
-              persistence: tx,
-              policy: context_policy_for(staged),
-              journal_records: local_journal
-            ).build_initial(
-              input: filtered_input,
-              agent_root: active_root,
-              execution: staged,
-              config: effective_config,
-              patch: @agent.send(
-                :run_before_llm_input_hooks,
-                call_sequence: 1,
-                config: effective_config
-              )
+          )
+          assembler = ContextAssembler.new(
+            agent: @agent,
+            persistence: @agent.persistence,
+            journal_records: journal_records
+          )
+          prepared = assembler.prepare_initial(
+            input: filtered_input,
+            agent_root: active_root,
+            execution: staged,
+            config: effective_config,
+            patch: @agent.send(
+              :run_before_llm_input_hooks,
+              call_sequence: 1,
+              config: effective_config
             )
+          )
+          @agent.send(
+            :check_cancellation!,
+            effective_config,
+            "invocation cancelled after context policy"
+          )
+
+          # Revalidate the durable base only after Application Policy returns.
+          # ContextPolicy never runs while this transaction is open.
+          @agent.persistence.transaction do |tx|
+            assert_local_durable_base!(tx, active_root)
+            manifest, manifest_ref = assembler.finalize(prepared, persistence: tx)
             active_execution = staged.with(
               status: :active,
               phase: :calling_llm,
@@ -276,52 +633,94 @@ module Phronomy
             agent: @agent,
             persistence: @agent.persistence
           ).materialize(manifest: manifest, manifest_ref: manifest_ref)
-          Phronomy::Agent::ExecutionCoordinator::Prepared.new(
+          InitialPreparationResult.new(
             execution: active_execution,
+            root: active_root,
             runtime_projection: projection,
             filtered_input: filtered_input,
-            config: effective_config
+            config: effective_config,
+            appended_records: [].freeze,
+            error: nil,
+            admission_outcome: :active
           )
         rescue => error
-          commit_preparation_failure(current_execution, error)
-          raise
+          failure = commit_preparation_failure(
+            current_execution,
+            active_root,
+            error
+          )
+          InitialPreparationResult.new(
+            execution: failure.fetch(:execution),
+            root: failure.fetch(:root),
+            runtime_projection: nil,
+            filtered_input: nil,
+            config: config,
+            appended_records: failure.fetch(:appended_records),
+            error: failure.fetch(:error),
+            admission_outcome: :terminal
+          )
         end
       end
 
-      def admit_execution(raw_message, thread_id:)
-        root = @agent.agent_root
-        raise Phronomy::Error, "agent is closed: #{@agent.agent_id}" if root.lifecycle_status == :closed
+      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}"
+        end
 
         execution = next_root = nil
+        mode = mode.to_sym
+        pending_llm_call_id = SecureRandom.uuid.to_s.freeze
+        pending_started_at = Time.now.utc.iso8601(6).freeze
+
         @agent.persistence.transaction do |tx|
           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,
-            correlation_id: thread_id,
             context_generation: root.transcript_generation,
             context_candidate: false
           )
-          policy_descriptor = ContextPolicies::Default.new.descriptor
           execution = AgentExecution.start(
             agent_root: root,
             input_record: input_record,
+            execution_id: config[:phronomy_reserved_execution_id] || SecureRandom.uuid,
             metadata: {
-              "thread_id" => thread_id,
+              "coordination" => config[:phronomy_coordination],
               "current_input_ref" => input_ref,
-              "context_policy" => policy_descriptor.to_h
+              "durable_context_ref" => durable_context_ref,
+              "preparation_replayable" => !!preparation_replayable,
+              RecoverySupport::CONTRACT_VERSION_KEY =>
+                RecoverySupport::CONTRACT_VERSION,
+              RecoverySupport::INVOCATION_MODE_KEY => mode.to_s,
+              RecoverySupport::PENDING_LLM_ID_KEY =>
+                pending_llm_call_id,
+              RecoverySupport::PENDING_LLM_STARTED_AT_KEY =>
+                pending_started_at
             }.compact
           )
           input_record = JournalRecord.from_h(
-            input_record.to_h.merge("execution_id" => execution.execution_id)
+            input_record.to_h.merge(
+              "execution_id" => execution.execution_id
+            )
           )
           execution = execution.with(
             execution_revision: 0,
             working_records: [input_record]
           )
+          validate_coordination_admission!(tx, execution)
           tx.executions.create_active(execution)
           next_root = root.with(
             agent_revision: root.agent_revision + 1,
@@ -336,9 +735,70 @@ module Phronomy
         [execution, next_root]
       end
 
-      def commit_preparation_failure(execution, error)
+      def validate_coordination_admission!(tx, execution)
+        owner = execution.metadata["coordination"]
+        return unless owner
+        case owner.fetch("kind")
+        when "team"
+          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::Persistence::ConflictError, "Team reserved child identity mismatch"
+          end
+        when "subagent"
+          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::Persistence::ConflictError, "Parent reserved child identity mismatch"
+          end
+        when "handoff"
+          routing = tx.handoff_states.load(owner.fetch("main_agent_id"))
+          unless routing && routing.active_agent_id == execution.agent_id
+            raise Phronomy::Persistence::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::Persistence::ConflictError, "Handoff reserved Target identity mismatch"
+          end
+        else
+          raise Phronomy::ConfigurationError, "Unknown coordination owner kind"
+        end
+      end
+
+      def initial_preparation_replayable?(input, config, approval_policy)
+        return false unless input.is_a?(String)
+        return false unless approval_policy.nil?
+        if config.key?(:phronomy_handoff_bindings) ||
+            config.key?(:phronomy_handoff_context)
+          return false unless config[:phronomy_coordination]&.fetch("kind", nil) == "handoff"
+        end
+
+        invocation_context = config[:invocation_context]
+        return true unless invocation_context
+
+        %i[approval_policy redaction_policy token_budget].none? do |name|
+          invocation_context.respond_to?(name) &&
+            !invocation_context.public_send(name).nil?
+        end
+      end
+
+      def commit_preparation_failure(execution, root, error)
         translated_error = translated(error)
-        root = @agent.agent_root
         failed = next_root = appended = nil
 
         @agent.persistence.transaction do |tx|
@@ -389,24 +849,95 @@ module Phronomy
             root: next_root
           )
         end
-        @agent.send(:_append_journal_records, appended)
-        @agent.__replace_root(next_root)
-        failed
+        {
+          error: translated_error,
+          execution: failed,
+          root: next_root,
+          appended_records: Array(appended).freeze
+        }.freeze
       end
 
-      def register(prepared, result_task, mode:, approval_policy:, approval_listener:, on_event:)
-        activation = AgentExecutionActivation.new(
-          execution: prepared.execution,
-          agent: @agent,
-          runtime_projection: prepared.runtime_projection,
-          coordinator: self,
-          application_listener: on_event
+      def apply_initial_preparation_on_event_loop(ready)
+        request = ready.request
+        event_loop = Phronomy::Runtime.instance.event_loop
+        if ready.error
+          event_loop.mark_agent_admission_recovery_required(
+            @agent.agent_id,
+            owner_token: request.admission_token
+          )
+          deliver_start_failure_on_event_loop(request, translated(ready.error))
+          return
+        end
+
+        result = ready.result
+        case result.admission_outcome
+        when :not_established
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            owner_token: request.admission_token
+          )
+          deliver_start_failure_on_event_loop(request, result.error)
+          return
+        when :outcome_unknown, :recovery_required
+          event_loop.mark_agent_admission_recovery_required(
+            @agent.agent_id,
+            owner_token: request.admission_token
+          )
+          deliver_start_failure_on_event_loop(request, result.error)
+          return
+        when :active, :terminal
+          event_loop.bind_agent_execution_admission(
+            @agent.agent_id,
+            owner_token: request.admission_token,
+            execution_id: result.execution.execution_id
+          )
+        else
+          event_loop.mark_agent_admission_recovery_required(
+            @agent.agent_id,
+            owner_token: request.admission_token
+          )
+          raise Phronomy::Error,
+            "unknown initial admission outcome: #{result.admission_outcome.inspect}"
+        end
+
+        apply_agent_live_state(
+          root: result.root,
+          appended_records: result.appended_records
+        )
+        if result.admission_outcome == :terminal
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: result.execution.execution_id
+          )
+          deliver_start_failure_on_event_loop(request, result.error)
+          return
+        end
+
+        register_initial_session_on_event_loop(request, result)
+      rescue => error
+        # Preparation may already be durably active. Terminalize through another
+        # offloaded durable operation rather than releasing the admission blindly.
+        begin_terminal_without_session_on_event_loop(
+          request: request,
+          prepared: ready.result,
+          error: error
         )
+      end
+
+      def register_initial_session_on_event_loop(request, prepared)
         runtime = Phronomy::Runtime.instance
-        runtime.__agent_activations.register(activation)
         event_loop = runtime.event_loop
+        Phronomy::Tracing::Automatic.observe_task(
+          request.result_task,
+          "agent.execution",
+          input: request.input,
+          agent_id: @agent.agent_id,
+          execution_id: prepared.execution.execution_id,
+          mode: request.mode,
+          **@agent.send(:_build_caller_meta, prepared.config)
+        )
         effective_config = prepared.config.merge(
-          phronomy_activation: activation,
+          phronomy_execution_coordinator: self,
           phronomy_runtime_projection: prepared.runtime_projection,
           phronomy_filtered_input: prepared.filtered_input,
           execution_id: prepared.execution.execution_id
@@ -415,128 +946,1384 @@ module Phronomy
           agent: @agent,
           input: prepared.filtered_input,
           config: effective_config,
-          approval_policy: approval_policy,
-          approval_listener: approval_listener,
-          mode: mode,
-          on_event: ->(event) { activation.record_event(event) },
+          approval_policy: request.approval_policy,
+          approval_listener: request.approval_listener,
+          mode: request.mode,
+          on_event: request.on_event,
           runtime: runtime
         )
-        activation.invocation = session.context
-        activation.session = session
-        source_task = Phronomy::Task.deferred(name: "#{result_task.name}-source")
+        event_loop.install_agent_execution(
+          execution_id: prepared.execution.execution_id,
+          agent: @agent,
+          coordinator: self,
+          execution: prepared.execution,
+          runtime_projection: prepared.runtime_projection,
+          base_manifest: prepared.runtime_projection.manifest,
+          invocation: session.context,
+          fsm_session_id: session.id
+        )
+        event_loop.register_agent_completion_waiter(
+          prepared.execution.execution_id,
+          request.result_task
+        )
+        source_task = Phronomy::Task.deferred(name: "#{request.result_task.name}-source")
         source_task.on_complete do |invocation, error|
-          finish(
-            activation,
-            result_task,
+          finish_on_event_loop(
+            prepared.execution.execution_id,
+            request.result_task,
             invocation || session.context,
-            error
+            error,
+            fsm_session_id: session.id
           )
         end
         event_loop.register(session, completion: source_task)
-      rescue => error
-        activation ||= AgentExecutionActivation.new(
-          execution: prepared.execution,
-          agent: @agent,
-          runtime_projection: prepared.runtime_projection,
-          coordinator: self,
-          application_listener: on_event
-        )
-        finish(activation, result_task, activation.invocation, error)
+      # simplecov:disable
+      rescue => _error
+        event_loop&.release_agent_execution(prepared.execution.execution_id) if
+          event_loop&.current? && event_loop.agent_execution_state(prepared.execution.execution_id)
+        raise
       end
+      # simplecov:enable
 
-      def finish(activation, result_task, invocation, error)
+      def deliver_start_failure_on_event_loop(request, error)
+        callback_error = @agent.send(
+          :_deliver_stream_event,
+          request.on_event,
+          StreamEvent.new(
+            type: terminal_event_type(error),
+            payload: {error: error}
+          )
+        )
+        settle_after_terminal(
+          request.result_task,
+          callback_error,
+          terminal_event_type(error),
+          nil,
+          error
+        )
+      end
+
+      # Restarts only the replay-safe initial preparation region of an already
+      # durably admitted logical Execution. Runtime-only caller state is not
+      # reconstructed here; the durable preparation inputs are authoritative.
+      # @api private
+      def start_initial_preparation_recovery_on_event_loop(
+        execution,
+        result_task,
+        load_completion:
+      )
         runtime = Phronomy::Runtime.instance
-        operation = runtime.offload.submit(on_full: :raise) do
-          compute_terminal(activation, invocation, error)
-        end
-        operation.on_complete do |outcome, commit_error|
-          command = AgentTerminalCommand.new(
-            self, activation, result_task, outcome, commit_error
-          )
-          posted = runtime.event_loop.post(
-            Phronomy::Event.new(
-              type: :agent_terminal_ready,
-              target_id: Phronomy::EventLoop::SYSTEM_CHANNEL_ID,
-              payload: {command: command}
-            )
+        event_loop = runtime.event_loop
+        assert_event_loop!(event_loop)
+        state = event_loop.agent_execution_state(execution.execution_id)
+        unless state && state.agent.equal?(@agent) &&
+            state.execution.execution_revision == execution.execution_revision &&
+            state.execution.status == :preparing &&
+            state.execution.phase.to_sym == :preparing
+          error = Phronomy::ExecutionRehydrationRequiredError.new(
+            "stale :preparing Recovery installation for #{execution.execution_id}"
+          )
+          fail_task(result_task, error)
+          load_completion.fail(error)
+          return
+        end
+
+        root = @agent.agent_root
+        journal_records = @agent.send(:_journal_records_snapshot)
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_initial_preparation_recovery(
+            execution,
+            root: root,
+            journal_records: journal_records
           )
-          unless posted
-            settle_without_listener(
-              activation, result_task, outcome, commit_error
+        end
+        task.on_complete do |result, error|
+          ready = InitialPreparationRecoveryReady.new(
+            coordinator: self,
+            execution_id: execution.execution_id.to_s.freeze,
+            expected_execution_revision: execution.execution_revision,
+            result_task: result_task,
+            load_completion: load_completion,
+            result: result,
+            error: error
+          )
+          unless post_control(runtime, ready)
+            rejected = runtime_rejected_error(:initial_preparation_recovery)
+            fail_task(result_task, rejected)
+            load_completion.fail(rejected)
+          end
+        end
+      rescue => error
+        # simplecov:disable
+        begin
+          if defined?(event_loop) && event_loop.current?
+            release_initial_preparation_recovery_runtime_state(
+              event_loop,
+              execution.execution_id
             )
           end
+        rescue
+          nil
         end
-      rescue => caught
-        fail_task(result_task, translated(caught))
+        translated_error = translated(error)
+        fail_task(result_task, translated_error)
+        load_completion.fail(translated_error)
+        # simplecov:enable
       end
 
-      public
+      def perform_initial_preparation_recovery(
+        execution,
+        root:,
+        journal_records:
+      )
+        unless execution.metadata["preparation_replayable"] == true
+          raise Phronomy::ExecutionRehydrationRequiredError,
+            "execution #{execution.execution_id} has no replay-safe initial preparation contract"
+        end
 
-      def deliver_on_event_loop(command)
-        case command
-        when PrepFailureCommand
-          callback_error = @agent.send(
-            :_deliver_stream_event,
-            command.on_event_listener,
-            StreamEvent.new(
-              type: terminal_event_type(command.error),
-              payload: {error: command.error}
-            )
+        input_ref = execution.metadata.fetch("current_input_ref")
+        input = @agent.persistence.contents.fetch_text(input_ref)
+        mode = (
+          execution.metadata[RecoverySupport::INVOCATION_MODE_KEY] || "invoke"
+        ).to_sym
+        config = {phronomy_recovery_mode: mode}.merge(@agent.__coordination_config)
+
+        if execution.metadata.key?("durable_context_ref")
+          durable_context_ref = execution.metadata.fetch("durable_context_ref")
+          durable_context = @agent.persistence.contents.fetch_json(
+            durable_context_ref
+          )
+          unless durable_context.is_a?(Hash)
+            raise Phronomy::ExecutionRehydrationRequiredError,
+              "execution #{execution.execution_id} has a non-Hash durable_context"
+          end
+          Phronomy::Agent::Immutable.validate_canonical_json!(
+            durable_context,
+            label: "Recovered durable_context"
+          )
+          config[:durable_context] =
+            Phronomy::Agent::Immutable.copy(durable_context)
+        end
+
+        perform_admitted_initial_preparation(
+          input: input,
+          config: config.freeze,
+          execution: execution,
+          active_root: root,
+          journal_records: journal_records
+        )
+      end
+
+      def apply_initial_preparation_recovery_on_event_loop(ready)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(ready.execution_id)
+        unless state && state.agent.equal?(@agent) &&
+            state.execution.execution_revision == ready.expected_execution_revision &&
+            state.execution.status == :preparing &&
+            state.execution.phase.to_sym == :preparing
+          error = Phronomy::ExecutionRehydrationRequiredError.new(
+            "stale initial preparation Recovery result for #{ready.execution_id}"
+          )
+          fail_task(ready.result_task, error)
+          ready.load_completion.fail(error)
+          return
+        end
+
+        if ready.error
+          release_initial_preparation_recovery_runtime_state(
+            event_loop,
+            ready.execution_id
+          )
+          error = translated(ready.error)
+          fail_task(ready.result_task, error)
+          ready.load_completion.fail(error)
+          return
+        end
+
+        result = ready.result
+        case result.admission_outcome
+        when :terminal
+          apply_agent_live_state(
+            root: result.root,
+            appended_records: result.appended_records
+          )
+          event_loop.replace_agent_execution(
+            ready.execution_id,
+            execution: result.execution
+          )
+          event_loop.release_agent_execution(ready.execution_id)
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: ready.execution_id
+          )
+          event_type = terminal_event_type(result.error)
+          callback_error = deliver_terminal(
+            @agent.send(:_phronomy_event_listener),
+            event_type,
+            error: result.error
           )
           settle_after_terminal(
-            command.result_task,
+            ready.result_task,
             callback_error,
-            terminal_event_type(command.error),
+            event_type,
             nil,
-            command.error
+            result.error
+          )
+          ready.load_completion.complete(@agent)
+        when :active
+          apply_agent_live_state(
+            root: result.root,
+            appended_records: result.appended_records
+          )
+          event_loop.release_agent_execution(ready.execution_id)
+          mode = (
+            result.execution.metadata[RecoverySupport::INVOCATION_MODE_KEY] ||
+              "invoke"
+          ).to_sym
+          request = StartCommand.new(
+            coordinator: self,
+            input: result.filtered_input,
+            config: result.config,
+            mode: mode,
+            approval_policy: nil,
+            approval_listener: nil,
+            on_event: @agent.send(:_phronomy_event_listener),
+            result_task: ready.result_task,
+            admission_token: Object.new.freeze
           )
-        when AgentTerminalCommand
-          deliver_execution_terminal(command)
+          begin
+            register_initial_session_on_event_loop(request, result)
+          rescue => error
+            begin_terminal_without_session_on_event_loop(
+              request: request,
+              prepared: result,
+              error: error
+            )
+          end
+          ready.load_completion.complete(@agent)
         else
-          raise Phronomy::Error, "unknown terminal command: #{command.class}"
+          error = Phronomy::ExecutionRehydrationRequiredError.new(
+            "unexpected initial preparation Recovery outcome: #{result.admission_outcome.inspect}"
+          )
+          release_initial_preparation_recovery_runtime_state(
+            event_loop,
+            ready.execution_id
+          )
+          fail_task(ready.result_task, error)
+          ready.load_completion.fail(error)
+        end
+      rescue => error
+        # simplecov:disable
+        begin
+          release_initial_preparation_recovery_runtime_state(
+            event_loop,
+            ready.execution_id
+          )
+        rescue
+          nil
+        end
+        translated_error = translated(error)
+        fail_task(ready.result_task, translated_error)
+        ready.load_completion.fail(translated_error)
+        # simplecov:enable
+      end
+
+      def release_initial_preparation_recovery_runtime_state(
+        event_loop,
+        execution_id
+      )
+        state = event_loop.agent_execution_state(execution_id)
+        event_loop.release_agent_execution(execution_id) if state
+        event_loop.release_agent_execution_admission(
+          @agent.agent_id,
+          execution_id: execution_id
+        )
+      end
+
+      # ----------------------------------------------------------------------
+      # External-operation causal durable barriers
+      # ----------------------------------------------------------------------
+
+      def perform_provider_dispatch_preparation(operation)
+        metadata = operation.execution.metadata.dup
+        metadata.delete(RecoverySupport::TOOL_BATCH_METADATA_KEY)
+        metadata.delete(RecoverySupport::RECOVERY_METADATA_KEY)
+        metadata[RecoverySupport::PENDING_LLM_ID_KEY] =
+          operation.pending_llm_call_id
+        metadata[RecoverySupport::PENDING_LLM_STARTED_AT_KEY] =
+          operation.pending_llm_started_at
+        metadata[RecoverySupport::CONTRACT_VERSION_KEY] =
+          RecoverySupport::CONTRACT_VERSION
+        staged_execution = operation.execution.with(
+          execution_revision: operation.execution.execution_revision,
+          metadata: metadata
+        )
+
+        manifest = manifest_ref = updated = intended = nil
+
+        # Encode the immutable runtime snapshot first. This transaction may add
+        # content-addressed blobs, but it does not advance Execution state.
+        encoded_records = call_records = nil
+        @agent.persistence.transaction do |tx|
+          assert_local_durable_base!(tx, operation.root)
+          encoded_records, call_records = encode_runtime_records(
+            staged_execution,
+            tx: tx,
+            snapshot: operation.runtime_snapshot,
+            context_candidate: true,
+            agent_root: operation.root
+          )
+        end
+        staged = staged_execution.with(
+          execution_revision: staged_execution.execution_revision,
+          phase: :preparing_llm_call,
+          working_records: staged_execution.working_records + encoded_records,
+          llm_calls: staged_execution.llm_calls + call_records
+        )
+        patch = @agent.send(
+          :run_before_llm_input_hooks,
+          call_sequence: staged.llm_calls.length + 1,
+          config: operation.invocation_config
+        )
+        assembler = ContextAssembler.new(
+          agent: @agent,
+          persistence: @agent.persistence,
+          journal_records: operation.journal_records
+        )
+        prepared = assembler.prepare_followup(
+          base_manifest: operation.base_manifest,
+          agent_root: operation.root,
+          execution: staged,
+          config: operation.invocation_config,
+          patch: patch
+        )
+        @agent.send(
+          :check_cancellation!,
+          operation.invocation_config,
+          "invocation cancelled after context policy"
+        )
+
+        begin
+          @agent.persistence.transaction do |tx|
+            assert_local_durable_base!(tx, operation.root)
+            manifest, manifest_ref = assembler.finalize(prepared, persistence: tx)
+            refs = Array(staged.metadata["manifest_refs"]) + [manifest_ref]
+            updated = staged.with(
+              phase: :calling_llm,
+              metadata: staged.metadata.merge(
+                "manifest_ref" => manifest_ref,
+                "manifest_refs" => refs
+              )
+            )
+            updated = @agent.__prepare_coordination_record(updated, tx: tx)
+            tx.executions.save(
+              operation.execution.execution_id,
+              expected_revision: operation.execution.execution_revision,
+              execution: updated
+            )
+            intended = ProviderDispatchPreparationResult.new(
+              execution: updated,
+              runtime_projection: nil,
+              error: nil
+            )
+          end
+        rescue => caught
+          raise if known_durable_preparation_failure?(caught) || intended.nil?
+
+          raise PreparationOutcomeUnknownError.new(caught, intended)
+        end
+
+        projection = materialization_error = nil
+        begin
+          projection = RubyLLMMaterializer.new(
+            agent: @agent,
+            persistence: @agent.persistence
+          ).materialize(manifest: manifest, manifest_ref: manifest_ref)
+        rescue => error
+          materialization_error = error
         end
+        ProviderDispatchPreparationResult.new(
+          execution: updated,
+          runtime_projection: projection,
+          error: materialization_error
+        )
       end
 
-      private
+      def perform_tool_dispatch_preparation(operation)
+        intended = nil
+        begin
+          @agent.persistence.transaction do |tx|
+            assert_local_durable_base!(tx, operation.root)
+            encoded_records, call_records = encode_runtime_records(
+              operation.execution,
+              tx: tx,
+              snapshot: operation.runtime_snapshot,
+              context_candidate: true,
+              agent_root: operation.root
+            )
+            metadata = operation.execution.metadata.dup
+            metadata.delete(RecoverySupport::PENDING_LLM_ID_KEY)
+            metadata.delete(RecoverySupport::PENDING_LLM_STARTED_AT_KEY)
+            metadata.delete(RecoverySupport::RECOVERY_METADATA_KEY)
+            metadata.delete("framework_calls_pending")
+            metadata[RecoverySupport::TOOL_BATCH_METADATA_KEY] =
+              RecoverySupport.canonical_copy(operation.tool_batch_snapshot)
+            metadata[RecoverySupport::CONTRACT_VERSION_KEY] =
+              RecoverySupport::CONTRACT_VERSION
+            updated = operation.execution.with(
+              phase: :dispatching_tools,
+              working_records: operation.execution.working_records + encoded_records,
+              llm_calls: operation.execution.llm_calls + call_records,
+              metadata: metadata
+            )
+            updated = @agent.__prepare_coordination_record(updated, tx: tx)
+            tx.executions.save(
+              operation.execution.execution_id,
+              expected_revision: operation.execution.execution_revision,
+              execution: updated
+            )
+            intended = ToolDispatchPreparationResult.new(execution: updated)
+          end
+        rescue => caught
+          raise if known_durable_preparation_failure?(caught) || intended.nil?
+
+          raise PreparationOutcomeUnknownError.new(caught, intended)
+        end
+        intended
+      end
+
+      def apply_provider_dispatch_preparation_on_event_loop(ready)
+        operation = ready.operation
+        state = authoritative_state_for_operation(
+          execution_id: operation.execution_id,
+          fsm_session_id: operation.fsm_session_id,
+          expected_execution_revision: operation.expected_execution_revision,
+          expected_fsm_state: :calling_llm
+        )
+        return unless state
+
+        if ready.error
+          if ready.error.is_a?(PreparationOutcomeUnknownError)
+            submit_provider_dispatch_preparation_reconciliation(
+              operation,
+              ready.error
+            )
+          else
+            state.invocation.event_sink.post(:llm_setup_failed, translated(ready.error))
+          end
+          return
+        end
+
+        apply_confirmed_provider_dispatch_preparation_on_event_loop(
+          operation,
+          ready.result,
+          state
+        )
+      rescue => error
+        state&.invocation&.event_sink&.post(:llm_setup_failed, translated(error))
+      end
+
+      def apply_tool_dispatch_preparation_on_event_loop(ready)
+        operation = ready.operation
+        state = authoritative_state_for_operation(
+          execution_id: operation.execution_id,
+          fsm_session_id: operation.fsm_session_id,
+          expected_execution_revision: operation.expected_execution_revision,
+          expected_fsm_state: :dispatching_tools
+        )
+        return unless state
+
+        if ready.error
+          if ready.error.is_a?(PreparationOutcomeUnknownError)
+            submit_tool_dispatch_preparation_reconciliation(
+              operation,
+              ready.error
+            )
+          else
+            state.invocation.event_sink.post(:tool_setup_failed, translated(ready.error))
+          end
+          return
+        end
+
+        apply_confirmed_tool_dispatch_preparation_on_event_loop(
+          operation,
+          ready.result,
+          state
+        )
+      rescue => error
+        state&.invocation&.event_sink&.post(:tool_setup_failed, translated(error))
+      end
+
+      def apply_confirmed_provider_dispatch_preparation_on_event_loop(
+        operation,
+        result,
+        state
+      )
+        event_loop = Phronomy::Runtime.instance.event_loop
+        if result.runtime_projection
+          event_loop.replace_agent_execution(
+            operation.execution_id,
+            execution: result.execution,
+            runtime_projection: result.runtime_projection
+          )
+        else
+          event_loop.replace_agent_execution(
+            operation.execution_id,
+            execution: result.execution
+          )
+        end
+        state.invocation.acknowledge_runtime_snapshot(operation.runtime_snapshot)
+
+        if result.error
+          state.invocation.event_sink.post(:llm_setup_failed, translated(result.error))
+          return
+        end
+
+        Agent::AgentInvocationSessionBuilder.start_prepared_provider_call(
+          agent: @agent,
+          runtime: Phronomy::Runtime.instance,
+          event_sink: state.invocation.event_sink,
+          invocation: state.invocation,
+          projection: result.runtime_projection,
+          streaming: operation.streaming
+        )
+      end
+
+      def apply_confirmed_tool_dispatch_preparation_on_event_loop(
+        operation,
+        result,
+        state
+      )
+        event_loop = Phronomy::Runtime.instance.event_loop
+        event_loop.replace_agent_execution(
+          operation.execution_id,
+          execution: result.execution
+        )
+        state.invocation.acknowledge_runtime_snapshot(operation.runtime_snapshot)
+        Agent::AgentInvocationSessionBuilder.start_prepared_tool_dispatch(
+          runtime: Phronomy::Runtime.instance,
+          event_sink: state.invocation.event_sink,
+          invocation: state.invocation
+        )
+      end
+
+      def perform_provider_dispatch_preparation_reconciliation(command)
+        # simplecov:disable
+        disposition, current = preparation_reconciliation_state(
+          command.operation,
+          command.intended_result.execution
+        )
+        preparation_result = nil
+        if disposition == :committed
+          projection = materialization_error = nil
+          begin
+            _manifest, projection = RecoverySupport.materialize_projection(
+              @agent,
+              current.metadata.fetch("manifest_ref")
+            )
+          rescue => error
+            materialization_error = error
+          end
+          preparation_result = ProviderDispatchPreparationResult.new(
+            execution: current,
+            runtime_projection: projection,
+            error: materialization_error
+          )
+        end
+        ProviderDispatchPreparationReconciliationResult.new(
+          disposition: disposition,
+          preparation_result: preparation_result
+        )
+      end
+
+      def perform_tool_dispatch_preparation_reconciliation(command)
+        disposition, current = preparation_reconciliation_state(
+          command.operation,
+          command.intended_result.execution
+        )
+        preparation_result = if disposition == :committed
+          ToolDispatchPreparationResult.new(execution: current)
+        end
+        ToolDispatchPreparationReconciliationResult.new(
+          disposition: disposition,
+          preparation_result: preparation_result
+        )
+      end
+
+      def apply_provider_dispatch_preparation_reconciliation_on_event_loop(ready)
+        command = ready.command
+        operation = command.operation
+        state = authoritative_state_for_operation(
+          execution_id: operation.execution_id,
+          fsm_session_id: operation.fsm_session_id,
+          expected_execution_revision: operation.expected_execution_revision,
+          expected_fsm_state: :calling_llm
+        )
+        return unless state
+
+        if ready.error
+          mark_barrier_recovery_required(operation, ready.error)
+          return
+        end
+
+        case ready.result.disposition
+        when :committed
+          apply_confirmed_provider_dispatch_preparation_on_event_loop(
+            operation,
+            ready.result.preparation_result,
+            state
+          )
+        when :not_committed
+          state.invocation.event_sink.post(
+            :llm_setup_failed,
+            translated(command.original_error)
+          )
+        when :conflict
+          mark_barrier_recovery_required(operation, command.original_error)
+        else
+          raise Phronomy::Error,
+            "unknown Provider dispatch reconciliation disposition: " \
+            "#{ready.result.disposition.inspect}"
+        end
+      rescue => error
+        mark_barrier_recovery_required(operation, error)
+      end
+
+      def apply_tool_dispatch_preparation_reconciliation_on_event_loop(ready)
+        command = ready.command
+        operation = command.operation
+        state = authoritative_state_for_operation(
+          execution_id: operation.execution_id,
+          fsm_session_id: operation.fsm_session_id,
+          expected_execution_revision: operation.expected_execution_revision,
+          expected_fsm_state: :dispatching_tools
+        )
+        return unless state
+
+        if ready.error
+          mark_barrier_recovery_required(operation, ready.error)
+          return
+        end
+
+        case ready.result.disposition
+        when :committed
+          apply_confirmed_tool_dispatch_preparation_on_event_loop(
+            operation,
+            ready.result.preparation_result,
+            state
+          )
+        when :not_committed
+          state.invocation.event_sink.post(
+            :tool_setup_failed,
+            translated(command.original_error)
+          )
+        when :conflict
+          mark_barrier_recovery_required(operation, command.original_error)
+        else
+          raise Phronomy::Error,
+            "unknown Tool dispatch reconciliation disposition: " \
+            "#{ready.result.disposition.inspect}"
+        end
+      rescue => error
+        mark_barrier_recovery_required(operation, error)
+        # simplecov:enable
+      end
+
+      # Worker-only Persistence readback for causal-barrier F1 reconciliation.
+      # EventLoop submits one operation-specific ReconciliationCommand and only
+      # applies this result after it returns through the normal control path.
+      def preparation_reconciliation_state(operation, intended_execution)
+        current = @agent.persistence.executions.load(operation.execution_id)
+        if current.execution_revision == intended_execution.execution_revision &&
+            current.to_h == intended_execution.to_h
+          return [:committed, current]
+        end
+        if current.execution_revision == operation.execution.execution_revision &&
+            current.to_h == operation.execution.to_h
+          return [:not_committed, current]
+        end
+
+        [:conflict, current]
+      end
+
+      def known_durable_preparation_failure?(error)
+        error.is_a?(Phronomy::Persistence::ConflictError) ||
+          error.is_a?(Phronomy::Persistence::NotFoundError) ||
+          error.is_a?(Phronomy::Persistence::SerializationError) ||
+          error.is_a?(Phronomy::Persistence::UnsupportedBackendError) ||
+          error.is_a?(ArgumentError) ||
+          error.is_a?(Phronomy::ConfigurationError)
+      end
+
+      def mark_barrier_recovery_required(operation, error)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        event_loop.mark_agent_execution_admission(
+          @agent.agent_id,
+          execution_id: operation.execution_id,
+          state: :recovery_required
+        )
+        Phronomy.configuration.logger&.warn(
+          "[Phronomy] causal durable barrier requires recovery for " \
+          "#{operation.execution_id}: #{error.class}: #{error.message}"
+        )
+      end
+
+      # ----------------------------------------------------------------------
+      # Approval resume
+      # ----------------------------------------------------------------------
+
+      def begin_resume_on_event_loop(request)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(request.execution_id)
+        if state&.agent&.equal?(@agent) && state&.invocation
+          @recovery_resume_snapshot_mutex ||= Mutex.new
+          snapshot = RecoverySupport.build_tool_batch_snapshot(
+            state.invocation
+          )
+          @recovery_resume_snapshot_mutex.synchronize do
+            @recovery_resume_snapshots ||= {}
+            @recovery_resume_snapshots[request.execution_id.to_s] =
+              snapshot
+          end
+        end
+
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        state = event_loop.agent_execution_state(request.execution_id)
+        unless state
+          fail_task(
+            request.result_task,
+            Phronomy::ExecutionRehydrationRequiredError.new(
+              "no live execution owner for #{request.execution_id}; durable rehydration is required"
+            )
+          )
+          return
+        end
+
+        unless state.agent.equal?(@agent) && state.execution.status == :suspended
+          fail_task(
+            request.result_task,
+            ArgumentError.new(
+              "execution is not a suspended execution of this agent: #{request.execution_id}"
+            )
+          )
+          return
+        end
+
+        approval = state.execution.approval_request || {}
+        current_request_id = approval["id"] || approval[:id]
+        unless current_request_id.to_s == request.approval_request_id
+          fail_task(
+            request.result_task,
+            ArgumentError.new(
+              "approval request does not match execution #{request.execution_id}"
+            )
+          )
+          return
+        end
+
+        operation = ResumeCommitCommand.new(
+          execution_id: state.execution_id,
+          expected_execution_revision: state.execution.execution_revision,
+          root: @agent.agent_root,
+          execution: state.execution,
+          approval_request_id: request.approval_request_id,
+          approved: request.approved
+        )
+        resume_transition_started = false
+        submitted = false
+        event_loop.mark_agent_execution_admission(
+          @agent.agent_id,
+          execution_id: state.execution_id,
+          state: :resuming
+        )
+        resume_transition_started = true
+        task = runtime.offload.submit(on_full: :raise) do
+          perform_resume_commit(operation)
+        end
+        submitted = true
+        task.on_complete do |result, error|
+          ready = ResumeCommitReady.new(
+            coordinator: self,
+            request: request,
+            operation: operation,
+            result: result,
+            error: error
+          )
+          fail_task(request.result_task, runtime_rejected_error(:resume_commit)) unless
+            post_control(runtime, ready)
+        end
+      rescue => error
+        if resume_transition_started
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: state.execution_id,
+            state: submitted ? :recovery_required : :suspended
+          )
+        end
+        fail_task(request.result_task, translated(error))
+        raise unless resume_transition_started
+      end
+
+      def perform_resume_commit(operation)
+        snapshot = nil
+        @recovery_resume_snapshot_mutex&.synchronize do
+          snapshot = @recovery_resume_snapshots&.delete(
+            operation.execution_id.to_s
+          )
+        end
+
+        if snapshot
+          staged_execution = RecoverySupport.with_recovery_metadata(
+            operation.execution,
+            RecoverySupport::TOOL_BATCH_METADATA_KEY => snapshot
+          )
+          operation = operation.class.new(
+            **operation.to_h.merge(execution: staged_execution)
+          )
+        end
+
+        current = operation.execution
+        current_root = operation.root
+        request = current.approval_request || {}
+        request_id = request["id"] || request[:id]
+        unless request_id.to_s == operation.approval_request_id
+          raise ArgumentError,
+            "approval request does not match execution #{current.execution_id}"
+        end
+
+        updated = next_root = nil
+        @agent.persistence.transaction do |tx|
+          decision_ref = tx.contents.put_json(
+            "approval_request_id" => request_id.to_s,
+            "approved" => operation.approved
+          )
+          decision_record = JournalRecord.new(
+            agent_id: @agent.agent_id,
+            execution_id: current.execution_id,
+            kind: :approval_decided,
+            channel: :approval,
+            content_ref: decision_ref,
+            context_generation: current_root.transcript_generation,
+            context_candidate: false
+          )
+          updated = current.with(
+            status: :active,
+            phase: :resuming,
+            working_records: current.working_records + [decision_record],
+            approval_request: request.merge("approved" => operation.approved)
+          )
+          tx.executions.save(
+            current.execution_id,
+            expected_revision: current.execution_revision,
+            execution: updated
+          )
+          next_root = current_root.with(
+            agent_revision: current_root.agent_revision + 1,
+            lifecycle_status: :active
+          )
+          tx.agents.save(
+            current_root.agent_id,
+            expected_revision: current_root.agent_revision,
+            root: next_root
+          )
+        end
+        ResumeCommitResult.new(execution: updated, root: next_root)
+      end
+
+      def apply_resume_commit_on_event_loop(ready)
+        request = ready.request
+        operation = ready.operation
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(operation.execution_id)
+        unless state && state.agent.equal?(@agent) &&
+            state.execution.execution_revision == operation.expected_execution_revision &&
+            state.execution.status == :suspended
+          fail_task(
+            request.result_task,
+            Phronomy::Error.new(
+              "stale approval resume result for #{operation.execution_id}"
+            )
+          )
+          return
+        end
+
+        if ready.error
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id,
+            state: :recovery_required
+          )
+          fail_task(request.result_task, translated(ready.error))
+          return
+        end
+
+        apply_agent_live_state(root: ready.result.root, appended_records: [])
+        event_loop.mark_agent_execution_admission(
+          @agent.agent_id,
+          execution_id: operation.execution_id,
+          state: :executing
+        )
+        event_loop.replace_agent_execution(
+          operation.execution_id,
+          execution: ready.result.execution
+        )
+        event_loop.register_agent_completion_waiter(
+          operation.execution_id,
+          request.result_task
+        )
+        trace_config = state.invocation ?
+          state.invocation.config.merge(request.config) : request.config
+        trace_mode = state.invocation&.mode ||
+          (
+            ready.result.execution.metadata[
+              RecoverySupport::INVOCATION_MODE_KEY
+            ] || "invoke"
+          ).to_sym
+        Phronomy::Tracing::Automatic.observe_task(
+          request.result_task,
+          "agent.execution",
+          agent_id: @agent.agent_id,
+          execution_id: operation.execution_id,
+          mode: trace_mode,
+          **@agent.send(:_build_caller_meta, trace_config)
+        )
+        start_resume_on_event_loop(
+          operation.execution_id,
+          request.result_task,
+          approved: request.approved,
+          config: request.config
+        )
+      rescue => error
+        state = event_loop&.agent_execution_state(operation.execution_id) if event_loop&.current?
+        if state
+          begin_terminal_commit_on_event_loop(
+            state,
+            request.result_task,
+            state.invocation,
+            error,
+            fsm_session_id: state.fsm_session_id
+          )
+        else
+          fail_task(request.result_task, translated(error))
+        end
+      end
+
+      def start_resume_on_event_loop(execution_id, result_task, approved:, config:)
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        state = event_loop.agent_execution_state(execution_id)
+        invocation = state.invocation
+        invocation.merge_config!(config)
+        invocation.begin_approval_resume!(approved: approved)
+        parent_session = Agent::AgentInvocationSessionBuilder.build_for_resume(
+          agent_invocation: invocation,
+          resume_event: :resume,
+          resume_phase: :suspended,
+          runtime: runtime
+        )
+        event_loop.replace_agent_execution(
+          execution_id,
+          invocation: invocation,
+          fsm_session_id: parent_session.id
+        )
+        source_task = Phronomy::Task.deferred(name: "#{result_task.name}-source")
+        source_task.on_complete do |completed, error|
+          finish_on_event_loop(
+            execution_id,
+            result_task,
+            completed || parent_session.context,
+            error,
+            fsm_session_id: parent_session.id
+          )
+        end
+        event_loop.register(parent_session, completion: source_task)
+        invocation.tool_invocations.each do |child|
+          child_session = if child.awaiting_approval?
+            Agent::ToolInvocationSessionBuilder.build_for_resume(
+              tool_invocation: child,
+              parent_event_sink: parent_session.event_sink,
+              resume_event: approved ? :approve : :reject,
+              resume_phase: :awaiting_approval,
+              runtime: runtime
+            )
+          elsif !approved && child.authorized?
+            Agent::ToolInvocationSessionBuilder.build_for_resume(
+              tool_invocation: child,
+              parent_event_sink: parent_session.event_sink,
+              resume_event: :cancel,
+              resume_phase: :authorized,
+              runtime: runtime
+            )
+          end
+          register_child(event_loop, child, child_session, parent_session.event_sink) if child_session
+        end
+      end
+
+      def start_framework_tools_on_event_loop(execution_id, result_task)
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        state = event_loop.agent_execution_state(execution_id)
+        invocation = state.invocation
+        session = AgentInvocationSessionBuilder.build_for_resume(agent_invocation: invocation,
+          resume_event: :resume, resume_phase: :suspended, runtime: runtime)
+        event_loop.replace_agent_execution(execution_id, invocation: invocation, fsm_session_id: session.id)
+        event_loop.mark_agent_execution_admission(@agent.agent_id, execution_id: execution_id, state: :executing)
+        source = Phronomy::Task.deferred(name: "framework-tool-recovery-source")
+        source.on_complete do |result, error|
+          finish_on_event_loop(execution_id, result_task, result || session.context, error, fsm_session_id: session.id)
+        end
+        event_loop.register(session, completion: source)
+        invocation.tool_invocations.select(&:authorized?).each do |child|
+          child_session = ToolInvocationSessionBuilder.build_for_resume(tool_invocation: child,
+            parent_event_sink: session.event_sink, resume_event: :dispatch, resume_phase: :authorized, runtime: runtime)
+          register_child(event_loop, child, child_session, session.event_sink)
+        end
+      end
+
+      def register_child(event_loop, child, session, parent_event_sink)
+        completion = Phronomy::Task.deferred(name: "tool-session:#{child.id}")
+        completion.on_complete do |_result, error|
+          next unless error
+
+          child.mark_framework_failed!(error)
+          parent_event_sink.post(:tool_failed, {tool_invocation_id: child.id})
+        end
+        event_loop.register(session, completion: completion)
+      end
+
+      # ----------------------------------------------------------------------
+      # Terminal durable barrier
+      # ----------------------------------------------------------------------
 
-      def compute_terminal(activation, invocation, error)
-        if (failure = activation.callback_failure)
-          terminal = commit_failed(
-            activation,
-            invocation,
-            failure.to_stream_callback_error
+      def finish_on_event_loop(execution_id, result_task, invocation, error, fsm_session_id:)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        assert_event_loop!(event_loop)
+        state = event_loop.agent_execution_state(execution_id)
+        return fail_task(result_task, runtime_rejected_error(:terminal)) unless state
+
+        unless state.fsm_session_id.to_s == fsm_session_id.to_s &&
+            state.invocation.equal?(invocation)
+          return fail_task(
+            result_task,
+            Phronomy::Error.new("stale Agent terminal callback for #{execution_id}")
+          )
+        end
+
+        terminal_error = error || invocation&.error
+        unless event_loop.agent_execution_quiescent?(execution_id)
+          wait_state = quiescence_sensitive_terminal_error?(terminal_error) ?
+            :cancelling : :terminalizing
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: execution_id,
+            state: wait_state
+          )
+          event_loop.defer_agent_terminal_until_quiescent(
+            execution_id,
+            DeferredTerminalCommand.new(
+              coordinator: self,
+              execution_id: execution_id.to_s.freeze,
+              result_task: result_task,
+              invocation: invocation,
+              source_error: error,
+              fsm_session_id: fsm_session_id.to_s.freeze
+            )
+          )
+          return
+        end
+
+        begin_terminal_commit_on_event_loop(
+          state,
+          result_task,
+          invocation,
+          error,
+          fsm_session_id: fsm_session_id
+        )
+      end
+
+      def resume_deferred_terminal_on_event_loop(command)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(command.execution_id)
+        unless state && state.agent.equal?(@agent) &&
+            state.fsm_session_id.to_s == command.fsm_session_id.to_s &&
+            state.invocation.equal?(command.invocation)
+          Phronomy.configuration.logger&.warn(
+            "[Phronomy] Dropped stale deferred terminal for #{command.execution_id}"
           )
-          return {type: :failed, error: terminal.fetch(:error)}
+          return
         end
-        if error
-          terminal = commit_failed(activation, invocation, error)
-          return {type: :failed, error: terminal.fetch(:error)}
+
+        unless event_loop.agent_execution_quiescent?(command.execution_id)
+          raise Phronomy::Error,
+            "deferred terminal resumed before quiescence for #{command.execution_id}"
         end
+
+        begin_terminal_commit_on_event_loop(
+          state,
+          command.result_task,
+          command.invocation,
+          command.source_error,
+          fsm_session_id: command.fsm_session_id
+        )
+      end
+
+      def quiescence_sensitive_terminal_error?(error)
+        error.is_a?(Phronomy::CancellationError) ||
+          error.is_a?(Phronomy::TimeoutError)
+      end
+
+      def begin_terminal_commit_on_event_loop(
+        state,
+        result_task,
+        invocation,
+        source_error,
+        fsm_session_id:
+      )
         if invocation&.phase == :suspended
-          return {
-            type: :suspended,
-            result: commit_suspended(activation, invocation)
-          }
+          snapshot = RecoverySupport.build_tool_batch_snapshot(invocation)
+          staged_execution = RecoverySupport.with_recovery_metadata(
+            state.execution,
+            RecoverySupport::TOOL_BATCH_METADATA_KEY => snapshot
+          )
+          state = state.class.new(
+            **state.to_h.merge(execution: staged_execution)
+          )
+        end
+
+        operation = build_terminal_operation(
+          execution: state.execution,
+          root: @agent.agent_root,
+          journal_records: @agent.send(:_journal_records_snapshot),
+          invocation: invocation,
+          source_error: source_error,
+          fsm_session_id: fsm_session_id,
+          state_required: true
+        )
+        delivery = TerminalDelivery.new(
+          result_task: result_task,
+          application_listener: invocation&.event_listener,
+          approval_listener: invocation&.approval_listener,
+          handoff_request: invocation&.handoff_request,
+          handoff_manifest: state.runtime_projection&.manifest
+        )
+        submit_terminal_operation(operation, delivery)
+      end
+
+      def begin_terminal_without_session_on_event_loop(request:, prepared:, error:)
+        return deliver_start_failure_on_event_loop(request, translated(error)) unless prepared&.execution
+
+        operation = build_terminal_operation(
+          execution: prepared.execution,
+          root: prepared.root,
+          journal_records: @agent.send(:_journal_records_snapshot),
+          invocation: nil,
+          source_error: error,
+          fsm_session_id: nil,
+          state_required: false
+        )
+        delivery = TerminalDelivery.new(
+          result_task: request.result_task,
+          application_listener: request.on_event,
+          approval_listener: request.approval_listener,
+          handoff_request: nil,
+          handoff_manifest: nil
+        )
+        submit_terminal_operation(operation, delivery)
+      end
+
+      def build_terminal_operation(
+        execution:,
+        root:,
+        journal_records:,
+        invocation:,
+        source_error:,
+        fsm_session_id:,
+        state_required:
+      )
+        TerminalCommitCommand.new(
+          execution_id: execution.execution_id.to_s.freeze,
+          fsm_session_id: fsm_session_id&.to_s&.freeze,
+          expected_execution_revision: execution.execution_revision,
+          root: root,
+          journal_records: journal_records,
+          execution: execution,
+          runtime_snapshot: invocation ? invocation.runtime_snapshot : empty_runtime_snapshot,
+          terminal_view: terminal_view(invocation, source_error),
+          state_required: state_required
+        )
+      end
+
+      def submit_terminal_operation(operation, delivery)
+        runtime = Phronomy::Runtime.instance
+        event_loop = runtime.event_loop
+        terminal_transition_started = false
+        event_loop.mark_agent_execution_admission(
+          @agent.agent_id,
+          execution_id: operation.execution_id,
+          state: :terminalizing
+        )
+        terminal_transition_started = true
+        event_loop.register_agent_completion_waiter(
+          operation.execution_id,
+          delivery.result_task
+        )
+        task = runtime.offload.submit(on_full: :raise) do
+          # Only the operation-specific immutable durable snapshot crosses the
+          # worker boundary. Task/listener delivery state stays outside it.
+          compute_terminal(operation)
+        end
+        task.on_complete do |outcome, error|
+          ready = TerminalCommitReady.new(
+            coordinator: self,
+            operation: operation,
+            delivery: delivery,
+            outcome: outcome,
+            error: error
+          )
+          fail_task(delivery.result_task, runtime_rejected_error(:terminal_apply)) unless
+            post_control(runtime, ready)
+        end
+      rescue => error
+        if terminal_transition_started
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id,
+            state: :recovery_required
+          )
+          Phronomy.configuration.logger&.warn(
+            "[Phronomy] Agent terminal transition requires recovery for " \
+            "#{operation.execution_id}: #{error.class}: #{error.message}"
+          )
+          return
         end
-        raise invocation.block_error if invocation.input_blocked? || invocation.output_blocked?
-        raise invocation.error if invocation.error
 
-        {type: :completed, result: commit_completed(activation, invocation)}
+        fail_task(delivery.result_task, translated(error))
+        raise
+      end
+
+      def terminal_view(invocation, source_error)
+        TerminalView.new(
+          phase: invocation&.phase,
+          output: invocation&.output,
+          usage: invocation&.usage,
+          approval_request: invocation&.approval_request,
+          rejected: invocation ? !!invocation.rejected : false,
+          input_blocked: invocation ? invocation.input_blocked? : false,
+          output_blocked: invocation ? invocation.output_blocked? : false,
+          block_error: invocation&.block_error,
+          invocation_error: invocation&.error,
+          handoff: handoff_terminal_view(invocation&.handoff_request),
+          callback_failure: invocation&.callback_failure,
+          source_error: source_error,
+          cancel_requested: invocation&.config&.fetch(:cancellation_token, nil)&.cancelled? || false
+        )
+      end
+
+      def handoff_terminal_view(request)
+        return unless request
+
+        HandoffTerminalView.new(
+          target_agent_id: request.handoff.target_agent.agent_id.to_s.freeze,
+          responsibility: request.responsibility.to_s.freeze,
+          selection_intent: request.selection_intent.to_h do |category, included|
+            [category.to_s.freeze, !!included]
+          end.freeze,
+          llm_call_id: request.llm_call_id&.to_s&.freeze,
+          tool_call_id: request.tool_call_id&.to_s&.freeze,
+          policy: Immutable.copy(request.handoff.policy.to_h)
+        )
+      end
+
+      def empty_runtime_snapshot
+        {llm_results: [].freeze, runtime_events: [].freeze, active_call: nil}.freeze
+      end
+
+      def compute_terminal(operation)
+        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
+        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
-        terminal = commit_failed(activation, invocation, caught)
-        {type: :failed, error: terminal.fetch(:error)}
+        reconcile_terminal_error(operation, caught)
       end
 
-      def commit_suspended(activation, invocation)
-        current = activation.execution
-        root = @agent.agent_root
-        request = invocation.approval_request
-        runtime_snapshot = activation.runtime_snapshot
+      # 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
+        @agent.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)
+        end
+        return unless waiting
+        coordination_wait_outcome(operation, waiting, error)
+      rescue => failure
+        confirmed = @agent.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)
+        TerminalOutcome.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 = @agent.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 = @agent.persistence.agents.load(@agent.agent_id)
+        records = @agent.persistence.journals.read(@agent.agent_id,
+          after: operation.root.journal_position, limit: root.journal_position - operation.root.journal_position)
+        result = @agent.persistence.execution_result(confirmed.execution_id)
+        failure = result[:error] && RecoverySupport.error_from_failure(result[:error])
+        type = if failure
+          :failed
+        else
+          ((confirmed.status == :handed_off) ? :handed_off : :completed)
+        end
+        TerminalOutcome.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)
+        current = operation.execution
+        root = operation.root
+        request = operation.terminal_view.approval_request
+        runtime_snapshot = operation.runtime_snapshot
         suspended = next_root = nil
 
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation,
+            current,
             tx: tx,
             snapshot: runtime_snapshot,
             context_candidate: true,
@@ -549,7 +2336,6 @@ module Phronomy
             kind: :approval_required,
             channel: :approval,
             content_ref: request_ref,
-            correlation_id: request.id.to_s,
             context_generation: root.transcript_generation,
             context_candidate: false
           )
@@ -575,31 +2361,49 @@ module Phronomy
             root: next_root
           )
         end
-        activation.acknowledge_runtime_snapshot(runtime_snapshot)
-        activation.replace_execution(suspended)
-        @agent.__replace_root(next_root)
-        dispatch_approval_listener(invocation, request)
-        result_base(suspended, next_root).merge(
+        result = result_base(suspended, next_root).merge(
           suspended: true,
           approval_request: request
         )
+        TerminalOutcome.new(
+          type: :suspended,
+          execution: suspended,
+          root: next_root,
+          appended_records: [].freeze,
+          result: result.freeze,
+          error: nil,
+          approval_request: request
+        )
       end
 
-      def commit_completed(activation, invocation)
-        current = activation.execution
-        root = @agent.agent_root
-        runtime_snapshot = activation.runtime_snapshot
-        completed = next_root = appended = nil
+      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::Persistence::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 commit_completed(operation)
+        current = operation.execution
+        root = operation.root
+        view = operation.terminal_view
+        runtime_snapshot = operation.runtime_snapshot
+        completed = next_root = appended = messages = nil
 
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation,
+            current,
             tx: tx,
             snapshot: runtime_snapshot,
             context_candidate: true,
             agent_root: root
           )
-          output_ref = tx.contents.put_text(invocation.output.to_s)
+          output_ref = tx.contents.put_text(view.output.to_s)
           final_output_record = JournalRecord.new(
             agent_id: @agent.agent_id,
             execution_id: current.execution_id,
@@ -613,7 +2417,7 @@ module Phronomy
           completed_record = JournalRecord.new(
             agent_id: @agent.agent_id,
             execution_id: current.execution_id,
-            kind: invocation.rejected ? :execution_rejected : :execution_completed,
+            kind: view.rejected ? :execution_rejected : :execution_completed,
             channel: :audit,
             content_ref: output_ref,
             context_generation: root.transcript_generation,
@@ -627,14 +2431,16 @@ module Phronomy
             records: all_records
           )
           completed = current.with(
-            status: invocation.rejected ? :rejected : :completed,
+            status: view.rejected ? :rejected : :completed,
             phase: :completed,
             working_records: [],
             llm_calls: current.llm_calls + call_records,
             approval_request: nil,
             result_ref: output_ref,
-            terminal_reason: invocation.rejected ? "rejected" : "completed"
+            terminal_reason: view.rejected ? "rejected" : "completed"
           )
+          completed = @agent.__prepare_coordination_record(completed, tx: tx)
+          synchronize_handoff_target(tx, completed)
           tx.executions.save(
             current.execution_id,
             expected_revision: current.execution_revision,
@@ -652,29 +2458,45 @@ module Phronomy
             expected_revision: root.agent_revision,
             root: next_root
           )
+
+          # Materialize the caller-facing transcript through the transaction
+          # view before commit. If materialization fails, the terminal durable
+          # transition rolls back instead of committing and then attempting a
+          # second terminal transition from a stale execution revision.
+          records_after_commit = operation.journal_records + Array(appended)
+          messages = transcript_messages(
+            next_root,
+            records_after_commit,
+            persistence: tx
+          )
         end
-        activation.acknowledge_runtime_snapshot(runtime_snapshot)
-        activation.replace_execution(completed)
-        @agent.send(:_append_journal_records, appended)
-        @agent.__replace_root(next_root)
-        result_base(completed, next_root).merge(
-          output: invocation.output,
-          rejected: invocation.rejected || nil,
-          usage: invocation.usage,
-          messages: transcript_messages(next_root)
+        result = result_base(completed, next_root).merge(
+          output: view.output,
+          rejected: view.rejected || nil,
+          usage: view.usage,
+          messages: messages
         ).compact
+        TerminalOutcome.new(
+          type: :completed,
+          execution: completed,
+          root: next_root,
+          appended_records: Array(appended).freeze,
+          result: result.freeze,
+          error: nil,
+          approval_request: nil
+        )
       end
 
-      def commit_failed(activation, _invocation, error)
+      def commit_failed_outcome(operation, error)
         translated_error = translated(error)
-        current = activation.execution
-        root = @agent.agent_root
-        runtime_snapshot = activation.runtime_snapshot
+        current = operation.execution
+        root = operation.root
+        runtime_snapshot = operation.runtime_snapshot
         failed = next_root = appended = nil
 
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation,
+            current,
             tx: tx,
             snapshot: runtime_snapshot,
             context_candidate: false,
@@ -712,6 +2534,8 @@ module Phronomy
             error_ref: error_ref,
             terminal_reason: translated_error.class.name
           )
+          failed = @agent.__prepare_coordination_record(failed, tx: tx)
+          synchronize_handoff_target(tx, failed)
           tx.executions.save(
             current.execution_id,
             expected_revision: current.execution_revision,
@@ -728,21 +2552,155 @@ module Phronomy
             root: next_root
           )
         end
-        activation.acknowledge_runtime_snapshot(runtime_snapshot)
-        activation.replace_execution(failed)
-        @agent.send(:_append_journal_records, appended)
-        @agent.__replace_root(next_root)
-        {error: translated_error, execution: failed, root: next_root}
+        TerminalOutcome.new(
+          type: :failed,
+          execution: failed,
+          root: next_root,
+          appended_records: Array(appended).freeze,
+          result: nil,
+          error: translated_error,
+          approval_request: nil
+        )
+      end
+
+      def apply_terminal_commit_on_event_loop(ready)
+        operation = ready.operation
+        delivery = ready.delivery
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(operation.execution_id)
+
+        if operation.state_required
+          unless state && state.agent.equal?(@agent) &&
+              state.execution.execution_revision == operation.expected_execution_revision &&
+              state.fsm_session_id.to_s == operation.fsm_session_id.to_s
+            Phronomy.configuration.logger&.warn(
+              "[Phronomy] Dropped stale Agent terminal result for #{operation.execution_id}"
+            )
+            return
+          end
+        end
+
+        if ready.error
+          if operation.execution.metadata["coordination"] || operation.execution.metadata["multi_agent_coordination_ref"]
+            event_loop.release_agent_execution(operation.execution_id) if state
+            event_loop.release_agent_execution_admission(@agent.agent_id, execution_id: operation.execution_id)
+            event_loop.take_agent_completion_waiters(operation.execution_id, fallback: delivery.result_task).each do |task|
+              task.fail(ready.error)
+            end
+            return
+          end
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id,
+            state: :recovery_required
+          )
+          Phronomy.configuration.logger&.warn(
+            "[Phronomy] Agent terminal durable outcome requires recovery for " \
+            "#{operation.execution_id}: #{ready.error.class}: #{ready.error.message}"
+          )
+          return
+        end
+
+        outcome = ready.outcome
+        apply_agent_live_state(
+          root: outcome.root,
+          appended_records: outcome.appended_records
+        )
+        if state
+          state.invocation&.acknowledge_runtime_snapshot(operation.runtime_snapshot)
+          event_loop.replace_agent_execution(
+            operation.execution_id,
+            execution: outcome.execution,
+            fsm_session_id: (outcome.type == :suspended) ? nil : state.fsm_session_id
+          )
+        end
+
+        case outcome.type
+        when :coordination_wait
+          event_loop.release_agent_execution(operation.execution_id) if state
+          event_loop.release_agent_execution_admission(@agent.agent_id, execution_id: operation.execution_id)
+          event_loop.take_agent_completion_waiters(operation.execution_id, fallback: delivery.result_task).each { |task| task.fail(outcome.error) }
+        when :suspended
+          event_loop.mark_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id,
+            state: :suspended
+          )
+          dispatch_approval_listener(delivery.approval_listener, outcome.approval_request)
+          callback_error = deliver_terminal(
+            delivery.application_listener,
+            :approval_required,
+            request: outcome.approval_request
+          )
+          report_nonterminal_callback_error(
+            callback_error,
+            :approval_required,
+            outcome.result
+          )
+          Array(state&.invocation&.config&.fetch(:phronomy_exact_observers, [])).each do |task|
+            task.fail(Phronomy::ExecutionRehydrationRequiredError.new("Execution #{operation.execution_id} requires approval"))
+          end
+        when :completed
+          event_loop.release_agent_execution(operation.execution_id) if state
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id
+          )
+          callback_error = deliver_terminal(delivery.application_listener, :done, outcome.result)
+          settle_execution_waiters(
+            event_loop, operation.execution_id, delivery.result_task,
+            callback_error, :done, outcome.result
+          )
+        when :handed_off
+          event_loop.release_agent_execution(operation.execution_id) if state
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id
+          )
+          result = outcome.result.merge(
+            handoff_request: delivery.handoff_request,
+            _phronomy_handoff_manifest: delivery.handoff_manifest
+          ).freeze
+          callback_error = deliver_terminal(delivery.application_listener, :handoff, result)
+          settle_execution_waiters(
+            event_loop, operation.execution_id, delivery.result_task,
+            callback_error, :handoff, result
+          )
+        when :failed
+          event_loop.release_agent_execution(operation.execution_id) if state
+          event_loop.release_agent_execution_admission(
+            @agent.agent_id,
+            execution_id: operation.execution_id
+          )
+          type = terminal_event_type(outcome.error)
+          callback_error = deliver_terminal(
+            delivery.application_listener,
+            type,
+            error: outcome.error
+          )
+          settle_execution_waiters(
+            event_loop, operation.execution_id, delivery.result_task,
+            callback_error, type, nil, outcome.error
+          )
+        else
+          fail_task(
+            delivery.result_task,
+            Phronomy::Error.new("unknown terminal outcome: #{outcome.type.inspect}")
+          )
+        end
       end
 
+      # ----------------------------------------------------------------------
+      # Durable record encoding helpers
+      # ----------------------------------------------------------------------
+
       def encode_runtime_records(
-        activation,
+        execution,
         tx:,
         snapshot:,
         context_candidate:,
         agent_root:
       )
-        execution = activation.execution
         root = agent_root
         records = []
         calls = []
@@ -846,6 +2804,9 @@ module Phronomy
             llm_call_id = payload[:llm_call_id] || payload["llm_call_id"]
             tool_call_id = payload.fetch(:tool_call_id).to_s
             tool_name = payload.fetch(:tool_name).to_s
+            next if execution.working_records.any? do |record|
+              record.kind == :tool_message && record.causation_id.to_s == tool_call_id && record.llm_call_id.to_s == llm_call_id.to_s
+            end
             result_ref = put_runtime_content(tx, payload.fetch(:tool_result))
             records << JournalRecord.new(
               agent_id: @agent.agent_id,
@@ -889,168 +2850,6 @@ module Phronomy
         [records, calls]
       end
 
-      def mark_resuming!(activation, approval_request_id:, approved:)
-        current = activation.execution
-        current_root = @agent.agent_root
-        unless current.agent_id == @agent.agent_id && current.status == :suspended
-          raise ArgumentError, "execution is not suspended: #{current.execution_id}"
-        end
-
-        request = current.approval_request || {}
-        request_id = request["id"] || request[:id]
-        unless request_id.to_s == approval_request_id.to_s
-          raise ArgumentError,
-            "approval request does not match execution #{current.execution_id}"
-        end
-
-        updated = next_root = nil
-        @agent.persistence.transaction do |tx|
-          decision_ref = tx.contents.put_json(
-            "approval_request_id" => request_id.to_s,
-            "approved" => !!approved
-          )
-          decision_record = JournalRecord.new(
-            agent_id: @agent.agent_id,
-            execution_id: current.execution_id,
-            kind: :approval_decided,
-            channel: :approval,
-            content_ref: decision_ref,
-            correlation_id: request_id.to_s,
-            context_generation: current_root.transcript_generation,
-            context_candidate: false
-          )
-          updated = current.with(
-            status: :active,
-            phase: :resuming,
-            working_records: current.working_records + [decision_record],
-            approval_request: request.merge("approved" => approved)
-          )
-          tx.executions.save(
-            current.execution_id,
-            expected_revision: current.execution_revision,
-            execution: updated
-          )
-          next_root = current_root.with(
-            agent_revision: current_root.agent_revision + 1,
-            lifecycle_status: :active
-          )
-          tx.agents.save(
-            current_root.agent_id,
-            expected_revision: current_root.agent_revision,
-            root: next_root
-          )
-        end
-        activation.replace_execution(updated)
-        @agent.__replace_root(next_root)
-        updated
-      end
-
-      def assert_local_durable_base!(tx, root)
-        tx.assert_agent_watermark!(
-          agent_id: root.agent_id,
-          agent_revision: root.agent_revision,
-          journal_position: root.journal_position
-        )
-      end
-
-      def transcript_messages(root)
-        materializer = RubyLLMMaterializer.new(
-          agent: @agent,
-          persistence: @agent.persistence
-        )
-        materializer.materialize_journal_records(
-          JournalProjection.new(
-            agent_root: root,
-            records: @agent.send(:_journal_records_snapshot)
-          ).transcript_records
-        )
-      end
-
-      def deliver_execution_terminal(command)
-        activation = command.activation
-        registry = Phronomy::Runtime.instance.__agent_activations
-        if command.commit_error
-          callback_error = deliver_terminal(
-            activation,
-            :error,
-            error: command.commit_error
-          )
-          settle_after_terminal(
-            command.result_task,
-            callback_error,
-            :error,
-            nil,
-            command.commit_error
-          )
-          return
-        end
-
-        outcome = command.outcome
-        case outcome.fetch(:type)
-        when :suspended
-          result = outcome.fetch(:result)
-          callback_error = deliver_terminal(
-            activation,
-            :approval_required,
-            request: result.fetch(:approval_request)
-          )
-          settle_after_terminal(
-            command.result_task,
-            callback_error,
-            :approval_required,
-            result
-          )
-        when :completed
-          registry.delete(activation.execution_id)
-          result = outcome.fetch(:result)
-          callback_error = deliver_terminal(activation, :done, result)
-          settle_after_terminal(
-            command.result_task,
-            callback_error,
-            :done,
-            result
-          )
-        when :failed
-          registry.delete(activation.execution_id)
-          error = outcome.fetch(:error)
-          type = terminal_event_type(error)
-          callback_error = deliver_terminal(activation, type, error: error)
-          settle_after_terminal(
-            command.result_task,
-            callback_error,
-            type,
-            nil,
-            error
-          )
-        end
-      end
-
-      def settle_without_listener(activation, result_task, outcome, commit_error)
-        registry = Phronomy::Runtime.instance.__agent_activations
-        if commit_error
-          return fail_task(result_task, commit_error)
-        end
-
-        case outcome&.fetch(:type)
-        when :suspended
-          complete_task(result_task, outcome.fetch(:result))
-        when :completed
-          registry.delete(activation.execution_id)
-          complete_task(result_task, outcome.fetch(:result))
-        when :failed
-          registry.delete(activation.execution_id)
-          fail_task(result_task, outcome.fetch(:error))
-        else
-          registry.delete(activation.execution_id)
-          fail_task(
-            result_task,
-            Phronomy::RuntimeShutdownError.new(
-              "EventLoop is not accepting terminal delivery"
-            )
-          )
-        end
-      end
-
       def assistant_message_ref(tx, outcome)
         return unless outcome
 
@@ -1084,64 +2883,76 @@ module Phronomy
           tx.contents.put_text(value) : tx.contents.put_json(json_value(value))
       end
 
-      def start_resume(activation, result_task, approved:, config:)
-        invocation = activation.invocation
-        invocation.merge_config!(config)
-        invocation.begin_approval_resume!(approved: approved)
-        runtime = Phronomy::Runtime.instance
-        event_loop = runtime.event_loop
-        parent_session = Agent::AgentInvocationSessionBuilder.build_for_resume(
-          agent_invocation: invocation,
-          resume_event: :resume,
-          resume_phase: :suspended,
-          runtime: runtime
+      # ----------------------------------------------------------------------
+      # EventLoop validation/apply helpers
+      # ----------------------------------------------------------------------
+
+      def authoritative_state_for_operation(
+        execution_id:,
+        fsm_session_id:,
+        expected_execution_revision:,
+        expected_fsm_state:
+      )
+        event_loop = Phronomy::Runtime.instance.event_loop
+        state = event_loop.agent_execution_state(execution_id)
+        authoritative = state &&
+          state.agent.equal?(@agent) &&
+          state.execution.execution_revision == expected_execution_revision &&
+          state.fsm_session_id.to_s == fsm_session_id.to_s &&
+          event_loop.fsm_session_state(fsm_session_id) == expected_fsm_state
+        return state if authoritative
+
+        Phronomy.configuration.logger&.warn(
+          "[Phronomy] Dropped stale Agent operation result: " \
+          "execution_id=#{execution_id} fsm_session_id=#{fsm_session_id}"
         )
-        activation.session = parent_session
-        source_task = Phronomy::Task.deferred(name: "#{result_task.name}-source")
-        source_task.on_complete do |completed, error|
-          finish(
-            activation,
-            result_task,
-            completed || parent_session.context,
-            error
-          )
-        end
-        event_loop.register(parent_session, completion: source_task)
-        invocation.tool_invocations.each do |child|
-          child_session = if child.awaiting_approval?
-            Agent::ToolInvocationSessionBuilder.build_for_resume(
-              tool_invocation: child,
-              resume_event: approved ? :approve : :reject,
-              resume_phase: :awaiting_approval,
-              runtime: runtime
-            )
-          elsif !approved && child.authorized?
-            Agent::ToolInvocationSessionBuilder.build_for_resume(
-              tool_invocation: child,
-              resume_event: :cancel,
-              resume_phase: :authorized,
-              runtime: runtime
-            )
-          end
-          register_child(event_loop, runtime, child, child_session) if child_session
+        nil
+      rescue
+        nil
+      end
+
+      def validate_live_session!(state, invocation, fsm_session_id)
+        unless state && state.agent.equal?(@agent) &&
+            state.invocation.equal?(invocation) &&
+            state.fsm_session_id.to_s == fsm_session_id.to_s
+          raise Phronomy::Error,
+            "Agent operation does not belong to the current live FSMSession"
         end
       end
 
-      def register_child(event_loop, runtime, child, session)
-        completion = Phronomy::Task.deferred(name: "tool-session:#{child.id}")
-        completion.on_complete do |_result, error|
-          next unless error
+      def apply_agent_live_state(root:, appended_records:)
+        event_loop = Phronomy::Runtime.instance.event_loop
+        assert_event_loop!(event_loop)
+        @agent.send(:_append_journal_records, appended_records)
+        @agent.__replace_root(root)
+      end
 
-          child.mark_framework_failed!(error)
-          runtime.event_loop.post_to_session(
-            Phronomy::Event.new(
-              type: :tool_failed,
-              target_id: child.parent_agent_invocation_id,
-              payload: {tool_invocation_id: child.id}
-            )
-          )
-        end
-        event_loop.register(session, completion: completion)
+      def assert_event_loop!(event_loop)
+        return if event_loop.current?
+
+        raise Phronomy::Error,
+          "ExecutionCoordinator live-state apply must run on EventLoop"
+      end
+
+      def assert_local_durable_base!(tx, root)
+        tx.assert_agent_watermark!(
+          agent_id: root.agent_id,
+          agent_revision: root.agent_revision,
+          journal_position: root.journal_position
+        )
+      end
+
+      def transcript_messages(root, journal_records, persistence: @agent.persistence)
+        materializer = RubyLLMMaterializer.new(
+          agent: @agent,
+          persistence: persistence
+        )
+        materializer.materialize_journal_records(
+          JournalProjection.new(
+            agent_root: root,
+            records: journal_records
+          ).transcript_records
+        )
       end
 
       def result_base(execution, root)
@@ -1154,16 +2965,7 @@ module Phronomy
         }
       end
 
-      def context_policy_for(execution)
-        descriptor_hash = execution.metadata.fetch("context_policy") do
-          ContextPolicies::Default.new.descriptor.to_h
-        end
-        descriptor = ContextPolicyDescriptor.from_h(descriptor_hash)
-        ContextPolicyRegistry.default.resolve(descriptor)
-      end
-
-      def deliver_terminal(activation, type, payload)
-        listener = activation.application_listener
+      def deliver_terminal(listener, type, payload)
         return nil unless listener
 
         @agent.send(
@@ -1173,16 +2975,43 @@ module Phronomy
         )
       end
 
-      def post_prep_failure(runtime, listener, result_task, error)
-        command = PrepFailureCommand.new(self, listener, result_task, error)
-        posted = runtime.event_loop.post(
-          Phronomy::Event.new(
-            type: :agent_terminal_ready,
-            target_id: Phronomy::EventLoop::SYSTEM_CHANNEL_ID,
-            payload: {command: command}
+      def dispatch_approval_listener(listener, request)
+        return unless listener
+
+        Phronomy::Runtime.instance.offload.submit(on_full: :raise) do
+          listener.call(request)
+        end
+      rescue => error
+        Phronomy.configuration.logger&.warn(
+          "[Phronomy] approval listener dispatch failed: #{error.class}: #{error.message}"
+        )
+      end
+
+      def settle_execution_waiters(
+        event_loop, execution_id, fallback_task, callback_error, event_type,
+        result, execution_error = nil
+      )
+        waiters = event_loop.take_agent_completion_waiters(
+          execution_id,
+          fallback: fallback_task
+        )
+        waiters.each do |task|
+          settle_after_terminal(
+            task, callback_error, event_type, result, execution_error
           )
+        end
+      end
+
+      def report_nonterminal_callback_error(callback_error, event_type, result)
+        return unless callback_error
+
+        @agent.send(
+          :_report_stream_callback_error,
+          callback_error,
+          event: StreamEvent.new(type: event_type, payload: result),
+          execution_id: result&.fetch(:execution_id, nil),
+          callback_error_policy: Phronomy.configuration.stream_callback_error_policy
         )
-        fail_task(result_task, error) unless posted
       end
 
       def settle_after_terminal(
@@ -1201,7 +3030,7 @@ module Phronomy
               type: event_type,
               payload: result || {error: execution_error}
             ),
-            invocation_id: nil,
+            execution_id: result&.fetch(:execution_id, nil),
             callback_error_policy: policy
           )
           if policy == :fail_task && execution_error.nil?
@@ -1216,8 +3045,15 @@ module Phronomy
             )
           end
         end
-        execution_error ?
-          fail_task(result_task, execution_error) : complete_task(result_task, result)
+        if execution_error
+          if execution_error.is_a?(Phronomy::CancellationError)
+            result_task.cancel!(execution_error)
+          else
+            fail_task(result_task, execution_error)
+          end
+        else
+          complete_task(result_task, result)
+        end
       end
 
       def terminal_event_type(error)
@@ -1227,15 +3063,6 @@ module Phronomy
         :error
       end
 
-      def dispatch_approval_listener(invocation, request)
-        listener = invocation.approval_listener
-        return unless listener
-
-        Phronomy::Runtime.instance.offload.submit(on_full: :raise) do
-          listener.call(request)
-        end
-      end
-
       def json_value(value)
         case value
         when Hash
@@ -1277,6 +3104,24 @@ module Phronomy
         }.fetch(status)
       end
 
+      def post_control(runtime, command)
+        runtime.event_loop.post(
+          Phronomy::Event.new(
+            type: :agent_control,
+            target_id: Phronomy::EventLoop::SYSTEM_CHANNEL_ID,
+            payload: {command: command}
+          )
+        )
+      rescue Phronomy::RuntimeShutdownError
+        false
+      end
+
+      def runtime_rejected_error(operation)
+        Phronomy::RuntimeShutdownError.new(
+          "EventLoop is not accepting Agent #{operation} control delivery"
+        )
+      end
+
       def translated(error)
         @agent.send(:_translated_error, error)
       end