phronomy 0.26.0 → 0.28.0

data/lib/phronomy/agent/{exact_execution.rb → execution/exact_execution.rb}

@@ -10,24 +10,25 @@ module Phronomy
       Wait = Data.define(:coordinator, :agent, :execution_id)
       private_constant :Wait
 
-      def self.start(agent:, execution_id:, input:, config: {})
-        new(agent, execution_id, input, config).start
+      def self.start(agent:, execution_id:, input:, config: {}, resume_only: false)
+        new(agent, execution_id, input, config, resume_only).start
       end
 
-      def initialize(agent, execution_id, input, config)
+      def initialize(agent, execution_id, input, config, resume_only)
         @agent, @id, @input, @config = agent, execution_id.to_s.freeze, input, config.freeze
-        @runtime = Phronomy::Runtime.instance
+        @resume_only = resume_only
+        @environment = @agent.__execution_environment
         @completion = Phronomy::TaskResult.deferred(name: "exact-execution:#{@id}")
       end
 
       def start
-        preparation = @runtime.offload.submit(on_full: :raise) do
+        preparation = @environment.submit(on_full: :raise) do
           execution = read_execution
           if execution&.terminal?
             [:terminal, materialize(execution)]
           elsif execution
-            unless @runtime.__agent_execution_owner(@id)
-              @agent.instance_variable_set(:@_phronomy_coordination_config, @config)
+            unless @environment.existing_registry&.agent_execution_owner(@id)
+              @agent.instance_variable_set(:@_phronomy_execution_wiring, @config)
               begin
                 RecoveryCoordinator.new(@agent).recover_on_load!
               rescue Phronomy::ConfigurationError => error
@@ -37,6 +38,7 @@ module Phronomy
             end
             [:active, nil]
           else
+            raise Phronomy::Persistence::NotFoundError, "Execution #{@id} is absent" if @resume_only
             @config[:cancellation_token]&.raise_if_cancelled!
             [:absent, nil]
           end
@@ -55,8 +57,7 @@ module Phronomy
               source.on_complete { |_value, failure| reconcile(failure) }
             when :active
               command = Wait.new(coordinator: self, agent: @agent, execution_id: @id)
-              posted = @runtime.event_loop.post(Phronomy::Event.new(type: :agent_terminal_ready,
-                target_id: Phronomy::EventLoop::SYSTEM_CHANNEL_ID, payload: {command: command}))
+              posted = @environment.registry.post(command, completion: @completion)
               @completion.fail(Phronomy::RuntimeShutdownError.new("Exact execution observer rejected")) unless posted
             end
           end
@@ -70,7 +71,7 @@ module Phronomy
       end
 
       def deliver_on_event_loop(command)
-        state = @runtime.event_loop.agent_execution_state(command.execution_id)
+        state = @environment.registry.agent_execution_state(command.execution_id)
         unless state
           # Ownership can be released between the durable read and this command.
           # Reinstall once with the caller's current wiring/cancellation request.
@@ -81,9 +82,13 @@ module Phronomy
           return reconcile(nil)
         end
         unless state.agent.equal?(command.agent)
-          raise Phronomy::Persistence::ConflictError, "Exact execution #{@id} owner mismatch"
+          raise Phronomy::Persistence::StateConflictError, "Exact execution #{@id} owner mismatch"
         end
         if @config[:cancellation_token]&.cancelled?
+          # One observation governs both recording and notification. A newly
+          # observed request must be persisted off EventLoop before signaling.
+          return start unless @cancellation_recorded
+
           state.invocation&.config&.fetch(:cancellation_token, nil)&.cancel!
         end
         if state.execution.status == :suspended || state.fsm_session_id.nil?
@@ -94,7 +99,7 @@ module Phronomy
         state.invocation.merge_config!(phronomy_exact_observers: (observers + [@completion]).uniq.freeze)
         waiter = Phronomy::TaskResult.deferred(name: "exact-wait:#{@id}")
         waiter.on_complete { |_result, failure| reconcile(failure) }
-        @runtime.event_loop.register_agent_completion_waiter(@id, waiter)
+        @environment.registry.register_agent_completion_waiter(@id, waiter)
       rescue => failure
         @completion.fail(failure)
       end
@@ -108,26 +113,41 @@ module Phronomy
           return nil
         end
         unless execution.agent_id == @agent.agent_id
-          raise Phronomy::Persistence::ConflictError, "Reserved execution #{@id} belongs to another Agent"
+          raise Phronomy::Persistence::StateConflictError, "Reserved execution #{@id} belongs to another Agent"
         end
-        expected = @config[:phronomy_coordination]
-        stored = execution.metadata["coordination"]
+        expected = @config[:phronomy_reservation]
+        stored = execution.metadata["reservation"]
         if expected && stored != expected
-          actual_identity = stored&.except("handoff_revision")
-          expected_identity = expected.except("handoff_revision")
-          unless actual_identity == expected_identity
-            raise Phronomy::Persistence::ConflictError, "Reserved execution #{@id} coordination mismatch"
-          end
+          raise Phronomy::Persistence::StateConflictError, "Reserved execution #{@id} correlation mismatch"
         end
         ref = execution.metadata["current_input_ref"]
+        @input = @agent.persistence.contents.fetch_text(ref) if @resume_only && ref
         if ref && @agent.persistence.contents.fetch_text(ref) != @input
-          raise Phronomy::Persistence::ConflictError, "Reserved execution #{@id} input mismatch"
+          raise Phronomy::Persistence::StateConflictError, "Reserved execution #{@id} input mismatch"
+        end
+        unless execution.terminal?
+          extension = execution.metadata["execution_extension"]
+          participant = @config[:phronomy_execution_participant]
+          if extension && (!participant || participant.binding.to_h.except("state_ref") != extension.except("state_ref"))
+            raise Phronomy::ExecutionRehydrationRequiredError, "Execution #{@id} needs its current participant binding"
+          end
+          # The ledger is independent of execution revision, so recording intent
+          # does not invalidate an already captured outcome command.
+          if @config[:cancellation_token]&.cancelled?
+            @cancellation_recorded = @agent.persistence.request_cancellation(agent_id: @agent.agent_id, execution_id: @id)
+          end
+          if @agent.persistence.cancellation_requested?(agent_id: @agent.agent_id, execution_id: @id)
+            @cancellation_recorded = true
+            token = @config[:cancellation_token] || Phronomy::Concurrency::CancellationToken.new
+            token.cancel!
+            @config = @config.merge(cancellation_token: token).freeze
+          end
         end
         execution
       end
 
       def reconcile(failure)
-        task = @runtime.offload.submit(on_full: :raise) do
+        task = @environment.submit(on_full: :raise) do
           execution = read_execution
           if execution&.terminal?
             materialize(execution)
@@ -145,7 +165,7 @@ module Phronomy
       end
 
       def materialize(execution)
-        result = @agent.persistence.execution_result(execution.execution_id)
+        result = @agent.persistence.result(execution.execution_id)
         result.merge(output: result[:result]).freeze
       end
     end

data/lib/phronomy/agent/{execution_cancellation.rb → execution/execution_cancellation.rb}

@@ -9,14 +9,17 @@ module Phronomy
       Command = Data.define(:coordinator, :execution_id, :agent_id)
       private_constant :Command
 
-      def self.signal(execution_id, agent_id)
-        command = Command.new(coordinator: new, execution_id: execution_id, agent_id: agent_id)
-        Phronomy::Runtime.instance.event_loop.post(Phronomy::Event.new(type: :agent_terminal_ready,
-          target_id: Phronomy::EventLoop::SYSTEM_CHANNEL_ID, payload: {command: command}))
+      def self.signal(execution_id, agent_id, environment:)
+        command = Command.new(coordinator: new(environment), execution_id: execution_id, agent_id: agent_id)
+        environment.registry.post(command)
+      end
+
+      def initialize(environment)
+        @environment = environment
       end
 
       def deliver_on_event_loop(command)
-        state = Phronomy::Runtime.instance.event_loop.agent_execution_state(command.execution_id)
+        state = @environment.registry.agent_execution_state(command.execution_id)
         return unless state && state.agent.agent_id == command.agent_id
         state.invocation&.config&.fetch(:cancellation_token, nil)&.cancel!
       end