phronomy 0.27.0 → 0.29.0

data/lib/phronomy.rb

@@ -13,19 +13,29 @@ loader.inflector.inflect("llm_adapter" => "LLMAdapter")
 loader.inflector.inflect("llm_operation_result" => "LLMOperationResult")
 loader.inflector.inflect("ruby_llm" => "RubyLLM")
 loader.inflector.inflect("canonical_json" => "CanonicalJSON")
-loader.inflector.inflect("ruby_llm_materializer" => "RubyLLMMaterializer")
 loader.inflector.inflect("llm_call_record" => "LLMCallRecord")
 loader.inflector.inflect("llm_input_manifest" => "LLMInputManifest")
 loader.inflector.inflect("llm_input_build_context" => "LLMInputBuildContext")
 loader.inflector.inflect("llm_input_patch" => "LLMInputPatch")
 loader.inflector.inflect("before_llm_input" => "BeforeLLMInput")
 # These responsibility directories do not add a public Ruby namespace.
-%w[common configuration engine generation llm_contract recovery].each do |directory|
+%w[common configuration engine execution generation runtime_composition].each do |directory|
+  loader.collapse("#{__dir__}/phronomy/#{directory}")
+end
+# Backend contracts, execution clients and implementations have separate source
+# directories, while keeping their existing feature namespace.
+%w[
+  llm_adapter/async llm_adapter/backends
+  vector_store/async vector_store/backends
+  embeddings/async embeddings/backends
+  storage/async
+  multi_agent/runtime_binding
+].each do |directory|
   loader.collapse("#{__dir__}/phronomy/#{directory}")
 end
 # Agent responsibility directories retain the existing Agent constant names.
 %w[
-  context_contract lifecycle execution tool_execution context_assembly
+  lifecycle execution tool_execution runtime_binding
   journal handoff recovery
 ].each do |directory|
   loader.collapse("#{__dir__}/phronomy/agent/#{directory}")
@@ -36,44 +46,81 @@ end
 # beside the feature they belong to, without aliases or a new partial-load API.
 %w[
   agent/api
-  agent/lifecycle_contract
-  filter/contract
-  output_parser/contract
-  persistence/api
-  tool/contract
   workflow/execution
-  workflow/storage_contract
-  multi_agent/storage_contract
+  workflow/runtime_binding
 ].each do |directory|
   loader.push_dir("#{__dir__}/phronomy/#{directory}", namespace: Phronomy)
 end
 
 # These files wire composition, reopen namespaces, or patch a dependency.
 loader.ignore(
-  "#{__dir__}/phronomy/configuration/global_configuration.rb",
+  "#{__dir__}/phronomy/persistence/persistence.rb",
+  "#{__dir__}/phronomy/persistence/errors.rb",
+  "#{__dir__}/phronomy/persistence_composition/stores.rb",
+  "#{__dir__}/phronomy/runtime_composition/global_configuration.rb",
   "#{__dir__}/phronomy/agent/composition",
   "#{__dir__}/phronomy/runtime_composition/agent_defaults.rb",
+  "#{__dir__}/phronomy/runtime_composition/generation_defaults.rb",
+  "#{__dir__}/phronomy/runtime_composition/evaluation_defaults.rb",
+  "#{__dir__}/phronomy/runtime_composition/workflow_defaults.rb",
+  "#{__dir__}/phronomy/runtime_composition/multi_agent_defaults.rb",
   "#{__dir__}/phronomy/runtime_composition/configuration_defaults.rb",
-  "#{__dir__}/phronomy/runtime_composition/global_runtime.rb"
+  "#{__dir__}/phronomy/runtime_composition/global_runtime.rb",
+  "#{__dir__}/phronomy/runtime_composition/execution_defaults.rb"
 )
+# Optional application integrations are loaded explicitly by their consumers.
+loader.ignore("#{__dir__}/phronomy/integrations")
 # Persistence conformance support must never make production loading require RSpec.
 loader.ignore(
   "#{__dir__}/phronomy/testing/persistence_contract.rb",
   "#{__dir__}/phronomy/testing/persistence_contract"
 )
+# Failure contracts can define Persistence before ordinary framework loading.
+# Explicitly install its service methods without constructing a backend/Runtime.
+require_relative "phronomy/persistence/persistence"
+require_relative "phronomy/persistence/errors"
+loader.ignore("#{__dir__}/phronomy/tool/tool_error.rb")
+loader.ignore("#{__dir__}/phronomy/filter/filter_block_error.rb")
+loader.ignore("#{__dir__}/phronomy/output_parser/parse_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/agent_busy_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/agent_purged_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/stream_callback_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/handoff_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/agent_already_exists_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/agent_not_found_error.rb")
+loader.ignore("#{__dir__}/phronomy/agent/agent_unloaded_error.rb")
 loader.setup
+require_relative "phronomy/persistence/transaction"
+require_relative "phronomy/persistence_composition/stores"
+require_relative "phronomy/tool/tool_error"
+require_relative "phronomy/filter/filter_block_error"
+require_relative "phronomy/output_parser/parse_error"
+require_relative "phronomy/agent/agent_busy_error"
+require_relative "phronomy/agent/agent_purged_error"
+require_relative "phronomy/agent/stream_callback_error"
+require_relative "phronomy/agent/handoff_error"
+require_relative "phronomy/agent/agent_already_exists_error"
+require_relative "phronomy/agent/agent_not_found_error"
+require_relative "phronomy/agent/agent_unloaded_error"
 
 require_relative "phronomy/runtime_composition/configuration_defaults"
-require_relative "phronomy/llm_contract/token_usage"
-require_relative "phronomy/configuration/global_configuration"
+require_relative "phronomy/llm_adapter/token_usage"
+require_relative "phronomy/runtime_composition/global_configuration"
 require_relative "phronomy/runtime_composition/global_runtime"
+require_relative "phronomy/runtime_composition/execution_defaults"
 
 # Explicitly install the Agent namespace extensions even if its factory
 # contract was loaded first. Composition owns both concrete binding and the
 # run_once method definition; neither is required from Agent execution files.
 require_relative "phronomy/agent/api/agent"
 require_relative "phronomy/runtime_composition/agent_defaults"
+require_relative "phronomy/runtime_composition/multi_agent_defaults"
+require_relative "phronomy/runtime_composition/workflow_defaults"
+require_relative "phronomy/runtime_composition/generation_defaults"
+require_relative "phronomy/runtime_composition/evaluation_defaults"
 require_relative "phronomy/agent/composition/run_once"
 
-# Load the common recovery vocabulary during ordinary application loading.
-require_relative "phronomy/recovery/recovery"
+# Preserve ordinary boot loading of the existing recovery rules and comparisons
+# while giving each definition its owning domain.
+require_relative "phronomy/agent/recovery/recovery_rules"
+require_relative "phronomy/persistence/snapshot_comparison"

data/scripts/api_snapshot.rb

@@ -18,32 +18,62 @@ require_relative "../lib/phronomy"
 
 PUBLIC_API_ENTRIES = [
   # Stable
+  Phronomy::Error,
+  Phronomy::AgentNotFoundError,
+  Phronomy::AgentUnloadedError,
+  Phronomy::Agent,
+  Phronomy::Agent::Scope,
+  Phronomy::Agent::ScopeCleanupError,
+  Phronomy::MultiAgent::TeamNotFoundError,
+  Phronomy::MultiAgent::TeamBusyError,
+  Phronomy::Embeddings::AuthenticationError,
+  Phronomy::Embeddings::RateLimitError,
   Phronomy::Agent::Base,
-  Phronomy::Agent::ContextPolicy,
-  Phronomy::Agent::ContextPolicyInput,
-  Phronomy::Agent::ContextPolicyInput::Provenance,
-  Phronomy::Agent::ContextPolicyInput::InstructionItem,
-  Phronomy::Agent::ContextPolicyInput::KnowledgeItem,
-  Phronomy::Agent::ContextPolicyInput::ToolItem,
-  Phronomy::Agent::ContextPolicyInput::ConversationItem,
-  Phronomy::Agent::ContextPlan,
+  Phronomy::Agent::ReservedExecution,
+  Phronomy::Agent::ExecutionObservation,
+  Phronomy::Agent::KnowledgeItem,
+  Phronomy::Agent::Retention,
+  Phronomy::Agent::ExecutionExtensionState,
+  Phronomy::Agent::ControlRequest,
+  Phronomy::Context::ContextPolicy,
+  Phronomy::Context::ContextPolicyInput,
+  Phronomy::Context::ContextPolicyInput::Provenance,
+  Phronomy::Context::ContextPolicyInput::InstructionItem,
+  Phronomy::Context::ContextPolicyInput::KnowledgeItem,
+  Phronomy::Context::ContextPolicyInput::ToolItem,
+  Phronomy::Context::ContextPolicyInput::ConversationItem,
+  Phronomy::Context::ContextPlan,
   Phronomy::InvocationContext,
-  Phronomy::Agent::Context::Capability::Base,
+  Phronomy::Tool::Base,
   Phronomy::Workflow,
+  Phronomy::Workflow::Builder,
+  Phronomy::WorkflowTaskResumeError,
   Phronomy::WorkflowContext,
   Phronomy::Runnable,
-  Phronomy::Agent::Context::Instruction::PromptTemplate,
+  Phronomy::Context::PromptTemplate,
   # Beta
-  Phronomy::Agent::Handoff,
-  Phronomy::Agent::HandoffPolicy,
+  Phronomy::Tool::Schema,
+  Phronomy::Tool::CallRequest,
+  Phronomy::Tool::Operation,
+  Phronomy::LLMAdapter::Base,
+  Phronomy::LLMAdapter::Request,
+  Phronomy::LLMAdapter::Message,
+  Phronomy::LLMAdapter::Response,
+  Phronomy::LLMAdapter::StreamChunk,
+  Phronomy::LLMAdapter::TokenUsage,
+  Phronomy::MultiAgent::Handoff,
+  Phronomy::MultiAgent::HandoffPolicy,
   Phronomy::MultiAgent::HandoffRunner,
   Phronomy::MultiAgent::Orchestrator,
   Phronomy::MultiAgent::TeamCoordinator,
   Phronomy::Filter::Base,
   Phronomy::Filter::PromptInjectionFilter,
+  Phronomy::Storage::AsyncClient,
   Phronomy::VectorStore::Base,
+  Phronomy::VectorStore::AsyncClient,
   Phronomy::VectorStore::InMemory,
-  Phronomy::VectorStore::Embeddings::Base,
+  Phronomy::Embeddings::Base,
+  Phronomy::Embeddings::AsyncClient,
   Phronomy::Tracing::Base,
   Phronomy::Tracing::NullTracer,
   Phronomy::Tools::Mcp,
@@ -67,13 +97,15 @@ def snapshot_entry(klass)
     {
       "name" => klass.name,
       "type" => "module",
-      "public_instance_methods" => own_methods
+      "public_instance_methods" => own_methods,
+      "public_class_methods" => (klass.public_methods(false) - BASELINE_CLASS_METHODS).sort
     }
   else
     internal_context_methods = (klass == Phronomy::InvocationContext) ?
       %i[__bind_execution __execution_scope] : []
     instance_methods = (klass.public_instance_methods - BASELINE_INSTANCE_METHODS - internal_context_methods).sort
-    class_methods = (klass.public_methods(false) - BASELINE_CLASS_METHODS).sort
+    internal_class_methods = (klass == Phronomy::Storage::AsyncClient) ? %i[submit] : []
+    class_methods = (klass.public_methods(false) - BASELINE_CLASS_METHODS - internal_class_methods).sort
     {
       "name" => klass.name,
       "type" => "class",

data/scripts/check_readme_ruby.rb

@@ -1,38 +1,33 @@
 # frozen_string_literal: true
 
-# Extracts every ```ruby ... ``` block from README.md and runs `ruby -c` on each.
-# Exits non-zero if any block has a syntax error.
-
+# Check all Ruby fences, including executable examples, in the entry documents.
 require "tempfile"
 require "open3"
-
-readme_path = File.expand_path("../README.md", __dir__)
-readme = File.read(readme_path)
-blocks = readme.scan(/^```ruby\n(.*?)^```/m).map.with_index(1) { |(code), i| [i, code] }
-
-puts "Checking #{blocks.size} Ruby code blocks in README.md..."
+require_relative "check_readme_runnable"
 
 failures = []
-
-blocks.each do |index, code|
-  Tempfile.create(["readme_block_#{index}", ".rb"]) do |f|
-    f.write(code)
-    f.flush
-    stdout, status = Open3.capture2e("ruby", "-c", f.path)
-    if status.success?
-      puts "  OK   block ##{index}"
-    else
-      failures << index
-      puts "  FAIL block ##{index}"
-      puts stdout.gsub(f.path, "block ##{index}")
+count = 0
+paths = ARGV.empty? ? RunnableDocumentation::PATHS : ARGV
+paths.each do |relative|
+  text = File.read(File.expand_path(relative, RunnableDocumentation::ROOT))
+  text.to_enum(:scan, /^```ruby(?: runnable)?\n(.*?)^```/m).each do
+    match = Regexp.last_match
+    line = text[0...match.begin(1)].count("\n") + 1
+    label = "#{relative}:#{line}"
+    count += 1
+    Tempfile.create(["documentation_block", ".rb"]) do |file|
+      file.write(match[1])
+      file.flush
+      out, status = Open3.capture2e(RbConfig.ruby, "-c", file.path)
+      if status.success?
+        puts "OK   #{label}"
+      else
+        failures << label
+        puts "FAIL #{label}"
+        puts out.gsub(file.path, label)
+      end
     end
   end
 end
-
-if failures.empty?
-  puts "All #{blocks.size} Ruby code blocks passed syntax check."
-  exit 0
-else
-  puts "\n#{failures.size} block(s) failed syntax check: #{failures.join(", ")}"
-  exit 1
-end
+puts "#{count} Ruby blocks; #{failures.size} syntax failures"
+exit(failures.empty? ? 0 : 1)

data/scripts/check_readme_runnable.rb

@@ -1,101 +1,112 @@
 # frozen_string_literal: true
 
-# scripts/check_readme_runnable.rb
-#
-# Extracts ```ruby runnable blocks from README.md and executes each in an
-# isolated subprocess with a fake LLM stub to catch API drift.
-#
-# Any block that raises NoMethodError / ArgumentError / NameError causes a
-# non-zero exit, failing the CI step.
-#
-# Usage (from the phronomy/ root):
-#   bundle exec ruby scripts/check_readme_runnable.rb
-
+# Runs annotated, self-contained examples through the real public API.
+# Only the external LLM adapter is replaced. Each block has its own process,
+# configuration and Runtime; an accidental network request fails immediately.
+# Usage: bundle exec ruby scripts/check_readme_runnable.rb [markdown paths...]
 require "tempfile"
 require "open3"
 
-REPO_ROOT = File.expand_path("..", __dir__)
-README_PATH = File.join(REPO_ROOT, "README.md")
-
-# Injected before every runnable block.
-# Uses the Gemfile of this project so subprocesses can load phronomy.
-PREAMBLE = <<~RUBY
-  # frozen_string_literal: true
-  # --- CI preamble: stub LLM calls so no real network requests are made ---
-  ENV["BUNDLE_GEMFILE"] ||= "#{File.join(REPO_ROOT, "Gemfile")}"
-  require "bundler/setup"
-  require "phronomy"
+module RunnableDocumentation
+  ROOT = File.expand_path("..", __dir__)
+  PATHS = %w[README.md docs/getting-started.md docs/application-recipes.md docs/workflow-completion.md].freeze
+
+  PREAMBLE = <<~RUBY
+    require "bundler/setup"
+    require "phronomy"
+    require "webmock"
+    require "timeout"
+    WebMock.enable!
+    WebMock.disable_net_connect!
+
+    class DocumentationLLM < Phronomy::LLMAdapter::Base
+      protected
+
+      def perform_complete(request, cancellation_token:)
+        previous = request.messages.last
+        if previous&.role == :tool
+          return Phronomy::LLMAdapter::Response.new(content: previous.content)
+        end
 
-  # Patch invoke methods to return canned responses instead of calling the LLM.
-  module Phronomy
-    module Agent
-      # Prepend overrides AsyncEventApi (which is also prepended) so invoke
-      # returns a canned response without triggering the EventLoop.
-      module CiInvokeStub
-        def invoke(input = nil, **)
-          {output: "ci-stub-output", messages: []}
+        search = request.tools.find do |tool|
+          tool.fetch("parameters_schema").fetch("properties", {}).key?("query")
         end
+        if search
+          return Phronomy::LLMAdapter::Response.new(tool_calls: [
+            Phronomy::Tool::CallRequest.new(
+              id: SecureRandom.uuid, name: search.fetch("name"),
+              arguments: {"query" => "Ruby AI frameworks"}
+            )
+          ])
+        end
+
+        Phronomy::LLMAdapter::Response.new(content: "ci-stub-output")
       end
-      Base.prepend(CiInvokeStub)
 
-      class Runner
-        def invoke(input = nil, **)
-          {output: "ci-stub-output", agent: nil, messages: []}
-        end
+      def perform_stream(request, cancellation_token:)
+        response = perform_complete(request, cancellation_token: cancellation_token)
+        yield Phronomy::LLMAdapter::StreamChunk.new(content: response.content) if response.content
+        response
       end
     end
+  RUBY
 
-    module Chain
-      class LLMChain
-        def invoke(vars = {})
-          "ci-stub-chain"
-        end
-      end
+  def self.blocks(path)
+    text = File.read(path)
+    text.to_enum(:scan, /^```ruby runnable\n(.*?)^```/m).map do
+      match = Regexp.last_match
+      [text[0...match.begin(1)].count("\n") + 1, match[1]]
     end
   end
-  # --- end CI preamble ---
-
-RUBY
-
-readme = File.read(README_PATH)
 
-# Match opening fence with 'runnable' annotation: ```ruby runnable
-blocks = readme.scan(/^```ruby runnable\n(.*?)^```/m).map.with_index(1) { |(code), i| [i, code] }
-
-if blocks.empty?
-  puts "No 'ruby runnable' blocks found in README.md."
-  exit 0
-end
-
-puts "Checking #{blocks.size} runnable Ruby block(s) in README.md..."
-
-failures = []
-
-blocks.each do |index, code|
-  Tempfile.create(["readme_runnable_#{index}", ".rb"]) do |f|
-    f.write(PREAMBLE)
-    f.write(code)
-    f.flush
-
-    out, err, status = Open3.capture3(RbConfig.ruby, f.path)
-    combined = (out + err).gsub(f.path, "block ##{index}")
-
-    if status.success?
-      puts "  OK   block ##{index}"
-    else
-      failures << index
-      puts "  FAIL block ##{index}"
-      # Print at most 15 lines of output to keep CI logs readable.
-      puts combined.lines.first(15).join
+  def self.check(paths = PATHS, output: $stdout)
+    failures = []
+    count = 0
+    paths.each do |relative|
+      path = File.expand_path(relative, ROOT)
+      examples = blocks(path)
+      if examples.empty?
+        failures << relative
+        output.puts "FAIL #{relative}: no ruby runnable blocks"
+      end
+      examples.each do |line, code|
+        count += 1
+        label = "#{relative}:#{line}"
+        Tempfile.create(["phronomy_documentation", ".rb"]) do |file|
+          file.write(PREAMBLE)
+          file.write(<<~RUBY)
+            Phronomy.with_configuration do |configuration|
+              configuration.llm_adapter = DocumentationLLM.new
+              begin
+                Timeout.timeout(20) do
+                  eval(#{code.dump}, TOPLEVEL_BINDING, #{path.dump}, #{line})
+                end
+              ensure
+                Phronomy::Runtime.reset_default!(timeout: 5)
+              end
+            end
+          RUBY
+          file.flush
+          out, err, status = Open3.capture3(
+            {"BUNDLE_GEMFILE" => File.join(ROOT, "Gemfile")},
+            RbConfig.ruby, file.path, chdir: ROOT
+          )
+          if status.success?
+            output.puts "OK   #{label}"
+          else
+            failures << label
+            output.puts "FAIL #{label}"
+            output.puts (out + err).gsub(file.path, label).lines.first(15).join
+          end
+        end
+      end
     end
+    output.puts "#{count} runnable examples; #{failures.size} failures"
+    failures.empty?
   end
 end
 
-puts
-if failures.empty?
-  puts "All #{blocks.size} runnable block(s) passed."
-  exit 0
-else
-  puts "#{failures.size} block(s) failed: #{failures.join(", ")}"
-  exit 1
+if $PROGRAM_NAME == __FILE__
+  paths = ARGV.empty? ? RunnableDocumentation::PATHS : ARGV
+  exit(RunnableDocumentation.check(paths) ? 0 : 1)
 end

data/sig/_private/phronomy/agent/settings.rbs

@@ -0,0 +1,19 @@
+module Phronomy
+  module Agent
+    class Settings
+      def self.install_provider: () { () -> Settings } -> void
+      def self.current: () -> Settings
+      def initialize: (llm_adapter: LLMAdapter::Base?, authorization_timeout: Numeric?, stream_callback_error_policy: Symbol) -> void
+      attr_accessor default_model: String?
+      attr_accessor before_llm_input: _BeforeLLMInputHook?
+      attr_accessor agent_store: Store?
+      attr_accessor llm_adapter: LLMAdapter::Base?
+      attr_accessor authorization_timeout: Numeric?
+      attr_accessor stream_callback_error_policy: Symbol
+    end
+  end
+
+  class Configuration
+    attr_reader __agent_settings: Agent::Settings
+  end
+end

data/sig/_private/phronomy/configuration/runtime_settings.rbs

@@ -0,0 +1,20 @@
+module Phronomy
+  # Internal Engine-facing settings; application-specific types do not belong here.
+  class RuntimeSettings
+    def self.install_provider: () { () -> RuntimeSettings } -> void
+    def self.current: () -> RuntimeSettings
+    def initialize: () -> void
+    attr_accessor logger: untyped
+    attr_accessor event_loop_stop_grace_seconds: Numeric
+    attr_accessor event_loop_starvation_threshold_seconds: Numeric?
+    attr_accessor event_loop_dispatch_threshold_seconds: Numeric?
+    attr_accessor offload_pool_size: Integer
+    attr_accessor offload_queue_size: Integer
+    attr_accessor authorization_pool_size: Integer
+    attr_accessor authorization_queue_size: Integer
+  end
+
+  class Configuration
+    attr_reader __runtime_settings: RuntimeSettings
+  end
+end

data/sig/_private/phronomy/llm_adapter/async/async_client.rbs

@@ -0,0 +1,10 @@
+# Framework-internal API. Loaded by -I sig; not exported by gem library loading.
+module Phronomy
+  module LLMAdapter
+    class AsyncClient
+      def initialize: (adapter: Base, ?pool: untyped, ?submitter: _ExecutionSubmitter) -> void
+      def complete_async: (Request request, ?cancellation_token: Concurrency::CancellationToken?, ?pool: untyped) -> TaskResult[Response]
+      def stream_async: (Request request, ?cancellation_token: Concurrency::CancellationToken?, ?pool: untyped) { (StreamChunk chunk) -> void } -> TaskResult[Response]
+    end
+  end
+end

data/sig/_private/phronomy/multi_agent/store.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  module MultiAgent
+    class Store
+      def self.install_configured_provider: () { () -> Store? } -> void
+      def self.configured: () -> Store?
+    end
+  end
+end

data/sig/_private/phronomy/persistence/storage_boundary.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  class Persistence
+    module StorageBoundary
+      def self.call: [T] () { () -> T } -> T
+    end
+  end
+end

data/sig/_private/phronomy/tool/settings.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  module Tool
+    class Settings
+      def self.install_provider: () { () -> Settings } -> void
+      def self.current: () -> Settings
+      attr_accessor max_result_size: Integer?
+    end
+  end
+
+  class Configuration
+    attr_reader __tool_settings: Tool::Settings
+  end
+end

data/sig/_private/phronomy/tracing/settings.rbs

@@ -0,0 +1,15 @@
+module Phronomy
+  module Tracing
+    class Settings
+      def self.install_provider: () { () -> Settings } -> void
+      def self.current: () -> Settings
+      def initialize: (tracer: Tracing::Base?) -> void
+      attr_accessor tracer: Tracing::Base?
+      attr_accessor trace_pii: bool
+    end
+  end
+
+  class Configuration
+    attr_reader __tracing_settings: Tracing::Settings
+  end
+end

data/sig/_private/phronomy/workflow/execution/workflow_settings.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  class WorkflowSettings
+    def self.install_provider: () { () -> WorkflowSettings } -> void
+    def self.current: () -> WorkflowSettings
+    def initialize: (recursion_limit: Integer) -> void
+    attr_accessor recursion_limit: Integer
+    attr_accessor workflow_store: _WorkflowStateRepository?
+  end
+
+  class Configuration
+    attr_reader __workflow_settings: WorkflowSettings
+  end
+end

data/sig/phronomy/agent/admission.rbs

@@ -0,0 +1,19 @@
+module Phronomy
+  module Agent
+    # Coordination owns reservation semantics; Agent owns the acceptance operation.
+    interface _AdmissionOwner
+      def admit: (Admission admission) -> void
+    end
+
+    class Admission
+      attr_reader agent_id: String
+      attr_reader execution_id: String
+      attr_reader correlation: Hash[String, json_value]?
+      def initialize: (persistence: Store, root: untyped, input: String,
+                       config: Hash[Symbol, untyped], preparation_metadata: Hash[String, untyped]) -> void
+      def accept: () -> nil
+      def accept_in: (::Phronomy::Persistence::Transaction scope) -> nil
+      def result: () -> [untyped, untyped]
+    end
+  end
+end

data/sig/phronomy/agent/agent_not_found_error.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  class AgentNotFoundError < Phronomy::Persistence::NotFoundError
+    attr_reader agent_id: String
+    def initialize: (agent_id: untyped) -> void
+  end
+end

data/sig/phronomy/agent/agent_unloaded_error.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  class AgentUnloadedError < Phronomy::Error
+    attr_reader agent_id: String
+    def initialize: (agent_id: String) -> void
+  end
+end