phronomy 0.27.0 → 0.29.0

data/sig/phronomy/engine/concurrency/timer_bindings.rbs

@@ -0,0 +1,22 @@
+module Phronomy
+  interface _TimerQueue
+    def schedule: (seconds: Numeric) { () -> void } -> self
+    def cancel: (^() -> void callback) -> bool
+  end
+
+  module Concurrency
+    class OffloadPool
+      @timer_queue_provider: (^() -> _TimerQueue)?
+      def initialize: (?pool_size: Integer, ?queue_size: Integer, ?name: (String | Symbol)?, ?logger: untyped, ?timer_queue_provider: (^() -> _TimerQueue)?) -> void
+      def begin_shutdown: () -> self
+      def terminated?: () -> bool
+      def shutdown: (?drain_timeout: Numeric, ?deadline: Numeric?) -> self
+    end
+
+    class PoolRegistry
+      @timer_queue_provider: (^() -> _TimerQueue)?
+      def initialize: (?timer_queue_provider: (^() -> _TimerQueue)?) -> void
+      def shutdown: (?deadline: Numeric) -> bool
+    end
+  end
+end

data/sig/phronomy/engine/control_bindings.rbs

@@ -0,0 +1,11 @@
+module Phronomy
+  class FSMSession
+    @terminal_policy: _TerminalPolicy?
+    @event_sink: _FSMEventSink
+  end
+
+  class EventLoop
+    @execution_receivers: Hash[untyped, _ExecutionReceiver]
+    @session_receivers: Hash[String, _ExecutionReceiver]
+  end
+end

data/sig/phronomy/engine/control_protocols.rbs

@@ -0,0 +1,23 @@
+module Phronomy
+  interface _FSMEventSink
+    def post: (Symbol type, ?untyped payload) -> untyped
+  end
+
+  interface _TerminalPolicy
+    def start: (terminal_type: Symbol, context: untyped, event_sink: _FSMEventSink) -> untyped
+    def handles?: (Event event) -> bool
+    def decision_for: (Event event) -> TerminalDecision
+  end
+
+  class Event
+    attr_reader type: Symbol
+    attr_reader payload: untyped
+  end
+
+  class TerminalDecision < Data
+    attr_reader action: (:complete | :fail | :retire)
+    attr_reader error: Exception?
+    def self.new: (action: (:complete | :fail | :retire), error: Exception?) -> instance
+  end
+
+end

data/sig/phronomy/engine/execution_binding.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  module ExecutionBinding
+    def self.submit: [V] (?pool: _ExecutionPool?, ?runtime: _ExecutionRuntime?, ?pool_name: Symbol?, ?size: Integer, ?queue_size: Integer, ?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?on_full: Symbol) { () -> V } -> TaskResult[V]
+    def self.after: (Numeric seconds) { () -> void } -> ^() -> untyped
+  end
+end

data/sig/phronomy/engine/execution_receiver.rbs

@@ -0,0 +1,15 @@
+module Phronomy
+  class EventLoop
+    def __execution_receiver: (key: untyped) -> ExecutionReceiver?
+    def __register_execution_receiver: (key: untyped, receiver: ExecutionReceiver) -> ExecutionReceiver
+    def __synchronize_execution_state: [V] () { () -> V } -> V
+    def __admit_execution: [V] (ExecutionReceiver receiver) { () -> V } -> V
+    def __post_execution: (ExecutionReceiver receiver, untyped message, ?admission: bool, ?completion: TaskResult[untyped]?) -> bool
+    def __route_execution_event: (ExecutionReceiver receiver) { () -> untyped } -> bool
+    def __receiver_cleanup_complete?: () -> bool
+  end
+
+  class Runtime
+    def __event_loop_if_initialized: () -> EventLoop?
+  end
+end

data/sig/phronomy/engine/observability.rbs

@@ -0,0 +1,13 @@
+# Internal lookup operations. None of these methods initializes a resource.
+module Phronomy
+  class Runtime
+    def self.__default_if_initialized: () -> Runtime?
+    def __offload_if_initialized: () -> Concurrency::OffloadPool?
+  end
+
+  module Concurrency
+    class PoolRegistry
+      def default_pool_if_initialized: () -> OffloadPool?
+    end
+  end
+end

data/sig/phronomy/execution/async_operation.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  module AsyncOperation
+    def self.map: [A, B] (_CompletionHandle[A] source, name: String, ?on_error: (^(Exception) -> B)?) { (A) -> B } -> TaskResult[B]
+    def self.call: [A, B] (name: String, ?on_error: (^(Exception) -> B)?, ?transform: ^(A) -> B) { () -> _CompletionHandle[A] } -> TaskResult[B]
+    def self.capture: [V] (name: String, ?on_error: (^(Exception) -> V)?) { () -> V } -> TaskResult[V]
+  end
+end

data/sig/phronomy/execution/blocking.rbs

@@ -0,0 +1,5 @@
+module Phronomy
+  module Blocking
+    def self.call_async: [V] (?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?invocation_context: InvocationContext?) { () -> V } -> TaskResult[V]
+  end
+end

data/sig/phronomy/execution/concurrency/cancellation_token.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  module Concurrency
+    class CancellationToken
+      def self.timeout_after: (Numeric seconds) -> CancellationToken
+      def initialize: (?monotonic_deadline: Float?) -> void
+      def remaining_monotonic_seconds: () -> Float?
+      def on_cancel: () { () -> void } -> self
+      def cancel!: () -> self
+      def cancelled?: () -> bool
+      def raise_if_cancelled!: (?String message) -> nil
+    end
+  end
+end

data/sig/phronomy/execution/concurrency/deadline.rbs

@@ -0,0 +1,10 @@
+module Phronomy
+  module Concurrency
+    class Deadline
+      def self.in: (Numeric seconds) -> instance
+      def initialize: (Numeric monotonic_at) -> void
+      def expired?: () -> bool
+      def remaining_seconds: () -> Float
+    end
+  end
+end

data/sig/phronomy/execution/concurrency/result_composition.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  module Concurrency
+    class ResultComposition
+      @scope: _ExecutionScope?
+    end
+  end
+end

data/sig/phronomy/execution/control_protocols.rbs

@@ -0,0 +1,18 @@
+module Phronomy
+  # Only the operations used across the execution boundary; no concrete runtime.
+  interface _CompletionHandle[A]
+    def on_complete: () { (A?, Exception?) -> void } -> untyped
+  end
+
+  interface _ExecutionScope
+    def __while_open: [V] () { () -> V } -> V?
+    def __open?: () -> bool
+    def __cancellation_token: () -> Concurrency::CancellationToken
+    def __cancellation_error: () -> Exception
+  end
+
+  module WaitPolicy
+    def self.blocking_forbidden?: () -> bool
+    def self.without_blocking: [V] () { () -> V } -> V
+  end
+end

data/sig/phronomy/execution/errors.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  class RecursionLimitError < Error
+  end
+
+  class TimeoutError < Error
+  end
+end

data/sig/phronomy/execution/execution.rbs

@@ -0,0 +1,41 @@
+module Phronomy
+  interface _ExecutionSubmitter
+    def submit: [V] (?cancellation_token: Concurrency::CancellationToken?, ?on_full: Symbol) { () -> V } -> TaskResult[V]
+  end
+
+  interface _ExecutionPool
+    def submit: [V] (?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?on_full: Symbol) { () -> V } -> TaskResult[V]
+  end
+
+  interface _ExecutionRuntime
+    def offload: () -> _ExecutionPool
+    def pool: (Symbol name, size: Integer, queue_size: Integer) -> _ExecutionPool
+  end
+
+  interface _ExecutionBackend
+    def submit: [V] (?pool: _ExecutionPool?, ?runtime: _ExecutionRuntime?, ?pool_name: Symbol?, ?size: Integer, ?queue_size: Integer, ?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?on_full: Symbol) { () -> V } -> TaskResult[V]
+    def after: (Numeric seconds) { () -> void } -> ^() -> untyped
+  end
+  class Execution
+    def self.backend_provider=: (^() -> _ExecutionBackend provider) -> ^() -> _ExecutionBackend
+    def self.submit: [V] (?pool: _ExecutionPool?, ?runtime: _ExecutionRuntime?, ?pool_name: Symbol?, ?size: Integer, ?queue_size: Integer, ?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?on_full: Symbol) { () -> V } -> TaskResult[V]
+    def self.after: (Numeric seconds) { () -> void } -> ^() -> untyped
+    attr_reader invocation_context: InvocationContext
+
+    def self.run_async: [I, V] (Array[I] inputs, ?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?invocation_context: InvocationContext?, ?max_concurrency: Integer?) { (I, Execution) -> TaskResult[V] } -> TaskResult[Array[TaskResult::Outcome[V]]]
+    def self.run: [I, V] (Array[I] inputs, ?timeout: Numeric?, ?cancellation_token: Concurrency::CancellationToken?, ?invocation_context: InvocationContext?, ?max_concurrency: Integer?) { (I, Execution) -> TaskResult[V] } -> Array[TaskResult::Outcome[V]]
+    def start_child: [V] (?invocation_context: InvocationContext?, ?cancellation_token: Concurrency::CancellationToken?, ?parent_task_id: String?) { (InvocationContext, Concurrency::CancellationToken) -> TaskResult[V] } -> TaskResult[V]
+    def observe: [V] (TaskResult[V] source_result) -> TaskResult[V]
+  end
+
+  class ExecutionTimeoutError < TimeoutError
+    attr_reader outcomes: Array[TaskResult::Outcome[untyped]]
+    def initialize: (?String message, outcomes: Array[TaskResult::Outcome[untyped]], ?code: String?) -> void
+  end
+
+  class ExecutionCancellationError < CancellationError
+    attr_reader outcomes: Array[TaskResult::Outcome[untyped]]
+    def initialize: (?String message, outcomes: Array[TaskResult::Outcome[untyped]], ?code: String?) -> void
+  end
+
+end

data/sig/phronomy/execution/execution_receiver.rbs

@@ -0,0 +1,40 @@
+module Phronomy
+  interface _ExecutionReceiver
+    def idle?: () -> bool
+    def deliver: (untyped message) -> untyped
+    def shutdown: (error: Exception?) -> untyped
+    def session_retired: (String session_id, reason: Symbol) -> untyped
+  end
+
+  interface _ExecutionChannel
+    def bound_to?: (untyped owner) -> bool
+    def current?: () -> bool
+    def synchronize: [V] () { () -> V } -> V
+    def admit: [V] (ExecutionReceiver receiver) { () -> V } -> V
+    def post: (ExecutionReceiver receiver, untyped message, admission: bool, completion: TaskResult[untyped]?) -> bool
+    def route: (ExecutionReceiver receiver, type: Symbol, payload: untyped) { () -> String? } -> bool
+  end
+
+  # Internal serial-owner contract; composition supplies the transport.
+  class ExecutionReceiver
+    def self.install_binding: (^() -> untyped provider) -> untyped
+    def self.binding: () -> untyped
+    def self.for: (untyped owner) -> instance
+    def self.existing_for: (untyped owner) -> instance?
+    def initialize: (channel: _ExecutionChannel) -> void
+    def __bound_to?: (untyped owner) -> bool
+    def idle?: () -> bool
+    def deliver: (untyped message) -> untyped
+    def shutdown: (error: Exception?) -> untyped
+    def session_retired: (String fsm_session_id, reason: Symbol) -> untyped
+
+    private
+
+    def synchronize: [V] () { () -> V } -> V
+    def admit: [V] () { () -> V } -> V
+    def post_message: (untyped message, ?admission: bool, ?completion: TaskResult[untyped]?) -> bool
+    def route_event: (type: Symbol, ?payload: untyped) { () -> String? } -> bool
+    def assert_event_loop_thread!: () -> void
+  end
+
+end

data/sig/phronomy/execution/execution_scope_state.rbs

@@ -0,0 +1,9 @@
+module Phronomy
+  class ExecutionScopeState
+    def __while_open: [V] () { () -> V } -> V?
+    def __open?: () -> bool
+    def __cancellation_token: () -> Concurrency::CancellationToken
+    def __cancellation_error: () -> Exception
+    def __set_cancellation_error: (Exception error) -> Exception
+  end
+end

data/sig/phronomy/execution/invocation_context.rbs

@@ -0,0 +1,18 @@
+module Phronomy
+  class InvocationContext
+    @execution_scope: _ExecutionScope?
+    def __bind_execution: (_ExecutionScope? scope) -> self
+    def __execution_scope: () -> _ExecutionScope?
+
+    attr_reader user_id: String?
+    attr_reader cancellation_token: Concurrency::CancellationToken?
+    attr_reader deadline: Concurrency::Deadline?
+    attr_reader token_budget: Integer?
+    attr_reader approval_policy: untyped
+    attr_reader redaction_policy: untyped
+    attr_reader task_id: String?
+    attr_reader parent_task_id: String?
+
+    def initialize: (?user_id: String?, ?cancellation_token: Concurrency::CancellationToken?, ?deadline: Concurrency::Deadline?, ?token_budget: Integer?, ?approval_policy: untyped, ?redaction_policy: untyped, ?task_id: String?, ?parent_task_id: String?) -> void
+  end
+end

data/sig/phronomy/execution/invocation_controls.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  class InvocationControls
+    @scope: _ExecutionScope?
+    attr_reader token: Concurrency::CancellationToken?
+    def self.attach: [V] (TaskResult[V] result, invocation_context: InvocationContext?, cancellation_token: Concurrency::CancellationToken?) -> instance
+    def initialize: (invocation_context: InvocationContext?, cancellation_token: Concurrency::CancellationToken?) -> void
+    def check_start!: () -> nil
+    def bind: [V] (TaskResult[V] result) -> TaskResult[V]
+    def track: [V] (TaskResult[V] result) -> TaskResult[V]
+    def close: () -> untyped
+    def self.effective_timeout_token: (InvocationContext context) -> Concurrency::CancellationToken?
+  end
+end

data/sig/phronomy/execution/task_result.rbs

@@ -0,0 +1,29 @@
+module Phronomy
+  class TaskResult[A]
+    @execution_scope: _ExecutionScope?
+    def __bind_execution: (_ExecutionScope? scope) -> self
+    def __execution_scope: () -> _ExecutionScope?
+    class Outcome[V]
+      attr_reader index: Integer
+      attr_reader status: (:completed | :failed | :cancelled | :unfinished)
+      attr_reader value: V?
+      attr_reader error: Exception?
+    end
+
+    def self.completed: [V] (V value, ?name: String?) -> TaskResult[V]
+                      | (?name: String?) -> TaskResult[nil]
+    def self.failed: (Exception error, ?name: String?) -> TaskResult[untyped]
+    def self.all_settled: [V] (Array[TaskResult[V]] results) -> TaskResult[Array[Outcome[V]]]
+    attr_reader name: String?
+    attr_reader parent: TaskResult[untyped]?
+
+    def status: () -> (:pending | :completed | :failed | :cancelled)
+    def done?: () -> bool
+    def alive?: () -> bool
+    def wait_result: (?timeout: Numeric?) -> A
+    def on_complete: () { (A?, Exception?) -> void } -> self
+    def map: [B] () { (A) -> B } -> TaskResult[B]
+    def flat_map: [B] () { (A) -> TaskResult[B] } -> TaskResult[B]
+  end
+
+end

data/sig/phronomy/extensions.rbs

@@ -14,33 +14,13 @@ module Phronomy
 
   module Tracing
     class Base
+      def self.trace_with: [A] (untyped tracer, String name, ?record_output: bool, ?attributes: Hash[Symbol, untyped]) { (untyped span) -> [A, untyped] } -> A
       def start_span: (String name, **untyped attributes) -> untyped
       def finish_span: (untyped span, ?output: untyped, ?usage: untyped, ?error: Exception?) -> untyped
       def trace: [A] (String name, ?input: untyped, **untyped meta) { (untyped span) -> [A, untyped] } -> A
     end
   end
 
-  module VectorStore
-    class Base
-      def add: (id: String, embedding: Array[Float], ?metadata: Hash[untyped, untyped], ?cancellation_token: Concurrency::CancellationToken?) -> untyped
-      def search: (query_embedding: Array[Float], ?k: Integer, ?cancellation_token: Concurrency::CancellationToken?) -> Array[Hash[Symbol, untyped]]
-      def remove: (id: String) -> untyped
-      def clear: () -> untyped
-      def size: () -> Integer
-
-      def add_async: (id: String, embedding: Array[Float], ?metadata: Hash[untyped, untyped], ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
-      def search_async: (query_embedding: Array[Float], ?k: Integer, ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[Array[Hash[Symbol, untyped]]]
-      def remove_async: (id: String, ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
-      def clear_async: (?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
-    end
-
-    module Embeddings
-      class Base
-        def embed: (String text, ?Concurrency::CancellationToken? cancellation_token) -> Array[Float]
-        def embed_async: (String text, ?Concurrency::CancellationToken? cancellation_token, ?timeout: Numeric?) -> TaskResult[Array[Float]]
-      end
-    end
-  end
   module Testing
     module PersistenceContract
       SHARED_EXAMPLES: Array[String]

data/sig/phronomy/filter/filter_block_error.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  class FilterBlockError < Error
+    attr_reader filter: untyped
+    def initialize: (String message, ?filter: untyped, ?code: String?) -> void
+  end
+end

data/sig/phronomy/generation/low_confidence_error.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  class LowConfidenceError < Error
+    attr_reader result: untyped
+    def initialize: (untyped result, ?code: String?) -> void
+  end
+end

data/sig/phronomy/handoff.rbs

@@ -1,5 +1,5 @@
 module Phronomy
-  module Agent
+  module MultiAgent
     class Handoff
       attr_reader source_agent: ::Phronomy::Agent::Base
       attr_reader target_agent: ::Phronomy::Agent::Base
@@ -10,6 +10,12 @@ module Phronomy
     end
 
     class HandoffPolicy
+      class Rule < Data
+        attr_reader category: Symbol
+        attr_reader mode: Symbol
+        attr_reader default: Symbol?
+      end
+
       CATEGORIES: Array[Symbol]
       MODES: Array[Symbol]
       DEFAULTS: Array[Symbol]
@@ -17,7 +23,7 @@ module Phronomy
       def self.define: () { () -> void } -> HandoffPolicy
       def self.default: () -> HandoffPolicy
 
-      def rule: (Symbol | String) -> untyped
+      def rule: (Symbol | String) -> Rule
       def required?: (Symbol | String) -> bool
       def forbidden?: (Symbol | String) -> bool
       def selectable?: (Symbol | String) -> bool
@@ -32,9 +38,9 @@ module Phronomy
       MAX_HANDOFFS: Integer
 
       attr_reader main_agent: ::Phronomy::Agent::Base
-      attr_reader handoffs: Array[::Phronomy::Agent::Handoff]
+      attr_reader handoffs: Array[::Phronomy::MultiAgent::Handoff]
 
-      def initialize: (main_agent: ::Phronomy::Agent::Base, ?handoffs: Array[::Phronomy::Agent::Handoff]) -> void
+      def initialize: (main_agent: ::Phronomy::Agent::Base, ?handoffs: Array[::Phronomy::MultiAgent::Handoff], persistence: Store) -> void
       def invoke: (untyped input, ?config: Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
       def result: (String execution_id) -> Hash[Symbol, untyped]
       def cancel: (String execution_id) -> Hash[Symbol, untyped]

data/sig/phronomy/integrations.rbs

@@ -0,0 +1,14 @@
+module Phronomy
+  module Integrations
+    class OrderedEventDelivery
+      class ClosedError < Phronomy::Error
+      end
+      class OverflowError < Phronomy::Error
+      end
+      def self.open: [T] (?capacity: Integer, ?batch_size: Integer, ?flush_timeout: Numeric?, deliver: ^(untyped) -> untyped, ?prepare_batch: (^(Array[untyped]) -> Array[untyped])?) { (OrderedEventDelivery) -> T } -> T
+      def initialize: (?capacity: Integer, ?batch_size: Integer, ?prepare_batch: (^(Array[untyped]) -> Array[untyped])?) { (untyped) -> untyped } -> void
+      def publish: (untyped) -> self
+      def close_and_wait: (?timeout: Numeric?) -> self
+    end
+  end
+end

data/sig/phronomy/llm_adapter/backends/ruby_llm.rbs

@@ -0,0 +1,6 @@
+module Phronomy
+  module LLMAdapter
+    class RubyLLM < Base
+    end
+  end
+end

data/sig/phronomy/llm_adapter/base.rbs

@@ -0,0 +1,14 @@
+module Phronomy
+  module LLMAdapter
+    class Base
+      def identity: () -> Hash[String, String?]
+      def input_budget: (Hash[String, untyped] model_config) -> LlmContextWindow::TokenBudget?
+      def complete: (Request request, ?cancellation_token: _CancellationSignal?) -> Response
+      def stream: (Request request, ?cancellation_token: _CancellationSignal?) { (StreamChunk chunk) -> void } -> Response
+      # Protected extension SPI at runtime; RBS has no protected visibility.
+      private
+      def perform_complete: (Request request, cancellation_token: _CancellationSignal?) -> Response
+      def perform_stream: (Request request, cancellation_token: _CancellationSignal?) { (StreamChunk chunk) -> void } -> Response
+    end
+  end
+end

data/sig/phronomy/llm_adapter/usage.rbs

@@ -0,0 +1,14 @@
+module Phronomy
+  module LLMAdapter
+  class TokenUsage
+    attr_reader input: Integer?
+    attr_reader output: Integer?
+    attr_reader cached: Integer?
+    attr_reader cache_creation: Integer?
+    def initialize: (?input: Integer?, ?output: Integer?, ?cached: Integer?, ?cache_creation: Integer?) -> void
+    def self.zero: () -> TokenUsage
+    def +: (TokenUsage? other) -> TokenUsage
+    def to_h: () -> Hash[Symbol, Integer?]
+  end
+end
+end

data/sig/phronomy/llm_adapter/values.rbs

@@ -0,0 +1,43 @@
+module Phronomy
+  module LLMAdapter
+    class Request
+      attr_reader model_config: Hash[String, untyped]
+      attr_reader system: String?
+      attr_reader messages: Array[Message]
+      attr_reader tools: Array[Hash[String, untyped]]
+      attr_reader message: String?
+      def initialize: (?model_config: Hash[String | Symbol, untyped], ?system: String?, ?messages: Array[Message], ?tools: Array[Hash[String, untyped]], ?message: String?) -> void
+    end
+    class Message
+      attr_reader role: Symbol
+      attr_reader content: json_value
+      attr_reader tool_calls: Array[Tool::CallRequest]
+      attr_reader tool_call_id: String?
+      attr_reader metadata: Hash[String, json_value]
+      def initialize: (role: String | Symbol, ?content: json_value, ?tool_calls: Array[Tool::CallRequest], ?tool_call_id: String?, ?metadata: Hash[String, json_value]) -> void
+      def tool_call?: () -> bool
+      def content_present?: () -> bool
+      def to_h: () -> Hash[String, untyped]
+    end
+    class Response < Message
+      attr_reader usage: TokenUsage
+      def initialize: (?content: json_value, ?tool_calls: Array[Tool::CallRequest], ?usage: TokenUsage, ?metadata: Hash[String, json_value], ?role: String | Symbol) -> void
+      def self.from_h: (Hash[String | Symbol, untyped] value) -> Response
+      def to_h: () -> Hash[String, untyped]
+    end
+    class StreamChunk
+      attr_reader content: String?
+      def initialize: (content: String?) -> void
+    end
+    class InvalidResultError < Error
+    end
+    class TransportError < Error
+    end
+    class RateLimitError < TransportError
+    end
+    class AuthenticationError < TransportError
+    end
+    class ContextLengthError < Error
+    end
+  end
+end

data/sig/phronomy/llm_context_window.rbs

@@ -0,0 +1,10 @@
+module Phronomy
+  module LlmContextWindow
+    class TokenBudget
+      attr_reader max_input_tokens: Integer
+      def initialize: (max_input_tokens: Integer) -> void
+      def effective_input_limit: () -> Integer
+      def available: (?used: Integer) -> Integer
+    end
+  end
+end

data/sig/phronomy/multi_agent/reserved_child_admission.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  module MultiAgent
+    class ReservedChildAdmission
+      def initialize: (persistence: (Store | Agent::Store), owner: Hash[String, untyped]) -> void
+      def admit: (::Phronomy::Agent::Admission admission) -> nil
+    end
+  end
+end

data/sig/phronomy/multi_agent/store.rbs

@@ -0,0 +1,54 @@
+module Phronomy
+  interface _HandoffStateRepository
+    def load: (String main_agent_id) -> untyped
+    def load_locked: (String main_agent_id) -> untyped
+    def save: (String main_agent_id, expected_revision: Integer?, state: untyped) -> untyped
+    def delete: (String main_agent_id, expected_revision: Integer) -> untyped
+  end
+
+  interface _TeamRepository
+    def create: (untyped root) -> untyped
+    def load: (String team_id) -> untyped
+    def save: (String team_id, expected_revision: Integer, root: untyped) -> untyped
+    def delete: (String team_id) -> untyped
+  end
+
+  interface _TeamExecutionRepository
+    def create_active: (untyped execution) -> untyped
+    def load: (String team_execution_id) -> untyped
+    def save: (String team_execution_id, expected_revision: Integer, execution: untyped) -> untyped
+    def list_active: (String team_id) -> Array[untyped]
+    def list: (String team_id, ?after: String?, ?limit: Integer) -> Array[untyped]
+    def delete: (String team_execution_id) -> untyped
+    def delete_for_team: (String team_id) -> untyped
+    def assert_idle!: (String team_id) -> untyped
+  end
+
+  module MultiAgent
+    interface _Records
+      def contents: () -> _ContentRepository
+      def handoff_states: () -> _HandoffStateRepository
+      def teams: () -> _TeamRepository
+      def team_executions: () -> _TeamExecutionRepository
+      def guard_team!: (String team_id) -> untyped
+    end
+
+    class Store
+      attr_reader coordinator: ::Phronomy::Persistence
+      attr_reader contents: _ContentRepository
+      attr_reader handoff_states: _HandoffStateRepository
+      attr_reader teams: _TeamRepository
+      attr_reader team_executions: _TeamExecutionRepository
+      attr_reader agent_store: Agent::Store
+      def initialize: (coordinator: ::Phronomy::Persistence, records: ::Phronomy::Persistence::_Participant[_Records], agent_store: Agent::Store) -> void
+      def transaction: [R] () { (_Records, ::Phronomy::Persistence::Transaction) -> R } -> R
+      def participate: [R] (::Phronomy::Persistence::Transaction scope) { (_Records) -> R } -> R
+      def handoff_leaf: (String execution_id, main_agent_id: String, ?scope: ::Phronomy::Persistence::Transaction?) -> Agent::ExecutionObservation
+      def handoff_result: (String execution_id, main_agent_id: String) -> Agent::execution_result
+      def forget_handoff: (String main_agent_id) -> bool
+      def forget_subagents: (agent_id: String, execution_id: String) -> bool
+      def result: (String execution_id) -> Hash[Symbol, untyped]
+      def runs: (String owner_id, ?after: String?, ?limit: Integer) -> Array[untyped]
+    end
+  end
+end

data/sig/phronomy/multi_agent/team_busy_error.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  module MultiAgent
+    class TeamBusyError < Phronomy::Error
+      attr_reader team_id: String
+      def initialize: (?String? message, team_id: untyped) -> void
+    end
+  end
+end

data/sig/phronomy/multi_agent/team_not_found_error.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  module MultiAgent
+    class TeamNotFoundError < Phronomy::Persistence::NotFoundError
+      attr_reader team_id: String
+      def initialize: (?String? message, team_id: untyped) -> void
+    end
+  end
+end