phronomy 0.26.0 → 0.28.0

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]]) -> void
+  end
+
+  class ExecutionCancellationError < CancellationError
+    attr_reader outcomes: Array[TaskResult::Outcome[untyped]]
+    def initialize: (?String message, outcomes: Array[TaskResult::Outcome[untyped]]) -> 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

@@ -20,27 +20,6 @@ module Phronomy
     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/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
@@ -25,14 +31,16 @@ module Phronomy
       def selectable_categories: () -> Array[Symbol]
       def to_h: () -> Hash[String, Hash[String, String]]
     end
+  end
 
+  module MultiAgent
     class HandoffRunner
       MAX_HANDOFFS: Integer
 
       attr_reader main_agent: ::Phronomy::Agent::Base
-      attr_reader handoffs: Array[Handoff]
+      attr_reader handoffs: Array[::Phronomy::MultiAgent::Handoff]
 
-      def initialize: (main_agent: ::Phronomy::Agent::Base, ?handoffs: Array[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/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.rbs

@@ -1,6 +1,27 @@
 module Phronomy
   module MultiAgent
+    class SharedState
+      class KnowledgeStore
+        def self.new: () -> instance
+        def read_all: () -> Array[Hash[Symbol, untyped]]
+        def write: (agent: untyped, content: untyped, cycle: untyped) -> nil
+        def size: () -> Integer
+      end
+
+      def self.new: () -> instance
+      def self.member: (singleton(::Phronomy::Agent::Base) klass, ?instruction: untyped) -> Array[Hash[Symbol, untyped]]
+      def self.coordination: (?untyped text) -> untyped
+      def self.max_cycles: (?untyped value) -> Integer?
+      def self.timeout: (?untyped value) -> Float?
+      def self.terminate_when: () ?{ (KnowledgeStore) -> untyped } -> untyped
+      def self.aggregate: () ?{ (KnowledgeStore) -> untyped } -> untyped
+      def invoke: (untyped input, ?config: Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    end
+
     class Orchestrator < ::Phronomy::Agent::Base
+      attr_reader coordination_store: Store?
+      def self.create: (?coordination_store: Store?, **Object options) ?{ (Object) -> void } -> instance
+      def self.load: (String agent_id, persistence: Agent::Store, coordination_store: Store, **Object options) ?{ (Object) -> void } -> instance
       def self.subagent: (Symbol | String name, singleton(::Phronomy::Agent::Base) agent_class, ?on_error: Symbol, ?inherit_knowledge: bool) -> untyped
       def self.registered_subagents: () -> Hash[Symbol | String, untyped]
       def resume: (String execution_id, ?config: Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
@@ -10,7 +31,7 @@ module Phronomy
 
     class TeamCoordinator
       attr_reader team_id: String
-      attr_reader persistence: ::Phronomy::Persistence
+      attr_reader persistence: Store
       def self.team_definition: (?id: String?, ?version: Integer?) -> Hash[Symbol, String | Integer]
       def self.coordinator_model: (?String? value) -> String?
       def self.coordinator_instructions: (?String? value) -> String?
@@ -18,9 +39,9 @@ module Phronomy
       def self.pool: (size: Integer, agent: singleton(::Phronomy::Agent::Base), ?on_error: Symbol) -> untyped
       def self.schedule: () { (Array[untyped]) -> untyped } -> untyped
       def self.aggregate: () { (Array[Hash[Symbol, untyped]]) -> untyped } -> untyped
-      def self.new: (?team_id: String, ?persistence: ::Phronomy::Persistence?, ?metadata: Hash[String, untyped], ?on_event: ^(untyped) -> untyped) -> instance
+      def self.new: (?team_id: String, ?persistence: Store?, ?metadata: Hash[String, untyped], ?on_event: ^(untyped) -> untyped) -> instance
       def self.create: (**untyped options) -> instance
-      def self.load: (String team_id, persistence: ::Phronomy::Persistence, ?on_event: ^(untyped) -> untyped) -> instance
+      def self.load: (String team_id, persistence: Store, ?on_event: ^(untyped) -> untyped) -> instance
       def self.get: (String team_id) -> instance?
       def invoke: (untyped input, ?config: Hash[Symbol, untyped]) -> untyped
       def stream: (untyped input, ?config: Hash[Symbol, untyped]) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped

data/sig/phronomy/persistence/errors.rbs

@@ -0,0 +1,18 @@
+module Phronomy
+  class Persistence
+    class TransactionError < Error
+    end
+    class Error < Phronomy::Error
+    end
+    class ConflictError < Error
+    end
+    class StateConflictError < ConflictError
+    end
+    class NotFoundError < Error
+    end
+    class SerializationError < Error
+    end
+    class UnsupportedBackendError < Error
+    end
+  end
+end

data/sig/phronomy/persistence/migration.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  class Persistence
+    module Migration
+      module InitialFormatMigration
+        def self.agent_root: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.agent_execution: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.journal_record: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.workflow_state: (workflow_instance_id: String, revision: Integer, snapshot: Hash[untyped, untyped]) -> Storage::DurableRecord
+        def self.llm_input_manifest: (Hash[untyped, untyped] hash) -> Hash[String, untyped]
+      end
+    end
+  end
+end

data/sig/phronomy/persistence/transaction.rbs

@@ -0,0 +1,19 @@
+module Phronomy
+  class Persistence
+    interface _Participant[T]
+      def new: (Storage::View view) -> T
+    end
+
+    class Transaction
+      def initialize: (Persistence persistence, Storage::View view, ?parent: Transaction?) -> void
+      def participate: [T, R] (persistence: Persistence, adapter: _Participant[T]) { (T) -> R } -> R
+      def outermost?: () -> bool
+      def committed?: () -> bool
+      def validate!: () -> bool
+      def close!: () -> bool
+      def confirm!: () -> bool
+    end
+
+    def atomic: [R] () { (Transaction) -> R } -> R
+  end
+end