phronomy 0.27.0 → 0.28.0

data/lib/phronomy/agent/{context_assembly/context_assembler.rb → context_preparation.rb}

@@ -2,29 +2,13 @@
 
 module Phronomy
   module Agent
-    class ContextAssembler
-      ASSEMBLY_POLICY_VERSION = 9
+    class ContextPreparation
       SEGMENT_ORIGIN_METADATA_KEY = "phronomy_origin"
       POLICY_ORIGIN_METADATA_KEY = "context_policy_origin"
       POLICY_ITEM_ID_METADATA_KEY = "context_policy_item_id"
-      SEMANTIC_CATEGORY_METADATA_KEY = "context_policy_semantic_category"
-      CONTENT_FORMAT_METADATA_KEY = "context_policy_content_format"
-      CONVERSATION_GROUP_ID_METADATA_KEY = "context_policy_conversation_group_id"
-      TRUSTED_HANDOFF_METADATA_KEYS = %w[
-        handoff_policy_category
-        handoff_provenance
-      ].freeze
-      HANDOFF_POLICY_CATEGORY_METADATA_KEY = "handoff_policy_category"
       BEFORE_LLM_INPUT_ORIGIN = "before_llm_input"
       HANDOFF_CONTEXT_ORIGIN = "handoff_context"
 
-      Prepared = Data.define(:input, :plan, :model_config, :call_sequence, :call_mode) do
-        def initialize(**values)
-          super
-          freeze
-        end
-      end
-
       def initialize(
         agent:,
         persistence:,
@@ -38,26 +22,23 @@ module Phronomy
         @candidate_resolver = candidate_resolver || ContextCandidateResolver.new(
           content_loader: method(:fetch_content)
         )
-        @input_builder = ContextPolicyInputBuilder.new(
+        @input_builder = Phronomy::Context::ContextPolicyInputBuilder.new(
           content_loader: method(:fetch_content)
         )
       end
 
       # Builds one immutable Policy input snapshot and executes Application Policy.
       # This method must run outside a Phronomy Persistence transaction.
-      def prepare_initial(input:, agent_root:, execution:, config: {}, patch: LLMInputPatch.empty)
+      def prepare_initial(input:, agent_root:, execution:, config: {}, patch: Phronomy::Context::LLMInputPatch.empty)
         projection = journal_projection(agent_root)
         model_cfg = effective_model_config(config, patch)
-        tool_set = ToolDefinitionSet.build(
-          @agent,
-          additional_tools: handoff_tool_classes(config)
-        )
+        tool_set = @agent.send(:tool_definition_set, additional_tools: handoff_tool_classes(config))
         system_text = build_system_text(input)
         hook_candidates = normalize_candidates(patch.segment_candidates)
         input_ref = execution.metadata.fetch("current_input_ref")
         current_input_content = @persistence.contents.fetch_text(input_ref)
         excluded = [execution.metadata["current_input_record_id"]].compact
-        handoff_context = config[:phronomy_handoff_context]
+        handoff_context = config[:phronomy_transfer_context]
 
         instructions = initial_instruction_items(
           system_text,
@@ -109,16 +90,13 @@ module Phronomy
         agent_root:,
         execution:,
         config: {},
-        patch: LLMInputPatch.empty
+        patch: Phronomy::Context::LLMInputPatch.empty
       )
         projection = journal_projection(agent_root)
         model_cfg = effective_model_config(config, patch)
         hook_candidates = normalize_candidates(patch.segment_candidates)
-        handoff_context = config[:phronomy_handoff_context]
-        tool_set = ToolDefinitionSet.build(
-          @agent,
-          additional_tools: handoff_tool_classes(config)
-        )
+        handoff_context = config[:phronomy_transfer_context]
+        tool_set = @agent.send(:tool_definition_set, additional_tools: handoff_tool_classes(config))
 
         instructions = retained_instruction_items(base_manifest)
 
@@ -153,68 +131,8 @@ module Phronomy
       end
 
       # Validates and canonicalizes a previously prepared Policy decision.
-      # This method contains no ContextPolicy invocation and is safe to execute in
+      # This method contains no Phronomy::Context::ContextPolicy invocation and is safe to execute in
       # the short commit transaction after the caller revalidates durable revision.
-      def finalize(prepared, persistence: @persistence)
-        unless prepared.is_a?(Prepared)
-          raise ArgumentError, "ContextAssembler#finalize expected ContextAssembler::Prepared"
-        end
-
-        plan = ContextPlanValidator.new.validate!(input: prepared.input, plan: prepared.plan)
-        segments = []
-        plan.instruction.each do |item|
-          segments << segment_from_content_item(
-            item,
-            persistence: persistence,
-            additional_metadata: {SEMANTIC_CATEGORY_METADATA_KEY => "instruction"}
-          )
-        end
-        plan.knowledge.each do |item|
-          segments << segment_from_content_item(
-            item,
-            persistence: persistence,
-            additional_metadata: {SEMANTIC_CATEGORY_METADATA_KEY => "knowledge"}
-          )
-        end
-        plan.conversation.each_with_index do |group, group_index|
-          group_metadata = {
-            SEMANTIC_CATEGORY_METADATA_KEY => "conversation",
-            CONVERSATION_GROUP_ID_METADATA_KEY =>
-              "conversation:#{prepared.call_sequence}:#{group_index}"
-          }
-          if tool_exchange_group?(group)
-            group_metadata[HANDOFF_POLICY_CATEGORY_METADATA_KEY] = "tool_exchanges"
-          end
-
-          group.each do |item|
-            segments << segment_from_content_item(
-              item,
-              persistence: persistence,
-              additional_metadata: group_metadata
-            )
-          end
-        end
-
-        selected_tool_definitions = plan.tools.map(&:definition)
-        ContextParts::Validators::FinalBudgetValidator.new(
-          content_loader: lambda { |ref| fetch_content_from(persistence, ref) }
-        ).validate!(
-          token_budget: prepared.input.token_budget,
-          segments: segments,
-          extra_values: [selected_tool_definitions]
-        )
-
-        store_manifest(
-          persistence: persistence,
-          call_sequence: prepared.call_sequence,
-          call_mode: prepared.call_mode,
-          segments: segments,
-          model_config_ref: persistence.contents.put_json(prepared.model_config),
-          tool_definitions_ref: persistence.contents.put_json(selected_tool_definitions)
-        )
-      end
-
-      private
 
       def initial_instruction_items(system_text, handoff_context, execution:)
         instructions = []
@@ -228,7 +146,7 @@ module Phronomy
       end
 
       def agent_instruction_item(system_text, execution:)
-        ContextPolicyInput::InstructionItem.new(
+        Phronomy::Context::ContextPolicyInput::InstructionItem.new(
           id: "instruction:agent:#{execution.execution_id}:1",
           kind: :instruction,
           role: :system,
@@ -236,13 +154,13 @@ module Phronomy
           content_format: :text,
           estimated_tokens: estimate_value(system_text.to_s),
           required: true,
-          provenance: ContextPolicyInput::Provenance.new(origin: :agent_configuration),
+          provenance: Phronomy::Context::ContextPolicyInput::Provenance.new(origin: :agent_configuration),
           metadata: {}
         )
       end
 
       def handoff_instruction_item(handoff_context, execution:)
-        ContextPolicyInput::InstructionItem.new(
+        Phronomy::Context::ContextPolicyInput::InstructionItem.new(
           id: "instruction:handoff:#{execution.execution_id}:1",
           kind: :handoff_responsibility,
           role: :user,
@@ -250,7 +168,7 @@ module Phronomy
           content_format: :text,
           estimated_tokens: estimate_value(handoff_context.responsibility.to_s),
           required: true,
-          provenance: ContextPolicyInput::Provenance.new(origin: :handoff_context),
+          provenance: Phronomy::Context::ContextPolicyInput::Provenance.new(origin: :handoff_context),
           metadata: {SEGMENT_ORIGIN_METADATA_KEY => HANDOFF_CONTEXT_ORIGIN}
         )
       end
@@ -294,7 +212,7 @@ module Phronomy
 
       def current_input_item(content, input_ref:, candidates:, agent_root:, execution:)
         next_sequence = Array(candidates).filter_map(&:sequence).max.to_i + 1
-        ContextPolicyInput::ConversationItem.new(
+        Phronomy::Context::ContextPolicyInput::ConversationItem.new(
           id: "current-input:#{execution.execution_id}",
           kind: :current_input,
           role: :user,
@@ -303,7 +221,7 @@ module Phronomy
           sequence: next_sequence,
           estimated_tokens: estimate_value(content),
           required: true,
-          provenance: ContextPolicyInput::Provenance.new(
+          provenance: Phronomy::Context::ContextPolicyInput::Provenance.new(
             origin: :working,
             content_ref: input_ref,
             record_id: execution.metadata["current_input_record_id"],
@@ -333,7 +251,7 @@ module Phronomy
         tools:,
         current_input:
       )
-        token_budget = TokenBudgetResolver.new.resolve(model_config)
+        token_budget = Phronomy::Agent::Settings.current.llm_adapter.input_budget(model_config)
         policy_input = @input_builder.build(
           agent_id: agent_root.agent_id,
           execution_id: execution.execution_id,
@@ -353,36 +271,10 @@ module Phronomy
             "execution_revision" => execution.execution_revision
           }
         )
-        plan = invoke_policy(policy_input)
-        ContextPlanValidator.new.validate!(input: policy_input, plan: plan)
-        Prepared.new(
-          input: policy_input,
-          plan: plan,
-          model_config: model_config,
-          call_sequence: call_sequence,
-          call_mode: call_mode
-        )
-      end
-
-      def invoke_policy(policy_input)
-        tracer = Phronomy.configuration.tracer
-        span = tracer.start_span(
-          "context_policy",
-          agent_id: policy_input.agent_id,
-          execution_id: policy_input.execution_id,
-          call_sequence: policy_input.call_sequence,
-          policy_class: @policy.class.name || @policy.class.to_s,
-          instruction_count: policy_input.instruction.length,
-          knowledge_count: policy_input.knowledge.length,
-          tool_count: policy_input.tools.length,
-          conversation_group_count: policy_input.conversation.length
+        Phronomy::Context::Assembly.new.prepare(
+          input: policy_input, policy: @policy,
+          adapter_identity: Phronomy::Agent::Settings.current.llm_adapter.identity
         )
-        result = @policy.call(policy_input)
-        tracer.finish_span(span)
-        result
-      rescue => error
-        tracer&.finish_span(span, error: error) if defined?(span) && span
-        raise
       end
 
       def journal_projection(agent_root)
@@ -407,7 +299,7 @@ module Phronomy
       def instruction_item_from_manifest(segment)
         origin = segment.metadata[POLICY_ORIGIN_METADATA_KEY] ||
           ((segment.category.to_sym == :handoff_responsibility) ? "handoff_context" : "agent_configuration")
-        ContextPolicyInput::InstructionItem.new(
+        Phronomy::Context::ContextPolicyInput::InstructionItem.new(
           id: segment.metadata[POLICY_ITEM_ID_METADATA_KEY] || "manifest-instruction:#{segment.position}",
           kind: segment.category,
           role: segment.role,
@@ -415,7 +307,7 @@ module Phronomy
           content_format: :text,
           estimated_tokens: estimate_value(fetch_content(segment.content_ref)),
           required: true,
-          provenance: ContextPolicyInput::Provenance.new(
+          provenance: Phronomy::Context::ContextPolicyInput::Provenance.new(
             origin: origin.to_sym,
             content_ref: segment.content_ref
           ),
@@ -426,91 +318,17 @@ module Phronomy
       def tool_items(tool_set)
         tool_set.definitions.map do |definition|
           name = definition.fetch("name")
-          ContextPolicyInput::ToolItem.new(
+          Phronomy::Context::ContextPolicyInput::ToolItem.new(
             id: "tool:#{name}",
             definition: definition,
             estimated_tokens: estimate_value(definition),
             required: false,
-            provenance: ContextPolicyInput::Provenance.new(origin: :agent_configuration),
+            provenance: Phronomy::Context::ContextPolicyInput::Provenance.new(origin: :agent_configuration),
             metadata: {}
           )
         end.freeze
       end
 
-      def store_manifest(
-        persistence:,
-        call_sequence:,
-        call_mode:,
-        segments:,
-        model_config_ref:,
-        tool_definitions_ref:
-      )
-        positioned = segments.each_with_index.map do |value, position|
-          LLMInputManifest::Segment.new(**value.merge(position: position))
-        end
-        manifest = LLMInputManifest.new(
-          call_sequence: call_sequence,
-          call_mode: call_mode,
-          segments: positioned,
-          model_config_ref: model_config_ref,
-          tool_definitions_ref: tool_definitions_ref,
-          assembly_policy_version: ASSEMBLY_POLICY_VERSION,
-          ruby_llm_version: defined?(RubyLLM::VERSION) ? RubyLLM::VERSION : nil,
-          adapter_name: Phronomy.configuration.llm_adapter.class.name
-        )
-        [manifest, persistence.contents.put_json(manifest.to_h)]
-      end
-
-      def segment_from_content_item(item, persistence:, additional_metadata: {})
-        content_ref = item.provenance.content_ref || store_item_content(item, persistence)
-        metadata = sanitized_item_metadata(item).merge(additional_metadata).merge(
-          CONTENT_FORMAT_METADATA_KEY => item.content_format.to_s,
-          POLICY_ITEM_ID_METADATA_KEY => item.id,
-          POLICY_ORIGIN_METADATA_KEY => item.provenance.origin.to_s,
-          "journal_record_id" => item.provenance.record_id,
-          "source_agent_id" => item.provenance.agent_id,
-          "source_execution_id" => item.provenance.execution_id,
-          "llm_call_id" => item.provenance.llm_call_id
-        ).compact
-
-        {
-          category: item.kind,
-          role: item.role,
-          content_ref: content_ref,
-          delivery: item.respond_to?(:delivery) ? item.delivery : :chat_message,
-          tool_call_id: item.respond_to?(:tool_call_id) ? item.tool_call_id : nil,
-          metadata: metadata
-        }
-      end
-
-      def sanitized_item_metadata(item)
-        raw = item.metadata.to_h.transform_keys(&:to_s)
-        # :working origin is Phronomy-controlled (from InitialPreparation),
-        # so handoff routing metadata on working records is equally trusted.
-        trusted_handoff = if item.provenance.origin == :handoff || item.provenance.origin == :working
-          raw.slice(*TRUSTED_HANDOFF_METADATA_KEYS)
-        else
-          {}
-        end
-
-        raw.except(*ContextPolicyInput::FRAMEWORK_METADATA_KEYS)
-          .merge(trusted_handoff)
-      end
-
-      def tool_exchange_group?(group)
-        Array(group).any? do |item|
-          item.kind == :assistant_message && !item.tool_call_ids.empty?
-        end && Array(group).any? { |item| item.kind == :tool_message }
-      end
-
-      def store_item_content(item, persistence)
-        if item.content_format == :json
-          persistence.contents.put_json(item.content)
-        else
-          persistence.contents.put_text(item.content.to_s)
-        end
-      end
-
       def effective_model_config(config, patch)
         apply_model_config_patch(model_config(config), patch.model_config_patch)
       end
@@ -530,7 +348,7 @@ module Phronomy
         values = patch.to_h.transform_keys(&:to_s)
         if values.key?("context_window")
           raise Phronomy::ConfigurationError,
-            "context_window is model metadata; configure the RubyLLM model registry"
+            "context_window is model metadata; configure the LLM backend model metadata"
         end
         if values.key?("max_output_tokens") && !values["max_output_tokens"].nil?
           cap = Integer(values["max_output_tokens"])
@@ -549,7 +367,7 @@ module Phronomy
           metadata = (hash[:metadata] || hash["metadata"] || {})
             .to_h
             .transform_keys(&:to_s)
-          validate_application_metadata!(metadata, source: "LLMInputPatch segment candidate")
+          validate_application_metadata!(metadata, source: "Phronomy::Context::LLMInputPatch segment candidate")
           {
             content: content,
             category: category,
@@ -560,7 +378,7 @@ module Phronomy
       end
 
       def validate_application_metadata!(metadata, source:)
-        conflicts = metadata.keys.map(&:to_s) & ContextPolicyInput::FRAMEWORK_METADATA_KEYS
+        conflicts = metadata.keys.map(&:to_s) & Phronomy::Context::ContextPolicyInput::FRAMEWORK_METADATA_KEYS
         return if conflicts.empty?
 
         raise ArgumentError,
@@ -582,7 +400,7 @@ module Phronomy
             "source_kind" => "hook",
             "content_format" => content.is_a?(String) ? "text" : "json"
           )
-          Selection::Candidate.new(
+          Phronomy::Context::Candidate.new(
             candidate_id: "hook:#{execution.execution_id}:#{call_sequence}:#{index}",
             source_kind: :hook,
             category: hook.fetch(:category),
@@ -594,7 +412,7 @@ module Phronomy
             llm_call_id: nil,
             tool_call_id: nil,
             sequence: next_sequence + index + 1,
-            constraint: Selection::Constraint.selectable(origin: :context_policy),
+            constraint: Phronomy::Context::Constraint.selectable(origin: :context_policy),
             priority: 0,
             metadata: metadata
           )
@@ -607,8 +425,8 @@ module Phronomy
       def merge_handoff_candidates(candidates, handoff_context, execution:)
         return Array(candidates).freeze unless handoff_context
 
-        unless handoff_context.is_a?(Phronomy::Agent::HandoffContext)
-          raise ArgumentError, "phronomy_handoff_context must be a HandoffContext"
+        unless handoff_context.is_a?(Phronomy::Agent::TransferContext)
+          raise ArgumentError, "phronomy_transfer_context must be a TransferContext"
         end
 
         next_sequence = Array(candidates).filter_map(&:sequence).max.to_i
@@ -627,7 +445,7 @@ module Phronomy
             "handoff_provenance" => item.provenance.to_h
           )
 
-          Selection::Candidate.new(
+          Phronomy::Context::Candidate.new(
             candidate_id: "handoff:#{execution.execution_id}:#{index}:#{item.provenance.origin_record_id || item.provenance.origin_tool_call_id || index}",
             source_kind: :handoff,
             category: item.candidate_category,
@@ -639,7 +457,7 @@ module Phronomy
             llm_call_id: item.provenance.origin_llm_call_id,
             tool_call_id: item.tool_call_id,
             sequence: next_sequence + index + 1,
-            constraint: Selection::Constraint.selectable(origin: :handoff_context),
+            constraint: Phronomy::Context::Constraint.selectable(origin: :handoff_context),
             priority: 50,
             metadata: metadata
           )
@@ -655,7 +473,7 @@ module Phronomy
       end
 
       def handoff_tool_classes(config)
-        Array(config[:phronomy_handoff_bindings]).map(&:tool_class).freeze
+        Array(config[:phronomy_control_bindings]).map(&:tool_class).freeze
       end
 
       def estimate_value(value)
@@ -664,13 +482,9 @@ module Phronomy
       end
 
       def fetch_content(ref)
-        fetch_content_from(@persistence, ref)
-      end
-
-      def fetch_content_from(persistence, ref)
-        persistence.contents.fetch_text(ref)
+        @persistence.contents.fetch_text(ref)
       rescue
-        persistence.contents.fetch(ref)
+        @persistence.contents.fetch(ref)
       end
 
       def build_system_text(input)

data/lib/phronomy/agent/control_request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    # Value returned by a control capability after its domain policy is applied.
+    # Agent validates exclusivity and Source ownership before accepting it.
+    # @api public
+    ControlRequest = Data.define(:target_agent_id, :responsibility, :selection, :llm_call_id, :tool_call_id) do
+      def initialize(target_agent_id:, responsibility:, selection:, llm_call_id: nil, tool_call_id: nil)
+        raise ArgumentError, "target_agent_id is required" if target_agent_id.to_s.empty?
+        raise ArgumentError, "responsibility is required" if responsibility.to_s.strip.empty?
+        normalized = selection.to_h.transform_keys(&:to_sym)
+        unless normalized.values.all? { |value| value == true || value == false }
+          raise ArgumentError, "context selection values must be boolean"
+        end
+        super(target_agent_id: target_agent_id.to_s.freeze, responsibility: responsibility.to_s.strip.freeze,
+              selection: normalized.freeze, llm_call_id: llm_call_id&.to_s&.freeze, tool_call_id: tool_call_id&.to_s&.freeze)
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 require "securerandom"
 require "time"

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 require "securerandom"
 require "time"
@@ -33,7 +33,8 @@ module Phronomy
       end
 
       attr_accessor :input,
-        :chat,
+        :messages,
+        :tools,
         :output,
         :usage,
         :input_blocked,
@@ -85,7 +86,8 @@ module Phronomy
         @event_sink = nil
         @mode = (mode || :invoke).to_sym
 
-        @chat = nil
+        @messages = []
+        @tools = {}.freeze
         @output = nil
         @usage = nil
         @input_blocked = false
@@ -139,17 +141,6 @@ module Phronomy
         end
 
         durable_id = llm_call_id
-        if durable_id.nil? &&
-            Phronomy::Runtime.instance.event_loop.current?
-          state =
-            Phronomy::Agent::ExecutionRegistry.for(Phronomy::Runtime.instance.event_loop).agent_execution_state(
-              execution_id
-            )
-          durable_id = state&.execution&.metadata&.fetch(
-            ExecutionMetadata::PENDING_LLM_ID_KEY,
-            nil
-          )
-        end
         unless durable_id
           raise Phronomy::ExecutionRehydrationRequiredError,
             "Provider Call semantic identity was not durably established before dispatch"
@@ -279,7 +270,7 @@ module Phronomy
 
         @user_message_sent = true
         @output = response.content
-        @usage = Phronomy::TokenUsage.from_tokens(response.tokens)
+        @usage = response.usage
         @pending_tool_calls = []
         self
       end
@@ -321,7 +312,7 @@ module Phronomy
       def record_tool_results!
         @tool_invocations.each do |invocation|
           tool_content = invocation.result.to_s
-          @chat.add_message(
+          @messages << Phronomy::LLMAdapter::Message.new(
             role: :tool,
             content: tool_content,
             tool_call_id: invocation.tool_call_id
@@ -430,7 +421,7 @@ module Phronomy
       private
 
       def handoff_matches_for(calls)
-        bindings = Array(@config[:phronomy_handoff_bindings])
+        bindings = Array(@config[:phronomy_control_bindings])
         return [] if bindings.empty?
 
         by_name = bindings.to_h { |binding| [binding.tool_name.to_s, binding] }
@@ -441,25 +432,15 @@ module Phronomy
       end
 
       def build_handoff_request(tool_call, binding, llm_call_id:)
-        handoff = binding.handoff
-        unless handoff.source_agent.equal?(@agent)
-          raise Phronomy::HandoffError,
-            "Handoff capability is not bound to the active Source Agent"
+        unless binding.source_agent_id == @agent.agent_id
+          raise Phronomy::HandoffError, "Control capability is not bound to the active Source Agent"
         end
-
-        args = tool_call.respond_to?(:arguments) ? tool_call.arguments : {}
-        args = (args || {}).to_h.transform_keys(&:to_sym)
-        selection = handoff.policy.selectable_categories.each_with_object({}) do |category, result|
-          key = :"include_#{category}"
-          result[category] = args[key] if args.key?(key)
+        request = binding.request(arguments: tool_call.arguments || {}, llm_call_id: llm_call_id,
+          tool_call_id: tool_call.respond_to?(:id) ? tool_call.id : nil)
+        unless request.is_a?(ControlRequest)
+          raise ArgumentError, "Control capability must return Agent::ControlRequest"
         end
-        Phronomy::Agent::HandoffRequest.new(
-          handoff: handoff,
-          responsibility: args.fetch(:responsibility),
-          selection_intent: selection,
-          llm_call_id: llm_call_id,
-          tool_call_id: tool_call.respond_to?(:id) ? tool_call.id : nil
-        )
+        request
       end
 
       def apply_llm_event(event)
@@ -476,7 +457,7 @@ module Phronomy
         call = @current_llm_call
         @llm_results << {
           llm_call_id: call.fetch(:llm_call_id),
-          response: canonical_response_for_llm_result(result),
+          response: result.response,
           error: result.error,
           streaming: result.streaming,
           manifest_ref: call.fetch(:manifest_ref),
@@ -490,16 +471,17 @@ module Phronomy
         end
 
         if result.error
-          if result.error.is_a?(ToolCallIntercepted)
-            accept_tool_calls!(
-              result.error.tool_calls,
-              llm_call_id: result.llm_call_id
-            )
+          @error = result.error
+        elsif result.response.is_a?(Phronomy::LLMAdapter::Response)
+          @messages << result.response
+          if result.response.tool_call?
+            @usage = result.response.usage
+            accept_tool_calls!(result.response.tool_calls, llm_call_id: result.llm_call_id)
           else
-            @error = result.error
+            apply_llm_response!(result.response)
           end
         else
-          apply_llm_response!(result.response)
+          @error = Phronomy::LLMAdapter::InvalidResultError.new("LLM operation completed without a Response")
         end
         true
       end
@@ -510,7 +492,7 @@ module Phronomy
       end
 
       def warn_stale_llm_result(llm_call_id)
-        Phronomy.configuration.logger&.warn(
+        Phronomy::RuntimeSettings.current.logger&.warn(
           "[Phronomy] Dropped stale Provider result: " \
           "execution_id=#{@execution_id} expected_llm_call_id=#{current_llm_call_id.inspect} " \
           "actual_llm_call_id=#{llm_call_id.inspect}"
@@ -519,14 +501,6 @@ module Phronomy
         nil
       end
 
-      def canonical_response_for_llm_result(result)
-        if result.error.is_a?(ToolCallIntercepted)
-          result.error.assistant_outcome || ProviderCallOutcome.capture(result.response)
-        else
-          ProviderCallOutcome.capture(result.response)
-        end
-      end
-
       # Canonical runtime recording is independent of Application callback health.
       # Once an event is observed it is appended even after a listener has failed.
       def deliver_event(event)
@@ -555,13 +529,13 @@ module Phronomy
         if @event_sink
           accepted = @event_sink.post(:application_callback_failed, {failure: failure})
           unless accepted
-            Phronomy.configuration.logger&.warn(
+            Phronomy::RuntimeSettings.current.logger&.warn(
               "[Phronomy] Callback failure recorded but could not notify " \
               "FSMSession #{@event_sink.fsm_session_id}: execution_id=#{@execution_id}"
             )
           end
         end
-        Phronomy.configuration.logger&.warn(
+        Phronomy::RuntimeSettings.current.logger&.warn(
           "[Phronomy] Application event listener failed: " \
           "#{failure.error.class}: #{failure.error.message}"
         )

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 module Phronomy
   module Agent