phronomy 0.27.0 → 0.29.0

data/lib/phronomy/agent/persistence/cancellation_repository.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Persistence
+      # Cancellation is monotonic and independent of the in-flight execution
+      # revision. Recording intent cannot invalidate a worker's captured base.
+      # @api private
+      class CancellationRepository
+        include Phronomy::Storage::RecordCodec
+
+        def initialize(view) = @view = view
+
+        def requested?(agent_id, execution_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic do |view|
+              entry = view.records(StorageSchema::CANCELLATIONS).read(execution_id)
+              next false unless entry
+              payload = current_payload!(entry.record, record_type: "phronomy.agent_cancellation", format_version: "0.1",
+                keys: %w[agent_id execution_id], label: "Agent cancellation")
+              unless payload == {"agent_id" => agent_id, "execution_id" => execution_id} && entry.attributes == {owner: agent_id}
+                raise Phronomy::Storage::SerializationError, "Cancellation owner mismatch"
+              end
+              true
+            end
+          end
+        end
+
+        def request(agent_id, execution_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic do |view|
+              view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: agent_id)], conditions: [])
+              unless self.class.new(view).requested?(agent_id, execution_id)
+                view.records(StorageSchema::CANCELLATIONS).insert(key: execution_id, revision: 0,
+                  attributes: {owner: agent_id}, record: build_record("phronomy.agent_cancellation", "0.1",
+                    {"agent_id" => agent_id, "execution_id" => execution_id}))
+              end
+            end
+          end
+          true
+        end
+
+        def delete_for_agent(agent_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.records(StorageSchema::CANCELLATIONS).delete_matching(index: :owner, equals: {owner: agent_id})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/persistence/codec.rb

@@ -11,7 +11,7 @@ module Phronomy
         AGENT_ROOT_RECORD_TYPE = "phronomy.agent_root"
         AGENT_ROOT_FORMAT_VERSION = "0.1"
         AGENT_EXECUTION_RECORD_TYPE = "phronomy.agent_execution"
-        AGENT_EXECUTION_FORMAT_VERSION = "0.1"
+        AGENT_EXECUTION_FORMAT_VERSION = "0.2"
         JOURNAL_RECORD_TYPE = "phronomy.journal_record"
         JOURNAL_FORMAT_VERSION = "0.1"
         AGENT_ROOT_KEYS = %w[
@@ -48,26 +48,6 @@ module Phronomy
 
         module_function
 
-        def encode_handoff_state(value)
-          payload = value.to_h
-          Phronomy::Agent::HandoffState.from_h(payload)
-          build_record("phronomy.handoff_state", "0.1", payload)
-        rescue Phronomy::Storage::SerializationError
-          raise
-        rescue => error
-          serialization_error("cannot encode HandoffState", error)
-        end
-
-        def decode_handoff_state(record)
-          payload = current_payload!(record, record_type: "phronomy.handoff_state",
-            format_version: "0.1", keys: Phronomy::Agent::HandoffState::ATTRIBUTES, label: "HandoffState")
-          Phronomy::Agent::HandoffState.from_h(payload)
-        rescue Phronomy::Storage::SerializationError
-          raise
-        rescue => error
-          serialization_error("cannot decode HandoffState", error)
-        end
-
         def encode_agent_root(root)
           payload = top_level_string_keys(root.to_h, label: "AgentRoot payload")
           payload["lifecycle_status"] = root.lifecycle_status.to_s

data/lib/phronomy/agent/persistence/execution_repository.rb

@@ -9,75 +9,91 @@ module Phronomy
         def initialize(view) = @view = view
 
         def create_active(execution)
-          raise Phronomy::Storage::SerializationError, "create_active requires an active AgentExecution" unless execution.active?
-          record = Codec.encode_agent_execution(execution)
-          admission do
-            @view.atomic do |bound|
-              entry = bound.records(StorageSchema::EXECUTIONS).insert(key: execution.execution_id.to_s,
-                revision: Integer(execution.execution_revision), attributes: attributes(execution), record: record)
-              decode(entry, execution.execution_id, owner: execution.agent_id,
-                revision: execution.execution_revision, active: true)
+          Phronomy::Persistence::StorageBoundary.call do
+            raise Phronomy::Storage::SerializationError, "create_active requires an active AgentExecution" unless execution.active?
+            record = Codec.encode_agent_execution(execution)
+            admission do
+              @view.atomic do |bound|
+                entry = bound.records(StorageSchema::EXECUTIONS).insert(key: execution.execution_id.to_s,
+                  revision: Integer(execution.execution_revision), attributes: attributes(execution), record: record)
+                decode(entry, execution.execution_id, owner: execution.agent_id,
+                  revision: execution.execution_revision, active: true)
+              end
             end
           end
         end
 
         def load(execution_id)
-          value = @view.atomic do |bound|
-            entry = bound.records(StorageSchema::EXECUTIONS).read(execution_id.to_s)
-            entry && decode(entry, execution_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            value = @view.atomic do |bound|
+              entry = bound.records(StorageSchema::EXECUTIONS).read(execution_id.to_s)
+              entry && decode(entry, execution_id)
+            end
+            value || raise(Phronomy::Storage::NotFoundError, "Execution not found: #{execution_id}")
           end
-          value || raise(Phronomy::Storage::NotFoundError, "Execution not found: #{execution_id}")
         end
 
         def save(execution_id, expected_revision:, execution:)
-          expected = Integer(expected_revision)
-          revision = Integer(execution.execution_revision)
-          raise Phronomy::Storage::ConflictError, "execution save must advance revision exactly once" unless revision == expected + 1
-          unless execution.execution_id.to_s == execution_id.to_s
-            raise Phronomy::Storage::SerializationError, "Execution identity mismatch"
-          end
-          record = Codec.encode_agent_execution(execution)
-          admission do
-            @view.atomic do |bound|
-              entry = bound.records(StorageSchema::EXECUTIONS).replace(key: execution_id.to_s,
-                expected_revision: expected, next_revision: revision, attributes: attributes(execution),
-                expected_attributes: {}, record: record)
-              decode(entry, execution_id, owner: execution.agent_id, revision: revision, active: execution.active?)
+          Phronomy::Persistence::StorageBoundary.call do
+            expected = Integer(expected_revision)
+            revision = Integer(execution.execution_revision)
+            raise Phronomy::Storage::ConflictError, "execution save must advance revision exactly once" unless revision == expected + 1
+            unless execution.execution_id.to_s == execution_id.to_s
+              raise Phronomy::Storage::SerializationError, "Execution identity mismatch"
+            end
+            record = Codec.encode_agent_execution(execution)
+            admission do
+              @view.atomic do |bound|
+                entry = bound.records(StorageSchema::EXECUTIONS).replace(key: execution_id.to_s,
+                  expected_revision: expected, next_revision: revision, attributes: attributes(execution),
+                  expected_attributes: {}, record: record)
+                decode(entry, execution_id, owner: execution.agent_id, revision: revision, active: execution.active?)
+              end
             end
           end
         end
 
         def list_active(agent_id)
-          @view.atomic do |bound|
-            bound.records(StorageSchema::EXECUTIONS).scan(index: :owner_active,
-              equals: {owner: agent_id.to_s, active: true}).map { |entry| decode(entry, entry.key, owner: agent_id, active: true) }.freeze
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic do |bound|
+              bound.records(StorageSchema::EXECUTIONS).scan(index: :owner_active,
+                equals: {owner: agent_id.to_s, active: true}).map { |entry| decode(entry, entry.key, owner: agent_id, active: true) }.freeze
+            end
           end
         end
 
         def list(agent_id, after: nil, limit: 100)
-          raise ArgumentError, "limit must be a positive Integer" unless limit.is_a?(Integer) && limit.positive?
-          @view.atomic do |bound|
-            bound.records(StorageSchema::EXECUTIONS).scan(index: :owner, equals: {owner: agent_id.to_s},
-              after: after&.to_s, limit: limit).map { |entry| decode(entry, entry.key, owner: agent_id) }.freeze
+          Phronomy::Persistence::StorageBoundary.call do
+            raise ArgumentError, "limit must be a positive Integer" unless limit.is_a?(Integer) && limit.positive?
+            @view.atomic do |bound|
+              bound.records(StorageSchema::EXECUTIONS).scan(index: :owner, equals: {owner: agent_id.to_s},
+                after: after&.to_s, limit: limit).map { |entry| decode(entry, entry.key, owner: agent_id) }.freeze
+            end
           end
         end
 
         def delete(execution_id)
-          @view.records(StorageSchema::EXECUTIONS).delete(key: execution_id.to_s)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.records(StorageSchema::EXECUTIONS).delete(key: execution_id.to_s)
+          end
         end
 
         def delete_for_agent(agent_id)
-          @view.records(StorageSchema::EXECUTIONS).delete_matching(index: :owner, equals: {owner: agent_id.to_s})
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.records(StorageSchema::EXECUTIONS).delete_matching(index: :owner, equals: {owner: agent_id.to_s})
+          end
         end
 
         def assert_idle!(agent_id)
-          condition = Phronomy::Storage::Condition::NoRows.new(resource: StorageSchema::EXECUTIONS,
-            index: :owner_active, equals: {owner: agent_id.to_s, active: true})
-          @view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: agent_id.to_s)],
-            conditions: [condition])
-        rescue Phronomy::Storage::ConditionFailedError => error
-          raise unless error.condition.equal?(condition)
-          raise Phronomy::AgentBusyError, error.message
+          Phronomy::Persistence::StorageBoundary.call do
+            condition = Phronomy::Storage::Condition::NoRows.new(resource: StorageSchema::EXECUTIONS,
+              index: :owner_active, equals: {owner: agent_id.to_s, active: true})
+            @view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: agent_id.to_s)],
+              conditions: [condition])
+          rescue Phronomy::Storage::ConditionFailedError => error
+            raise unless error.condition.equal?(condition)
+            raise Phronomy::AgentBusyError, error.message
+          end
         end
 
         private

data/lib/phronomy/agent/persistence/journal_repository.rb

@@ -9,32 +9,41 @@ module Phronomy
         def initialize(view) = @view = view
 
         def append(agent_id, expected_position:, records:)
-          expected = Integer(expected_position)
-          entries = Array(records).each_with_index.map do |record, index|
-            unless record.agent_id.to_s == agent_id.to_s
-              raise Phronomy::Storage::SerializationError, "Journal record Agent mismatch"
+          Phronomy::Persistence::StorageBoundary.call do
+            expected = Integer(expected_position)
+            entries = Array(records).each_with_index.map do |record, index|
+              unless record.agent_id.to_s == agent_id.to_s
+                raise Phronomy::Storage::SerializationError, "Journal record Agent mismatch"
+              end
+              sequenced = record.with_sequence(expected + index + 1)
+              Phronomy::Storage::Entry::Append.new(id: sequenced.record_id.to_s, record: Codec.encode_journal_record(sequenced))
+            end
+            @view.atomic do |bound|
+              stored = bound.streams(StorageSchema::JOURNAL).append(stream: agent_id.to_s,
+                expected_head: expected, entries: entries)
+              decode(stored, agent_id, after: expected)
             end
-            sequenced = record.with_sequence(expected + index + 1)
-            Phronomy::Storage::Entry::Append.new(id: sequenced.record_id.to_s, record: Codec.encode_journal_record(sequenced))
-          end
-          @view.atomic do |bound|
-            stored = bound.streams(StorageSchema::JOURNAL).append(stream: agent_id.to_s,
-              expected_head: expected, entries: entries)
-            decode(stored, agent_id, after: expected)
           end
         end
 
         def read(agent_id, after: nil, limit: nil)
-          position = after.nil? ? 0 : Integer(after)
-          count = limit.nil? ? nil : Integer(limit)
-          @view.atomic do |bound|
-            stored = (count == 0) ? [] : bound.streams(StorageSchema::JOURNAL).read(stream: agent_id.to_s, after: position, limit: count)
-            decode(stored, agent_id, after: position)
+          Phronomy::Persistence::StorageBoundary.call do
+            position = after.nil? ? 0 : Integer(after)
+            count = limit.nil? ? nil : Integer(limit)
+            @view.atomic do |bound|
+              stored = (count == 0) ? [] : bound.streams(StorageSchema::JOURNAL).read(stream: agent_id.to_s, after: position, limit: count)
+              decode(stored, agent_id, after: position)
+            end
           end
         end
 
-        def head(agent_id) = @view.streams(StorageSchema::JOURNAL).head(stream: agent_id.to_s)
-        def delete(agent_id) = @view.streams(StorageSchema::JOURNAL).delete(stream: agent_id.to_s)
+        def head(agent_id)
+          Phronomy::Persistence::StorageBoundary.call { @view.streams(StorageSchema::JOURNAL).head(stream: agent_id.to_s) }
+        end
+
+        def delete(agent_id)
+          Phronomy::Persistence::StorageBoundary.call { @view.streams(StorageSchema::JOURNAL).delete(stream: agent_id.to_s) }
+        end
 
         private
 

data/lib/phronomy/agent/persistence/records.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Persistence
+      # Storage implementation of Agent's own record operations.
+      # @api private
+      class Records
+        attr_reader :contents, :agents, :journals, :executions, :retentions, :cancellations
+
+        def initialize(view)
+          @view = view
+          @contents = Phronomy::Persistence::ContentRepository.new(Phronomy::ContentStore::StoredContents.new(view))
+          @agents = AgentRepository.new(view)
+          @journals = JournalRepository.new(view)
+          @executions = ExecutionRepository.new(view)
+          @retentions = RetentionRepository.new(view)
+          @cancellations = CancellationRepository.new(view)
+        end
+
+        def assert_agent_watermark!(agent_id:, agent_revision:, journal_position:)
+          Watermark.new(@view).check!(agent_id: agent_id, agent_revision: agent_revision, journal_position: journal_position)
+        end
+
+        def guard_agent!(agent_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: agent_id)], conditions: [])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/persistence/retention_repository.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Phronomy
+  module Agent
+    module Persistence
+      # @api private
+      class RetentionRepository
+        include Phronomy::Storage::RecordCodec
+
+        def initialize(view) = @view = view
+
+        def retain(retention)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic do |view|
+              guard!(view, retention.agent_id)
+              records = view.records(StorageSchema::RETENTIONS)
+              key = Digest::SHA256.hexdigest(Phronomy::CanonicalJSON.dump(retention.to_h))
+              if (existing = records.read(key))
+                raise Phronomy::Storage::SerializationError, "retention identity mismatch" unless decode(existing) == retention
+              else
+                records.insert(key: key, revision: 0,
+                  attributes: {owner: retention.agent_id, holder: retention.owner_key},
+                  record: build_record("phronomy.agent_retention", "0.1", retention.to_h))
+              end
+            end
+          end
+          retention
+        end
+
+        def list(agent_id)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic { |view| view.records(StorageSchema::RETENTIONS).scan(index: :owner, equals: {owner: agent_id}).map { |entry| decode(entry) }.freeze }
+          end
+        end
+
+        def release(agent_id:, owner_key:)
+          Phronomy::Persistence::StorageBoundary.call do
+            @view.atomic do |view|
+              guard!(view, agent_id)
+              records = view.records(StorageSchema::RETENTIONS)
+              records.scan(index: :owner, equals: {owner: agent_id}).each do |entry|
+                value = decode(entry)
+                records.delete(key: entry.key, expected_revision: entry.revision) if value.owner_key == owner_key
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        def guard!(view, id)
+          view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: id)], conditions: [])
+        end
+
+        def decode(entry)
+          payload = current_payload!(entry.record, record_type: "phronomy.agent_retention", format_version: "0.1",
+            keys: %w[agent_id execution_id owner_key], label: "Agent retention")
+          value = Retention.new(**payload.transform_keys(&:to_sym))
+          unless entry.attributes == {owner: value.agent_id, holder: value.owner_key}
+            raise Phronomy::Storage::SerializationError, "retention attributes mismatch"
+          end
+          value
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/persistence/storage_schema.rb

@@ -16,8 +16,13 @@ module Phronomy
 
         JOURNAL = Phronomy::Storage::Resource.new(id: "agent.journal", kind: :streams,
           guard: {resource: ROOTS.id, via: :stream})
-        HANDOFF_STATES = Phronomy::Storage::Resource.new(id: "handoff.states", kind: :records,
-          attributes: {active_agent_id: :string})
+        CANCELLATIONS = Phronomy::Storage::Resource.new(id: "agent.cancellations", kind: :records,
+          attributes: {owner: :string}, immutable_attributes: [:owner], indexes: {owner: [:owner]},
+          guard: {resource: ROOTS.id, via: :owner})
+        RETENTIONS = Phronomy::Storage::Resource.new(id: "agent.retentions", kind: :records,
+          attributes: {owner: :string, holder: :string}, immutable_attributes: [:owner, :holder],
+          indexes: {owner: [:owner], holder: [:holder]},
+          guard: {resource: ROOTS.id, via: :owner})
       end
     end
   end

data/lib/phronomy/agent/persistence/watermark.rb

@@ -9,17 +9,19 @@ module Phronomy
         def initialize(view) = @view = view
 
         def check!(agent_id:, agent_revision:, journal_position:)
-          key = agent_id.to_s
-          @view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: key)],
-            conditions: [
-              Phronomy::Storage::Condition::RevisionIs.new(resource: StorageSchema::ROOTS,
-                key: key, expected: Integer(agent_revision)),
-              Phronomy::Storage::Condition::StreamHeadIs.new(resource: StorageSchema::JOURNAL,
-                stream: key, expected: Integer(journal_position))
-            ])
-        rescue Phronomy::Storage::ConditionFailedError => error
-          label = error.condition.is_a?(Phronomy::Storage::Condition::RevisionIs) ? "agent revision" : "journal position"
-          raise Phronomy::Storage::ConflictError, "#{label} conflict"
+          Phronomy::Persistence::StorageBoundary.call do
+            key = agent_id.to_s
+            @view.check!(guards: [Phronomy::Storage::GuardRef.new(resource: StorageSchema::ROOTS, key: key)],
+              conditions: [
+                Phronomy::Storage::Condition::RevisionIs.new(resource: StorageSchema::ROOTS,
+                  key: key, expected: Integer(agent_revision)),
+                Phronomy::Storage::Condition::StreamHeadIs.new(resource: StorageSchema::JOURNAL,
+                  stream: key, expected: Integer(journal_position))
+              ])
+          rescue Phronomy::Storage::ConditionFailedError => error
+            label = error.condition.is_a?(Phronomy::Storage::Condition::RevisionIs) ? "agent revision" : "journal position"
+            raise Phronomy::Storage::ConflictError, "#{label} conflict"
+          end
         end
       end
     end

data/lib/phronomy/agent/recovery/invocation_restorer.rb

@@ -8,7 +8,7 @@ module Phronomy
     module InvocationRestorer
       module_function
 
-      def build_invocation_for_suspended(agent, execution, projection, main_coordinator, listener, assistant_message:)
+      def build_invocation_for_suspended(agent, execution, projection, main_coordinator, listener, assistant_message:, cancellation_requested: false)
         request = execution.approval_request && Phronomy::Agent::ToolApprovalRequest.from_h(
           execution.approval_request
         )
@@ -18,10 +18,9 @@ module Phronomy
             "suspended execution #{execution.execution_id} has no durable assistant Tool Call message"
         end
 
-        invocation, chat, config = prepare_invocation(agent, execution, projection, main_coordinator, listener)
-        chat.messages << assistant_message
+        invocation, config = prepare_invocation(agent, execution, projection, main_coordinator, listener, cancellation_requested: cancellation_requested)
+        invocation.messages << assistant_message
 
-        invocation.chat = chat
         invocation.user_message_sent = true
         invocation.approval_request = request
         invocation.instance_variable_set(
@@ -54,7 +53,7 @@ module Phronomy
             raise Phronomy::ExecutionRehydrationRequiredError,
               "Tool Call #{entry.fetch("tool_call_id")} is missing from the durable assistant message"
           end
-          tool = chat.tools[entry.fetch("tool_name").to_sym]
+          tool = invocation.tools[entry.fetch("tool_name").to_sym]
           child = if tool
             Phronomy::Agent::ToolInvocation.new(
               execution_id: execution.execution_id,
@@ -83,24 +82,23 @@ module Phronomy
         invocation
       end
 
-      def build_chat_for_recovery(agent, execution, projection, main_coordinator, listener, messages:)
-        invocation, chat = prepare_invocation(agent, execution, projection, main_coordinator, listener)
+      def build_input_for_recovery(agent, execution, projection, main_coordinator, listener, messages:, cancellation_requested: false)
+        invocation, = prepare_invocation(agent, execution, projection, main_coordinator, listener, cancellation_requested: cancellation_requested)
 
-        messages.each { |message| chat.messages << message }
+        messages.each { |message| invocation.messages << message }
 
-        invocation.chat = chat
         invocation.user_message_sent = true
         invocation
       end
 
-      def prepare_invocation(agent, execution, projection, main_coordinator, listener)
+      def prepare_invocation(agent, execution, projection, main_coordinator, listener, cancellation_requested:)
         config = {
           execution_id: execution.execution_id,
           phronomy_execution_coordinator: main_coordinator,
           phronomy_runtime_projection: projection
-        }.merge(agent.__coordination_config)
+        }.merge(agent.__execution_wiring)
         config = agent.__invocation_config(config)
-        if execution.metadata["coordination_cancel_requested"]
+        if cancellation_requested || execution.metadata["cancellation_requested"]
           config = config.merge(cancellation_token: Phronomy::Concurrency::CancellationToken.new.cancel!)
         end
         invocation = Phronomy::Agent::AgentInvocation.new(
@@ -111,20 +109,14 @@ module Phronomy
           mode: (execution.metadata[ExecutionMetadata::INVOCATION_MODE_KEY] || "invoke").to_sym,
           execution_id: execution.execution_id
         )
-        chat = agent.send(:build_chat, model_config: projection.model_config)
-        agent.send(
-          :_apply_runtime_projection_to_chat,
-          chat,
-          projection,
-          invocation: invocation
-        )
+        agent.send(:prepare_runtime_input, projection, invocation: invocation)
         if projection.ask_message
-          chat.messages << RubyLLM::Message.new(
+          invocation.messages << Phronomy::LLMAdapter::Message.new(
             role: :user,
             content: projection.ask_message
           )
         end
-        [invocation, chat, config]
+        [invocation, config]
       end
       private_class_method :prepare_invocation
     end

data/lib/phronomy/agent/recovery/recovery_coordinator/continuation.rb

@@ -36,40 +36,41 @@ module Phronomy
             _manifest, projection = SavedContextReader.materialize_projection(agent, execution.metadata.fetch("manifest_ref"))
           end
           records = execution.working_records.select { |record| %i[assistant_message tool_message].include?(record.kind.to_sym) }
-          materializer = RubyLLMMaterializer.new(agent: agent, persistence: agent.persistence)
+          materializer = RuntimeInput.new(agent: agent, persistence: agent.persistence)
           messages = records.map { |record| materializer.materialize_journal_record(record) }.freeze
           assistant = messages.reverse.find { |message| message.role.to_sym == :assistant }
           output, usage = SavedContextReader.provider_output_and_usage(agent, execution) if execution.phase.to_sym == :recovery_provider_completed
           RecoveryMaterial.new(projection: projection, messages: messages,
-            assistant_message: assistant, output: output, usage: usage)
+            assistant_message: assistant, output: output, usage: usage,
+            cancellation_requested: agent.persistence.cancellation_requested?(agent_id: agent.agent_id, execution_id: execution.execution_id))
         end
 
         def continue_recovery_on_event_loop(execution, completion, material:)
-          event_loop = @runtime.event_loop
+          environment = @environment
           action = recovery_action(execution)
           if action == :resolution_required
-            Phronomy::Agent::ExecutionRegistry.for(event_loop).mark_agent_execution_admission(agent.agent_id,
+            environment.registry.mark_agent_execution_admission(agent.agent_id,
               execution_id: execution.execution_id, state: :recovery_required)
             deliver_resolution_required(execution, coordination_recovery_descriptor(execution))
-            completion.complete({execution_id: execution.execution_id,
-                                 execution_revision: execution.execution_revision,
-                                 recovery: :resolution_required}.freeze)
+            agent.send(:_complete_result_task, completion, {execution_id: execution.execution_id,
+                                                            execution_revision: execution.execution_revision,
+                                                            recovery: :resolution_required}.freeze)
             return
           end
 
           observe_recovery_execution(completion, execution)
-          main = agent.send(:execution_coordinator_for, agent.__coordination_config)
-          projection = Phronomy::Agent::ExecutionRegistry.for(event_loop).agent_execution_state(execution.execution_id).runtime_projection
+          main = agent.send(:execution_coordinator_for, agent.__execution_wiring)
+          projection = environment.registry.agent_execution_state(execution.execution_id).runtime_projection
           if action == :failed_terminal
             invocation = build_failed_recovery_invocation(execution, main)
           else
             projection = material.projection
             invocation = if action == :framework_tools
               InvocationRestorer.build_invocation_for_suspended(agent, execution, projection, main,
-                agent.send(:_phronomy_event_listener), assistant_message: material.assistant_message)
+                agent.send(:_phronomy_event_listener), assistant_message: material.assistant_message, cancellation_requested: material.cancellation_requested)
             else
-              InvocationRestorer.build_chat_for_recovery(agent, execution, projection, main,
-                agent.send(:_phronomy_event_listener), messages: material.messages)
+              InvocationRestorer.build_input_for_recovery(agent, execution, projection, main,
+                agent.send(:_phronomy_event_listener), messages: material.messages, cancellation_requested: material.cancellation_requested)
             end
             if execution.phase.to_sym == :recovery_provider_completed
               invocation.output, invocation.usage = material.output, material.usage