phronomy 0.4.0 → 0.5.1

data/lib/phronomy/agent/concerns/before_completion.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Concerns
+      # Adds before_completion hook support to an agent.
+      #
+      # Included in {Phronomy::Agent::Base}. Hooks are executed just before every
+      # LLM call (global → class → instance order) and may inject or override
+      # LLM parameters such as temperature or model.
+      module BeforeCompletion
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        # Class-level DSL methods mixed into the including agent class.
+        module ClassMethods
+          # Sets or reads the class-level before_completion hook.
+          # The hook is called before every LLM request for instances of this class.
+          # Receives a {Phronomy::Agent::BeforeCompletionContext}; must return a Hash
+          # of params to merge into the LLM call, or nil to pass through unchanged.
+          #
+          # @param callable [#call, nil] lambda/proc to register, or nil to clear
+          # @return [#call, nil]
+          # @example
+          #   class MyAgent < Phronomy::Agent::Base
+          #     before_completion ->(ctx) { { temperature: 0.2 } }
+          #   end
+          def before_completion(callable = nil)
+            if callable.nil? && !block_given?
+              @before_completion
+            else
+              @before_completion = callable
+            end
+          end
+
+          # @return [#call, nil]
+          def _before_completion
+            @before_completion
+          end
+        end
+
+        # Instance-level before_completion hook. When set, takes precedence over
+        # the class-level hook for this specific agent instance only.
+        # @return [#call, nil]
+        attr_accessor :before_completion
+
+        private
+
+        # Collects and runs all registered before_completion hooks in order
+        # (global → class → instance) and applies the merged params to the chat.
+        #
+        # @param chat   [RubyLLM::Chat] the assembled chat object
+        # @param config [Hash] the invocation config hash
+        # @return [Hash] the merged params applied to the chat
+        def run_before_completion_hooks!(chat, config)
+          hooks = [
+            Phronomy.configuration.before_completion,
+            self.class._before_completion,
+            @before_completion
+          ].compact
+
+          return {} if hooks.empty?
+
+          ctx = BeforeCompletionContext.new(
+            agent: self,
+            messages: chat.messages,
+            config: config,
+            params: {}
+          )
+
+          merged = {}
+          hooks.each do |hook|
+            result = hook.call(ctx)
+            merged.merge!(result) if result.is_a?(Hash)
+          end
+
+          apply_before_completion_params!(chat, merged)
+          merged
+        end
+
+        # Applies a merged param hash returned by before_completion hooks to
+        # the chat object using the appropriate RubyLLM::Chat API methods.
+        # When overriding the model, reuses the agent's configured provider and
+        # assume_exists setting so that local/namespaced models continue to work.
+        #
+        # @param chat   [RubyLLM::Chat]
+        # @param params [Hash]
+        def apply_before_completion_params!(chat, params)
+          params.each do |key, value|
+            case key
+            when :model
+              prov = self.class.provider
+              chat.with_model(value, provider: prov, assume_exists: !prov.nil?)
+            when :temperature
+              chat.with_temperature(value)
+            else
+              chat.with_params(key => value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/concerns/guardrailable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Concerns
+      # Adds input and output guardrail support to an agent.
+      #
+      # Included in {Phronomy::Agent::Base}. Guardrails are run on the raw
+      # input string before the LLM is called, and on the raw output string
+      # before the result is returned to the caller.
+      module Guardrailable
+        # Attach a guardrail that validates input before every #invoke call.
+        # @param guardrail [Phronomy::Guardrail::InputGuardrail]
+        # @return [self]
+        def add_input_guardrail(guardrail)
+          @input_guardrails ||= []
+          @input_guardrails << guardrail
+          self
+        end
+
+        # Attach a guardrail that validates output before it is returned.
+        # @param guardrail [Phronomy::Guardrail::OutputGuardrail]
+        # @return [self]
+        def add_output_guardrail(guardrail)
+          @output_guardrails ||= []
+          @output_guardrails << guardrail
+          self
+        end
+
+        private
+
+        def run_input_guardrails!(input)
+          (@input_guardrails || []).each { |g| g.run!(input) }
+        end
+
+        def run_output_guardrails!(output)
+          (@output_guardrails || []).each { |g| g.run!(output) }
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/concerns/retryable.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Concerns
+      # Adds configurable retry behaviour to an agent.
+      #
+      # Included in {Phronomy::Agent::Base}. The retry loop wraps the full
+      # #invoke_once call; {Phronomy::GuardrailError} is never retried.
+      module Retryable
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        # Class-level DSL methods mixed into the including agent class.
+        module ClassMethods
+          # Configures a retry policy that wraps the full #invoke call.
+          # GuardrailError is never retried regardless of this setting.
+          #
+          # @param times [Integer] maximum retry attempts (default: 0)
+          # @param wait  [Symbol, Numeric] :exponential, :linear, or a fixed Float
+          # @param base  [Float]  base wait time in seconds (default: 1.0)
+          #
+          # @example
+          #   class MyAgent < Phronomy::Agent::Base
+          #     retry_policy times: 2, wait: :exponential, base: 1.0
+          #   end
+          def retry_policy(times: 0, wait: 0, base: 1.0)
+            @_retry_policy = {times: times, wait: wait, base: base}
+          end
+
+          # Returns the configured retry policy, or nil when none is set.
+          # @return [Hash, nil]
+          attr_reader :_retry_policy
+
+          # Injectable sleep callable for testing (shared with Tool::Base pattern).
+          # @return [#call]
+          def _sleep_proc
+            @_sleep_proc || method(:sleep)
+          end
+
+          # Overrides the sleep callable used between retries.
+          # @param proc [#call]
+          attr_writer :_sleep_proc
+        end
+
+        private
+
+        # Retry loop for #invoke. Separated so that ReactAgent can override #invoke_once.
+        def _invoke_impl(input, messages: [], thread_id: nil, config: {})
+          policy = self.class._retry_policy
+          attempt = 0
+          begin
+            invoke_once(input, messages: messages, thread_id: thread_id, config: config)
+          rescue Phronomy::GuardrailError
+            raise
+          rescue
+            if policy && attempt < policy[:times]
+              wait = compute_agent_retry_wait(policy[:wait], policy[:base], attempt)
+              self.class._sleep_proc.call(wait) if wait > 0
+              attempt += 1
+              retry
+            end
+            raise
+          end
+        end
+
+        # Computes the agent-level retry wait duration.
+        # @param strategy [Symbol, Numeric]
+        # @param base     [Float]
+        # @param attempt  [Integer]
+        # @return [Float]
+        def compute_agent_retry_wait(strategy, base, attempt)
+          case strategy
+          when :exponential
+            (2**attempt) * base
+          when :linear
+            (attempt + 1) * base
+          when Numeric
+            strategy.to_f
+          else
+            base.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/concerns/suspendable.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    module Concerns
+      # Adds suspend/resume and tool-approval support to an agent.
+      #
+      # Included in {Phronomy::Agent::Base}. When a tool decorated with
+      # +requires_approval true+ is called and no synchronous approval handler
+      # has been registered, the invocation is suspended and a
+      # {Phronomy::Agent::Checkpoint} is returned so the caller can resume later.
+      module Suspendable
+        # Registers a callback that is invoked before executing any tool that has
+        # +requires_approval true+ set. The block receives the tool name (String)
+        # and the arguments Hash, and must return a truthy value to allow execution.
+        # Returning a falsy value causes the tool to return a denial message instead
+        # of executing.
+        #
+        # When no handler is registered and a tool with +requires_approval+ is
+        # called, #invoke returns a suspended result hash containing a
+        # {Phronomy::Agent::Checkpoint}. Call #resume to continue execution after
+        # obtaining an approval decision from the user or an external system.
+        #
+        # @example Synchronous handler
+        #   agent = MyAgent.new
+        #   agent.on_approval_required { |tool_name, args| prompt_user(tool_name, args) }
+        # @return [self]
+        def on_approval_required(&block)
+          @approval_handler = block
+          self
+        end
+
+        # Resumes a previously suspended invocation from a {Phronomy::Agent::Checkpoint}.
+        #
+        # This method reconstructs the conversation state captured at suspension
+        # time, injects the tool result (executed or denied), and continues the
+        # LLM loop until it produces a final answer.
+        #
+        # @param checkpoint [Phronomy::Agent::Checkpoint] the checkpoint returned by
+        #   the suspended #invoke call
+        # @param approved   [Boolean] +true+ to execute the pending tool; +false+
+        #   to inject a denial message and let the LLM handle it gracefully
+        # @param config     [Hash] same runtime options as #invoke
+        # @return [Hash] +{ output: String, suspended: false, messages: Array, usage: Phronomy::TokenUsage }+
+        # @raise [Phronomy::GuardrailError] when an output guardrail rejects the value
+        def resume(checkpoint, approved:, config: {})
+          # Build a fresh chat with all tools registered.
+          chat = build_chat
+
+          # Re-apply system instructions so the LLM has the same persona/context
+          # as the original invocation. build_cached_system_text is memoised, so
+          # a Proc- or PromptTemplate-based instructions block is re-evaluated
+          # against the original input rather than using a stale cached value.
+          system_text = build_cached_system_text(checkpoint.original_input)
+          apply_instructions(chat, system_text) if system_text
+
+          # Restore the full conversation (history + user + assistant with tool call).
+          checkpoint.messages.each { |msg| chat.messages << msg }
+
+          # Determine the tool result: execute it or inject a denial string.
+          tool_result =
+            if approved
+              tool_instance = chat.tools[checkpoint.pending_tool_name.to_sym]
+              tool_instance ? tool_instance.call(checkpoint.pending_tool_args) : "Tool not found."
+            else
+              "Tool execution denied."
+            end
+
+          # Inject the tool result so the LLM can continue.
+          chat.add_message(
+            role: :tool,
+            content: tool_result.to_s,
+            tool_call_id: checkpoint.pending_tool_call_id
+          )
+
+          # Continue the React loop.
+          response = chat.complete
+
+          output = response.content
+          usage = Phronomy::TokenUsage.from_tokens(response.tokens)
+
+          run_output_guardrails!(output)
+
+          {output: output, suspended: false, messages: chat.messages, usage: usage}
+        end
+
+        private
+
+        # Registers an on_tool_call hook on the chat object that raises SuspendSignal
+        # when an approval-required tool is about to be executed and no synchronous
+        # on_approval_required handler has been registered.
+        #
+        # Does nothing when:
+        #   - a synchronous handler is already registered (@approval_handler is set), or
+        #   - none of the agent's tools have requires_approval set.
+        #
+        # @param chat [RubyLLM::Chat]
+        def _register_suspension_hook!(chat)
+          return if @approval_handler
+          return if self.class.tools.none? { |tc| tc.requires_approval }
+
+          chat.on_tool_call do |tool_call|
+            tool_instance = chat.tools[tool_call.name.to_sym]
+            if tool_instance&.requires_approval
+              raise SuspendSignal.new(
+                tool_name: tool_call.name,
+                args: tool_call.arguments,
+                tool_call_id: tool_call.id
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/agent/react_agent.rb

@@ -9,7 +9,7 @@ module Phronomy
 
       # Performs a single (non-retried) ReAct invocation.
       # Overrides Base#invoke_once so that Base#invoke's retry loop is inherited.
-      def invoke_once(input, config: {})
+      def invoke_once(input, messages: [], thread_id: nil, config: {})
         caller_meta = {}
         caller_meta[:user_id] = config[:user_id] if config[:user_id]
         caller_meta[:session_id] = config[:session_id] if config[:session_id]
@@ -18,17 +18,16 @@ module Phronomy
           # Run input guardrails before any LLM interaction.
           run_input_guardrails!(input)
 
-          config[:thread_id]
           max_iter = self.class.max_iterations
 
           # Seed with app-managed conversation history when provided.
-          messages = Array(config[:messages]).dup
+          messages = Array(messages).dup
           user_asked = false
           total_usage = Phronomy::TokenUsage.zero
           iterations_exhausted = true
 
           max_iter.times do
-            response = step(messages, input, user_asked: user_asked, config: config)
+            response = step(messages, input, user_asked: user_asked, thread_id: thread_id, config: config)
             user_asked = true
             messages = response[:messages]
             total_usage += response[:usage]
@@ -55,12 +54,14 @@ module Phronomy
       # Streaming version of #invoke for the ReAct loop.
       # Yields {Phronomy::Agent::StreamEvent} events while the LLM-tool loop runs.
       #
-      # @param input  [String, Hash]
-      # @param config [Hash]
+      # @param input     [String, Hash]
+      # @param messages  [Array<RubyLLM::Message>] same as #invoke
+      # @param thread_id [String, nil]              same as #invoke
+      # @param config    [Hash]
       # @yield [Phronomy::Agent::StreamEvent]
       # @return [Hash] { output:, messages:, usage: }
-      def stream(input, config: {}, &block)
-        return invoke(input, config: config) unless block
+      def stream(input, messages: [], thread_id: nil, config: {}, &block)
+        return invoke(input, messages: messages, thread_id: thread_id, config: config) unless block
 
         caller_meta = {}
         caller_meta[:user_id] = config[:user_id] if config[:user_id]
@@ -69,16 +70,15 @@ module Phronomy
         trace("agent.invoke", input: input, **caller_meta) do |_span|
           run_input_guardrails!(input)
 
-          config[:thread_id]
           max_iter = self.class.max_iterations
 
-          messages = Array(config[:messages]).dup
+          messages = Array(messages).dup
           user_asked = false
           total_usage = Phronomy::TokenUsage.zero
           iterations_exhausted = true
 
           max_iter.times do
-            response = stream_step(messages, input, user_asked: user_asked, config: config, &block)
+            response = stream_step(messages, input, user_asked: user_asked, thread_id: thread_id, config: config, &block)
             user_asked = true
             messages = response[:messages]
             total_usage += response[:usage]
@@ -104,11 +104,23 @@ module Phronomy
 
       private
 
-      def step(messages, initial_input, user_asked: false, config: {})
+      def step(messages, initial_input, user_asked: false, thread_id: nil, config: {})
         chat = build_chat
 
-        # Inject any existing history (from previous loop iterations or loaded memory).
-        messages.each { |m| chat.add_message(m) }
+        if user_asked
+          # Subsequent loop iteration — messages already contains the full conversation
+          # (including the user's original input from the first step); apply system
+          # instructions and replay the accumulated history, then let the LLM continue.
+          system_text = build_cached_system_text(initial_input)
+          apply_instructions(chat, system_text) if system_text
+          messages.each { |m| chat.add_message(m) }
+        else
+          # First iteration — assemble context (system + history) via build_context so
+          # that trimming, compaction, and knowledge sources are applied consistently.
+          context = build_context(initial_input, messages: messages, thread_id: thread_id, config: config)
+          apply_instructions(chat, context[:system]) if context[:system]
+          context[:messages].each { |m| chat.messages << m }
+        end
 
         # Run before_completion hooks before each LLM call in the ReAct loop.
         run_before_completion_hooks!(chat, config)
@@ -130,9 +142,18 @@ module Phronomy
 
       # Streaming variant of #step.  Yields :token / :tool_call / :tool_result events
       # via the block while the LLM call is in progress.
-      def stream_step(messages, initial_input, user_asked: false, config: {}, &block)
+      def stream_step(messages, initial_input, user_asked: false, thread_id: nil, config: {}, &block)
         chat = build_chat
-        messages.each { |m| chat.add_message(m) }
+
+        if user_asked
+          system_text = build_cached_system_text(initial_input)
+          apply_instructions(chat, system_text) if system_text
+          messages.each { |m| chat.add_message(m) }
+        else
+          context = build_context(initial_input, messages: messages, thread_id: thread_id, config: config)
+          apply_instructions(chat, context[:system]) if context[:system]
+          context[:messages].each { |m| chat.messages << m }
+        end
 
         current_tool_call = nil
         chat.on_tool_call do |tc|

data/lib/phronomy/agent/team_coordinator.rb

@@ -16,8 +16,8 @@ module Phronomy
     # - +finalize+     — signals that all tasks have been enqueued
     #
     # Worker persistence is implemented by passing each worker's accumulated
-    # +messages+ array back via +config[:messages]+ on every subsequent +invoke+
-    # call, so the LLM retains context across multiple task assignments.
+    # +messages+ array back as a top-level +messages:+ argument on every subsequent
+    # +invoke+ call, so the LLM retains context across multiple task assignments.
     #
     # @example Basic usage
     #   class MigrationTeam < Phronomy::Agent::TeamCoordinator
@@ -38,7 +38,7 @@ module Phronomy
     class TeamCoordinator
       # Holds per-worker context between task invocations.
       # Worker persistence is implemented by carrying +messages+ forward on each
-      # successive +agent#invoke+ call via +config[:messages]+.
+      # successive +agent#invoke+ call as the top-level +messages:+ argument..
       WorkerState = Struct.new(
         :index,    # Integer — 0-based worker index
         :agent,    # Agent::Base instance
@@ -201,7 +201,7 @@ module Phronomy
           worker = scheduler ? scheduler.call(available) : default_scheduler(available)
 
           begin
-            result = worker.agent.invoke(task[:description], config: {messages: worker.messages})
+            result = worker.agent.invoke(task[:description], messages: worker.messages)
             worker.messages = result[:messages]
             worker.status = :available
             entry = {task: task, result: result[:output], worker: worker.index, error: nil}

data/lib/phronomy/ruby_llm_patches.rb

@@ -3,18 +3,22 @@
 # Patches for upstream ruby_llm bugs that have not yet been released.
 # Remove each patch once the fix is available in a published gem version.
 
-module RubyLLM
-  module Streaming
-    private
+# Guard: apply monkey-patches only to affected ruby_llm versions so that
+# upgrading the gem does not silently keep dead overrides in place.
+if Gem::Version.new(RubyLLM::VERSION) <= Gem::Version.new("1.15.0")
+  module RubyLLM
+    module Streaming
+      private
 
-    # Upstream ruby_llm <= 1.15.0 assumes the SSE error chunk always has two
-    # lines ("event: error\ndata: {...}") and uses a fixed index [1], which
-    # raises NoMethodError when some providers (e.g. Qwen) return a single-line
-    # chunk ("data: {...}").  This patch finds the data line by content instead.
-    def handle_error_chunk(chunk, env)
-      data_line = chunk.split("\n").find { |l| l.start_with?("data: ") } || chunk.split("\n")[0]
-      error_data = data_line.delete_prefix("data: ")
-      parse_error_from_json(error_data, env, "Failed to parse error chunk")
+      # Upstream ruby_llm <= 1.15.0 assumes the SSE error chunk always has two
+      # lines ("event: error\ndata: {...}") and uses a fixed index [1], which
+      # raises NoMethodError when some providers (e.g. Qwen) return a single-line
+      # chunk ("data: {...}").  This patch finds the data line by content instead.
+      def handle_error_chunk(chunk, env)
+        data_line = chunk.split("\n").find { |l| l.start_with?("data: ") } || chunk.split("\n")[0]
+        error_data = data_line.delete_prefix("data: ")
+        parse_error_from_json(error_data, env, "Failed to parse error chunk")
+      end
     end
   end
 end

data/lib/phronomy/tool/mcp_tool.rb

@@ -3,6 +3,7 @@
 require "json"
 require "net/http"
 require "open3"
+require "securerandom"
 require "shellwords"
 require "uri"
 
@@ -36,9 +37,13 @@ module Phronomy
         # @param tool_name [String] the tool name as registered in the MCP server
         # @return [McpTool] a configured subclass instance ready for use with an Agent
         def from_server(server_uri, tool_name:)
+          # Use a short-lived transport only to query the tool definition,
+          # then close it.  Each McpTool instance creates its own transport
+          # so that concurrent callers never share IO streams.
           transport = build_transport(server_uri)
           tool_def = transport.fetch_tool(tool_name)
-          build_tool_class(tool_name, tool_def, transport).new
+          transport.close
+          build_tool_class(tool_name, server_uri, tool_def).new
         end
 
         private
@@ -55,10 +60,10 @@ module Phronomy
           end
         end
 
-        def build_tool_class(tool_name, tool_def, transport)
+        def build_tool_class(tool_name, server_uri, tool_def)
           klass = Class.new(McpTool)
           klass.instance_variable_set(:@mcp_tool_name, tool_name)
-          klass.instance_variable_set(:@mcp_transport, transport)
+          klass.instance_variable_set(:@mcp_server_uri, server_uri)
 
           # Register description and params from the MCP tool definition.
           klass.description(tool_def[:description] || tool_name)
@@ -66,10 +71,15 @@ module Phronomy
             klass.param(p[:name].to_sym, type: p[:type]&.to_sym || :string, desc: p[:description].to_s)
           end
 
-          # Define #execute to forward the call to the MCP server.
+          # Each instance creates its own transport so concurrent agent threads
+          # never share IO streams, eliminating the need for synchronisation.
+          klass.define_method(:initialize) do
+            uri = self.class.instance_variable_get(:@mcp_server_uri)
+            @mcp_transport = self.class.send(:build_transport, uri)
+          end
+
           klass.define_method(:execute) do |**args|
-            self.class.instance_variable_get(:@mcp_transport)
-              .call_tool(tool_name, args)
+            @mcp_transport.call_tool(tool_name, args)
           end
 
           klass
@@ -108,7 +118,6 @@ module Phronomy
           wait_thr = @wait_thr
           @stderr_thread = nil
           @wait_thr = nil
-          # Join outside the lock to avoid blocking on slow joins.
           stderr_thread&.join(1)
           wait_thr&.join(5)
         end
@@ -208,6 +217,11 @@ module Phronomy
           @read_timeout = read_timeout
         end
 
+        # HTTP connections are stateless; close is a no-op, defined so that
+        # both transport classes share the same interface as StdioTransport.
+        def close
+        end
+
         # Retrieve the tool definition from the server using MCP `tools/list`.
         # @param tool_name [String]
         # @return [Hash] { description:, parameters: }

data/lib/phronomy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phronomy
-  VERSION = "0.4.0"
+  VERSION = "0.5.1"
 end

data/lib/phronomy.rb

@@ -5,7 +5,6 @@ require "ruby_llm"
 require_relative "phronomy/ruby_llm_patches"
 
 loader = Zeitwerk::Loader.for_gem
-loader.ignore(File.expand_path("generators", __dir__))
 # Teach Zeitwerk that "llm" maps to "LLM" so that file names such as
 # ruby_llm_embeddings.rb resolve to RubyLLMEmbeddings (not RubyLlmEmbeddings).
 loader.inflector.inflect("ruby_llm_embeddings" => "RubyLLMEmbeddings")
@@ -14,8 +13,6 @@ loader.setup
 require_relative "phronomy/version"
 require_relative "phronomy/token_usage"
 
-require "phronomy/railtie" if defined?(Rails::Railtie)
-
 module Phronomy
   # Exception hierarchy
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phronomy
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Raizo T.C.S
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-19 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_llm
@@ -64,15 +64,15 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
-- lib/generators/phronomy/install/install_generator.rb
-- lib/generators/phronomy/install/templates/create_phronomy_messages.rb.tt
-- lib/generators/phronomy/install/templates/initializer.rb.tt
-- lib/generators/phronomy/install/templates/message_model.rb.tt
 - lib/phronomy.rb
 - lib/phronomy/agent.rb
 - lib/phronomy/agent/base.rb
 - lib/phronomy/agent/before_completion_context.rb
 - lib/phronomy/agent/checkpoint.rb
+- lib/phronomy/agent/concerns/before_completion.rb
+- lib/phronomy/agent/concerns/guardrailable.rb
+- lib/phronomy/agent/concerns/retryable.rb
+- lib/phronomy/agent/concerns/suspendable.rb
 - lib/phronomy/agent/handoff.rb
 - lib/phronomy/agent/orchestrator.rb
 - lib/phronomy/agent/react_agent.rb
@@ -128,7 +128,6 @@ files:
 - lib/phronomy/output_parser/json_parser.rb
 - lib/phronomy/output_parser/structured_parser.rb
 - lib/phronomy/prompt_template.rb
-- lib/phronomy/railtie.rb
 - lib/phronomy/ruby_llm_patches.rb
 - lib/phronomy/runnable.rb
 - lib/phronomy/splitter.rb