phronomy 0.25.0 → 0.27.0

data/lib/phronomy/agent/{context_plan.rb → context_contract/context_plan.rb}

@@ -21,7 +21,7 @@ module Phronomy
           knowledge: Array(knowledge).freeze,
           tools: Array(tools).freeze,
           conversation: Array(conversation).map { |group| Array(group).freeze }.freeze,
-          metadata: Immutable.copy(metadata || {})
+          metadata: Phronomy::Values::Immutable.copy(metadata || {})
         )
         freeze
       end

data/lib/phronomy/agent/{context_policy_input.rb → context_contract/context_policy_input.rb}

@@ -50,8 +50,8 @@ module Phronomy
           knowledge: normalized_knowledge,
           tools: normalized_tools,
           conversation: normalized_conversation,
-          model_config: Immutable.copy(values[:model_config] || {}),
-          metadata: Immutable.copy(values[:metadata] || {})
+          model_config: Phronomy::Values::Immutable.copy(values[:model_config] || {}),
+          metadata: Phronomy::Values::Immutable.copy(values[:metadata] || {})
         ))
         freeze
       end
@@ -145,7 +145,7 @@ module Phronomy
       ) do
         def initialize(**values)
           provenance = ContextPolicyInput.send(:normalize_provenance, values[:provenance])
-          definition = Immutable.copy(values.fetch(:definition))
+          definition = Phronomy::Values::Immutable.copy(values.fetch(:definition))
           unless definition.is_a?(Hash) && definition["name"].to_s != ""
             raise ArgumentError, "ContextPolicyInput ToolItem definition requires a non-empty name"
           end
@@ -156,7 +156,7 @@ module Phronomy
             estimated_tokens: ContextPolicyInput.send(:normalize_estimated_tokens, values[:estimated_tokens]),
             required: !!values[:required],
             provenance: provenance,
-            metadata: Immutable.copy(values[:metadata] || {})
+            metadata: Phronomy::Values::Immutable.copy(values[:metadata] || {})
           )
           raise ArgumentError, "ContextPolicyInput ToolItem id must not be empty" if id.empty?
           freeze
@@ -212,12 +212,12 @@ module Phronomy
             id: id,
             kind: kind,
             role: role,
-            content: Immutable.copy(values[:content]),
+            content: Phronomy::Values::Immutable.copy(values[:content]),
             content_format: content_format,
             estimated_tokens: normalize_estimated_tokens(values[:estimated_tokens]),
             required: !!values[:required],
             provenance: normalize_provenance(values[:provenance]),
-            metadata: Immutable.copy(values[:metadata] || {})
+            metadata: Phronomy::Values::Immutable.copy(values[:metadata] || {})
           }
         end
 

data/lib/phronomy/agent/{llm_input_build_context.rb → context_contract/llm_input_build_context.rb}

@@ -9,7 +9,7 @@ module Phronomy
       :config, :call_sequence
     ) do
       def initialize(**values)
-        super(**values.merge(config: Immutable.copy(values.fetch(:config, {}))))
+        super(**values.merge(config: Phronomy::Values::Immutable.copy(values.fetch(:config, {}))))
         freeze
       end
     end

data/lib/phronomy/agent/{llm_input_manifest.rb → context_contract/llm_input_manifest.rb}

@@ -3,7 +3,7 @@
 module Phronomy
   module Agent
     # ContentStore-backed durable codec boundary for one Provider input manifest.
-    # It is intentionally separate from Persistence::DurableRecord.
+    # It is intentionally separate from Storage::DurableRecord.
     class LLMInputManifest
       VERSION = "0.1"
       CALL_MODES = %i[ask complete].freeze
@@ -18,7 +18,7 @@ module Phronomy
           if delivery.nil? || !SEGMENT_DELIVERIES.include?(delivery.to_s)
             raise ArgumentError, "unknown Segment delivery: #{delivery.inspect}"
           end
-          super(**values.merge(metadata: Immutable.copy(values[:metadata] || {})))
+          super(**values.merge(metadata: Phronomy::Values::Immutable.copy(values[:metadata] || {})))
           freeze
         end
 
@@ -62,7 +62,7 @@ module Phronomy
             label: label
           )
           unless SEGMENT_DELIVERIES.include?(delivery)
-            raise Phronomy::Persistence::SerializationError,
+            raise Phronomy::Storage::SerializationError,
               "LLMInputManifest segment delivery must be one of #{SEGMENT_DELIVERIES.inspect}, got #{delivery.inspect}"
           end
           tool_call_id = LLMInputManifest.send(
@@ -87,10 +87,10 @@ module Phronomy
             tool_call_id: tool_call_id,
             metadata: metadata
           )
-        rescue Phronomy::Persistence::SerializationError
+        rescue Phronomy::Storage::SerializationError
           raise
         rescue => error
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "invalid LLMInputManifest segment: #{error.class}: #{error.message}"
         end
 
@@ -162,7 +162,7 @@ module Phronomy
         label = "LLMInputManifest"
         version = source.fetch("version")
         unless version.is_a?(String) && version == VERSION
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "unsupported LLMInputManifest version: #{version.inspect}; " \
             "current version is #{VERSION.inspect}"
         end
@@ -229,10 +229,10 @@ module Phronomy
           adapter_name: adapter_name,
           adapter_version: adapter_version
         )
-      rescue Phronomy::Persistence::SerializationError
+      rescue Phronomy::Storage::SerializationError
         raise
       rescue => error
-        raise Phronomy::Persistence::SerializationError,
+        raise Phronomy::Storage::SerializationError,
           "invalid LLMInputManifest: #{error.class}: #{error.message}"
       end
 
@@ -262,11 +262,11 @@ module Phronomy
 
         def strict_source!(hash, required:, optional:, label:)
           unless hash.is_a?(Hash)
-            raise Phronomy::Persistence::SerializationError,
+            raise Phronomy::Storage::SerializationError,
               "#{label} must be a Hash"
           end
           unless hash.keys.all? { |key| key.is_a?(String) }
-            raise Phronomy::Persistence::SerializationError,
+            raise Phronomy::Storage::SerializationError,
               "#{label} keys must all be String"
           end
 
@@ -277,13 +277,13 @@ module Phronomy
             details = []
             details << "missing=#{missing.inspect}" unless missing.empty?
             details << "unknown=#{unknown.inspect}" unless unknown.empty?
-            raise Phronomy::Persistence::SerializationError,
+            raise Phronomy::Storage::SerializationError,
               "#{label} schema mismatch (#{details.join(", ")})"
           end
           Phronomy::CanonicalJSON.dump(hash)
           hash
         rescue ArgumentError => error
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} is not canonical JSON compatible: #{error.message}"
         end
 
@@ -291,7 +291,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(Integer)
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be an Integer"
         end
 
@@ -299,7 +299,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(Integer) && value.positive?
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be a positive Integer"
         end
 
@@ -307,7 +307,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(Integer) && value >= 0
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be a non-negative Integer"
         end
 
@@ -315,7 +315,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(String) && !value.empty?
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be a non-empty String"
         end
 
@@ -323,7 +323,7 @@ module Phronomy
           value = hash[key]
           return value if value.nil? || value.is_a?(String)
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be a String or nil"
         end
 
@@ -331,7 +331,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(String) && allowed.include?(value)
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be one of #{allowed.inspect}"
         end
 
@@ -339,7 +339,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(Array)
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be an Array"
         end
 
@@ -347,7 +347,7 @@ module Phronomy
           value = hash.fetch(key)
           return value if value.is_a?(Hash)
 
-          raise Phronomy::Persistence::SerializationError,
+          raise Phronomy::Storage::SerializationError,
             "#{label} #{key} must be a Hash"
         end
       end

data/lib/phronomy/agent/{llm_input_patch.rb → context_contract/llm_input_patch.rb}

@@ -7,8 +7,8 @@ module Phronomy
     LLMInputPatch = Data.define(:model_config_patch, :segment_candidates) do
       def initialize(model_config_patch: nil, segment_candidates: nil)
         super(
-          model_config_patch: model_config_patch && Immutable.copy(model_config_patch),
-          segment_candidates: segment_candidates && Immutable.copy(Array(segment_candidates))
+          model_config_patch: model_config_patch && Phronomy::Values::Immutable.copy(model_config_patch),
+          segment_candidates: segment_candidates && Phronomy::Values::Immutable.copy(Array(segment_candidates))
         )
         freeze
       end

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

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "../../engine/concurrency/worker_input_restricted"
+
 require "securerandom"
 require "time"
 
 module Phronomy
   module Agent
     class AgentExecution
+      include Phronomy::Concurrency::WorkerInputRestricted
+
       ACTIVE_STATUSES = %i[preparing active suspended].freeze
       TERMINAL_STATUSES = %i[completed handed_off failed cancelled rejected blocked].freeze
       TRANSITIONS = {
@@ -55,13 +59,13 @@ module Phronomy
         ATTRIBUTES.each do |name|
           value = attributes.fetch(name)
           value = value.to_sym if %i[status phase].include?(name)
-          instance_variable_set("@#{name}", Immutable.copy(value))
+          instance_variable_set("@#{name}", Phronomy::Values::Immutable.copy(value))
         end
         raise ArgumentError, "unknown execution status: #{status.inspect}" unless TRANSITIONS.key?(status)
         raise ArgumentError, "execution_revision must be non-negative" if execution_revision.negative?
-        Immutable.validate_canonical_json!(metadata, label: "Execution metadata")
+        Phronomy::Values::Immutable.validate_canonical_json!(metadata, label: "Execution metadata")
         if approval_request
-          Immutable.validate_canonical_json!(approval_request, label: "Approval request")
+          Phronomy::Values::Immutable.validate_canonical_json!(approval_request, label: "Approval request")
         end
         freeze
       end
@@ -86,7 +90,7 @@ module Phronomy
       end
 
       # Current semantic payload representation. Persistence format identity and
-      # compatibility validation are owned by Persistence::DurableCodec.
+      # compatibility validation are owned by Agent::Persistence::Codec.
       # @api public
       def to_h
         ATTRIBUTES.to_h do |name|

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

@@ -1,22 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "../../engine/concurrency/worker_input_restricted"
+
 require "securerandom"
 require "time"
 
 module Phronomy
   module Agent
     class AgentInvocation
+      include Phronomy::Concurrency::WorkerInputRestricted
+
       # execution_id is the logical Agent execution parent. Concrete Runtime
       # routing identity belongs only to the owning FSMSession incarnation.
-      TOOL_EVENT_TYPES = %i[
-        tool_authorized
-        tool_approval_required
-        tool_completed
-        tool_failed
-        tool_rejected
-        tool_cancelled
-      ].freeze
-
       LLM_EVENT_TYPES = %i[llm_completed llm_failed].freeze
       CALLBACK_FAILED_EVENTS = %i[application_callback_failed].freeze
       SETUP_FAILED_EVENTS = %i[llm_setup_failed tool_setup_failed].freeze
@@ -147,11 +142,11 @@ module Phronomy
         if durable_id.nil? &&
             Phronomy::Runtime.instance.event_loop.current?
           state =
-            Phronomy::Runtime.instance.event_loop.agent_execution_state(
+            Phronomy::Agent::ExecutionRegistry.for(Phronomy::Runtime.instance.event_loop).agent_execution_state(
               execution_id
             )
           durable_id = state&.execution&.metadata&.fetch(
-            RecoverySupport::PENDING_LLM_ID_KEY,
+            ExecutionMetadata::PENDING_LLM_ID_KEY,
             nil
           )
         end
@@ -209,7 +204,7 @@ module Phronomy
           return true
         end
 
-        return false unless TOOL_EVENT_TYPES.include?(event.type)
+        return false unless InvocationTransitions::TOOL_EVENTS.include?(event.type)
 
         invocation = tool_invocation(event.payload&.fetch(:tool_invocation_id, nil))
         return true unless invocation
@@ -540,7 +535,7 @@ module Phronomy
         # listener receives the notification event separately.
         @runtime_events << StreamEvent.new(
           type: event.type,
-          payload: Immutable.copy(event.payload)
+          payload: Phronomy::Values::Immutable.copy(event.payload)
         )
         listener = @callback_failure ? nil : @event_listener
         return unless listener

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

@@ -3,33 +3,6 @@
 module Phronomy
   module Agent
     class AgentInvocationSessionBuilder
-      AUTO_STATE_SET = {
-        idle: true,
-        filtering_input: true,
-        building_context: true,
-        starting_tools: true,
-        evaluating_tools: true,
-        recording_tool_results: true,
-        output_filtering: true
-      }.freeze
-
-      DECLARED_STATES = %i[
-        idle filtering_input building_context calling_llm starting_tools
-        evaluating_tools waiting_for_tools dispatching_tools
-        recording_tool_results suspended output_filtering handed_off completed blocked failed
-      ].freeze
-
-      WAIT_STATES = %i[suspended].freeze
-
-      TOOL_EVENTS = %i[
-        tool_authorized
-        tool_approval_required
-        tool_completed
-        tool_failed
-        tool_rejected
-        tool_cancelled
-      ].freeze
-
       def self.build(
         agent:,
         input:,
@@ -93,13 +66,13 @@ module Phronomy
         Phronomy::FSMSession.new(
           context: agent_invocation,
           event_sink: event_sink,
-          entry_point: :idle,
+          entry_point: InvocationTransitions::ENTRY_POINT,
           phase_machine_class: phase_machine,
           entry_actions: {},
-          auto_state_set: AUTO_STATE_SET,
-          declared_states: DECLARED_STATES,
-          wait_state_names: WAIT_STATES,
-          external_events: external_events,
+          auto_state_set: InvocationTransitions::AUTO_STATE_SET,
+          declared_states: InvocationTransitions::DECLARED_STATES,
+          wait_state_names: InvocationTransitions::WAIT_STATES,
+          external_events: InvocationTransitions::EXTERNAL_EVENTS,
           recursion_limit: 12 + (iterations * 8),
           event_loop: runtime.event_loop,
           resume_event: resume_event,
@@ -108,49 +81,6 @@ module Phronomy
       end
       private_class_method :build_session
 
-      def self.external_events
-        tool_transitions = TOOL_EVENTS.to_h do |event_name|
-          [event_name, [{from: :waiting_for_tools, to: :evaluating_tools, guard: nil}]]
-        end
-
-        tool_transitions.merge(
-          llm_completed: [
-            {from: :calling_llm, to: :failed, guard: ->(ctx) { ctx.callback_failed? }},
-            {from: :calling_llm, to: :failed, guard: ->(ctx) { ctx.handoff_failed? }},
-            {from: :calling_llm, to: :handed_off, guard: ->(ctx) { ctx.handoff_requested? }},
-            {from: :calling_llm, to: :starting_tools, guard: ->(ctx) { ctx.tool_call_pending? }},
-            {from: :calling_llm, to: :output_filtering, guard: nil}
-          ],
-          llm_failed: [
-            {from: :calling_llm, to: :failed, guard: nil}
-          ],
-          llm_setup_failed: [
-            {from: :calling_llm, to: :failed, guard: nil}
-          ],
-          tool_setup_failed: [
-            {from: :dispatching_tools, to: :failed, guard: nil}
-          ],
-          tool_dispatch_prepared: [
-            {from: :dispatching_tools, to: :evaluating_tools, guard: nil}
-          ],
-          resume: [
-            {from: :suspended, to: :waiting_for_tools, guard: nil}
-          ],
-          application_callback_failed: [
-            {from: :filtering_input, to: :failed, guard: nil},
-            {from: :building_context, to: :failed, guard: nil},
-            {from: :calling_llm, to: :failed, guard: nil},
-            {from: :starting_tools, to: :failed, guard: nil},
-            {from: :evaluating_tools, to: :failed, guard: nil},
-            {from: :waiting_for_tools, to: :failed, guard: nil},
-            {from: :dispatching_tools, to: :failed, guard: nil},
-            {from: :recording_tool_results, to: :failed, guard: nil},
-            {from: :output_filtering, to: :failed, guard: nil}
-          ]
-        )
-      end
-      private_class_method :external_events
-
       def self.build_entry_actions(agent, runtime, mode:, event_sink:)
         calling_action = if mode.to_sym == :stream
           method(:calling_llm_stream_action).curry.call(agent, runtime, event_sink)
@@ -159,8 +89,8 @@ module Phronomy
         end
 
         {
-          filtering_input: [method(:filtering_input_action).curry.call(agent)],
-          building_context: [method(:building_context_action).curry.call(agent)],
+          filtering_input: [method(:apply_prepared_input_action).curry.call(agent)],
+          building_context: [method(:build_runtime_chat_action).curry.call(agent)],
           calling_llm: [calling_action],
           starting_tools: [method(:starting_tools_action).curry.call(runtime, event_sink)],
           dispatching_tools: [method(:dispatching_tools_action).curry.call(runtime, event_sink)],
@@ -172,13 +102,13 @@ module Phronomy
       end
       private_class_method :build_entry_actions
 
-      def self.filtering_input_action(_agent, invocation)
+      def self.apply_prepared_input_action(_agent, invocation)
         invocation.input = invocation.config.fetch(:phronomy_filtered_input)
         invocation
       end
-      private_class_method :filtering_input_action
+      private_class_method :apply_prepared_input_action
 
-      def self.building_context_action(agent, invocation)
+      def self.build_runtime_chat_action(agent, invocation)
         projection = invocation.config.fetch(:phronomy_runtime_projection)
         invocation.chat = agent.send(:build_chat, model_config: projection.model_config)
         agent.send(
@@ -189,22 +119,16 @@ module Phronomy
         )
         invocation
       end
-      private_class_method :building_context_action
+      private_class_method :build_runtime_chat_action
 
       def self.install_tool_interceptors(chat, llm_call_id:)
-        unless chat.respond_to?(:before_tool_call)
-          raise Phronomy::ConfigurationError,
-            "Agent-owned Tool execution requires RubyLLM >= 1.15 (before_tool_call callback)"
-        end
-
-        if chat.respond_to?(:on_tool_call_batch)
-          chat.on_tool_call_batch do |tool_calls|
-            raise build_tool_interception(chat, tool_calls, llm_call_id)
-          end
-        end
+        # RubyLLM 2 records the complete assistant message before this callback,
+        # and checks its own approval gate afterwards. Capture here so Phronomy
+        # owns authorization and dispatch for the entire Tool batch.
+        chat.after_message do |message|
+          next unless message.tool_call?
 
-        chat.before_tool_call do |tool_call|
-          raise build_tool_interception(chat, [tool_call], llm_call_id)
+          raise build_tool_interception(chat, [], llm_call_id)
         end
       end
       private_class_method :install_tool_interceptors
@@ -347,7 +271,7 @@ module Phronomy
             chat, message, config: config
           )
         end
-        runtime.event_loop.supervise_agent_operation(
+        Phronomy::Agent::ExecutionRegistry.for(runtime.event_loop).supervise_agent_operation(
           invocation.execution_id,
           operation
         )
@@ -456,7 +380,7 @@ module Phronomy
         children = invocation.pending_tool_calls.map do |tool_call|
           tool = invocation.chat.tools[tool_call.name.to_sym]
           tool_invocation_id =
-            RecoverySupport.semantic_tool_id(
+            ToolInvocation.semantic_id(
               execution_id: invocation.execution_id,
               llm_call_id: invocation.tool_batch_llm_call_id,
               tool_call_id: (
@@ -542,7 +466,7 @@ module Phronomy
       end
 
       def self.register_child_session(runtime, child, session, parent_event_sink)
-        completion = Phronomy::Task.deferred(name: "tool-session:#{child.id}")
+        completion = Phronomy::TaskResult.deferred(name: "tool-session:#{child.id}")
         completion.on_complete do |_result, error|
           next unless error
 

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "../../engine/concurrency/worker_input_restricted"
+
+module Phronomy
+  module Agent
+    # Persists one approval decision with its captured recovery facts.
+    # Admission, live state and session resumption stay with the execution owner.
+    # @api private
+    class ApprovalResumeCommit
+      include Phronomy::Concurrency::WorkerInputRestricted
+
+      Command = Data.define(
+        :execution_id, :expected_execution_revision,
+        :root, :execution, :approval_request_id, :approved, :tool_batch_snapshot
+      )
+      Result = Data.define(:execution, :root)
+
+      # @api private
+      def initialize(agent_id:, persistence:)
+        @agent_id = agent_id
+        @persistence = persistence
+      end
+
+      # @api private
+      def commit(operation)
+        request = validated_approval_request(operation)
+        execution = stage_recovery_snapshot(operation)
+        persist_decision(execution, operation.root, request, operation.approved)
+      end
+
+      private
+
+      def validated_approval_request(operation)
+        request = operation.execution.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 #{operation.execution.execution_id}"
+        end
+        request
+      end
+
+      def stage_recovery_snapshot(operation)
+        return operation.execution unless operation.tool_batch_snapshot
+
+        ExecutionMetadata.with_values(
+          operation.execution,
+          ExecutionMetadata::TOOL_BATCH_METADATA_KEY => operation.tool_batch_snapshot
+        )
+      end
+
+      def persist_decision(execution, root, request, approved)
+        updated = next_root = nil
+        @persistence.transaction do |tx|
+          decision = record_decision(tx, execution, root, request, approved)
+          updated = save_resumed_execution(tx, execution, request, approved, decision)
+          next_root = save_resumed_root(tx, root)
+        end
+        Result.new(execution: updated, root: next_root)
+      end
+
+      def record_decision(tx, execution, root, request, approved)
+        decision_ref = tx.contents.put_json(
+          "approval_request_id" => (request["id"] || request[:id]).to_s,
+          "approved" => approved
+        )
+        JournalRecord.new(
+          agent_id: @agent_id,
+          execution_id: execution.execution_id,
+          kind: :approval_decided,
+          channel: :approval,
+          content_ref: decision_ref,
+          context_generation: root.transcript_generation,
+          context_candidate: false
+        )
+      end
+
+      def save_resumed_execution(tx, current, request, approved, decision)
+        updated = current.with(
+          status: :active,
+          phase: :resuming,
+          working_records: current.working_records + [decision],
+          approval_request: request.merge("approved" => approved)
+        )
+        tx.executions.save(
+          current.execution_id,
+          expected_revision: current.execution_revision,
+          execution: updated
+        )
+        updated
+      end
+
+      def save_resumed_root(tx, current)
+        updated = current.with(
+          agent_revision: current.agent_revision + 1,
+          lifecycle_status: :active
+        )
+        tx.agents.save(
+          current.agent_id,
+          expected_revision: current.agent_revision,
+          root: updated
+        )
+        updated
+      end
+    end
+  end
+end