phronomy 0.26.0 → 0.28.0

data/lib/phronomy/storage/view.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Root handles route to the current scope; bound handles cannot outlive it.
+    # @api public
+    class View
+      def initialize(backend, scope: nil, context: nil)
+        @backend, @scope, @context = backend, scope, context
+        @handles = {}
+      end
+
+      # @api public
+      def records(resource) = handle(resource, :records, Records)
+      # @api public
+      def streams(resource) = handle(resource, :streams, Streams)
+      # @api public
+      def blobs(resource) = handle(resource, :blobs, Blobs)
+
+      # Acquire stable anchors before evaluating conditions in the same view.
+      # @api public
+      def check!(guards:, conditions:)
+        validate!
+        raise ArgumentError, "guards and conditions must be arrays" unless guards.is_a?(Array) && conditions.is_a?(Array)
+        guards.each do |guard|
+          raise ArgumentError, "expected GuardRef" unless guard.is_a?(GuardRef)
+          resolve(guard.resource, :records)
+        end
+        conditions.each do |condition|
+          case condition
+          when Condition::RevisionIs then resolve(condition.resource, :records)
+          when Condition::StreamHeadIs then resolve(condition.resource, :streams)
+          when Condition::NoRows then resolve(condition.resource, :records).index_values(condition.index, condition.equals)
+          else raise ArgumentError, "unsupported condition"
+          end
+          require_guard!(condition, guards)
+        end
+        atomic do |bound|
+          guards.uniq.sort_by { |g| [resolve(g.resource, :records).id.b, g.key.b] }.each do |guard|
+            bound.perform(:lock_guard, resolve(guard.resource, :records), key: guard.key)
+          end
+          conditions.each do |condition|
+            matched = case condition
+            when Condition::RevisionIs then bound.records(condition.resource).read(condition.key)&.revision == condition.expected
+            when Condition::StreamHeadIs then bound.streams(condition.resource).head(stream: condition.stream) == condition.expected
+            when Condition::NoRows then bound.records(condition.resource).scan(index: condition.index, equals: condition.equals, limit: 1).empty?
+            end
+            raise ConditionFailedError, condition unless matched
+          end
+          true
+        end
+      end
+
+      # Keeps domain encoding/response validation inside the physical transaction.
+      # @api private
+      def atomic
+        validate!
+        unless @scope
+          current = @backend.current_view
+          return current.atomic { |bound| yield bound } if current
+          return @backend.transaction { |bound| bound.atomic { yield bound } }
+        end
+        completed = false
+        begin
+          result = yield self
+          @scope.check!
+          completed = true
+          result
+        ensure
+          @scope.fail! unless completed
+        end
+      end
+
+      # @api private
+      def perform(operation, resource, **arguments)
+        atomic { |bound| bound.dispatch(operation, resource, **arguments) }
+      end
+
+      # @api private
+      def dispatch(operation, resource, **arguments)
+        validate!
+        @backend.execute(@context, operation, resource, **arguments)
+      end
+
+      # @api private
+      def validate!
+        @scope&.check!
+        true
+      end
+
+      private
+
+      def require_guard!(condition, guards)
+        resource = @backend.resources.fetch(condition.resource.is_a?(Resource) ? condition.resource.id : condition.resource)
+        guard = resource.guard
+        return unless guard
+        key = case condition
+        when Condition::RevisionIs
+          if guard[:via] == :key
+            condition.key
+          else
+            raise ArgumentError, "revision checks require a key-based guard"
+          end
+        when Condition::StreamHeadIs then condition.stream
+        when Condition::NoRows
+          condition.equals.fetch(guard[:via]) { raise ArgumentError, "condition must constrain its guard attribute" }
+        end
+        covered = guards.any? do |candidate|
+          resolve(candidate.resource, :records).id == guard[:resource] && candidate.key == key
+        end
+        raise ArgumentError, "condition requires its declared guard" unless covered
+      end
+
+      def resolve(resource, kind)
+        id = resource.is_a?(Resource) ? resource.id : resource
+        registered = @backend.resources[id]
+        valid = registered && registered.kind == kind && (!resource.is_a?(Resource) || registered.equal?(resource))
+        unless valid
+          raise UnsupportedBackendError, "unregistered or mismatched #{kind} resource: #{id}"
+        end
+        registered
+      end
+
+      def handle(resource, kind, type)
+        validate!
+        registered = resolve(resource, kind)
+        @handles[registered.id] ||= type.new(self, registered)
+      end
+    end
+  end
+end

data/lib/phronomy/testing/eval/metrics.rb

@@ -19,7 +19,7 @@ module Phronomy
         end
 
         def total_usage
-          @results.map(&:usage).compact.reduce(Phronomy::TokenUsage.zero, :+)
+          @results.map(&:usage).compact.reduce(Phronomy::LLMAdapter::TokenUsage.zero, :+)
         end
 
         def average_latency_ms

data/lib/phronomy/testing/eval/scorer/llm_judge.rb

@@ -5,6 +5,19 @@ module Phronomy
     module Eval
       module Scorer
         class LlmJudge < Base
+          CLIENT_FACTORIES = {}
+          private_constant :CLIENT_FACTORIES
+
+          # One-time boot binding, not an application extension registry. The
+          # factory runs for each score, after its Request has been prepared.
+          # @api private
+          def self.install_client_factory(factory)
+            raise ArgumentError, "factory must respond to call" unless factory.respond_to?(:call)
+
+            CLIENT_FACTORIES.replace(client: factory).freeze
+            nil
+          end
+
           DEFAULT_PROMPT = <<~PROMPT
             You are an impartial judge evaluating the quality of an AI assistant response.
             Rate the response on a scale from 0.0 (completely wrong or unhelpful) to 1.0 (perfect).
@@ -32,9 +45,12 @@ module Phronomy
               expected: expected.to_s,
               actual: actual.to_s
             )
-            response = Phronomy::Runtime.instance.offload.submit do
-              RubyLLM.chat(model: @model, provider: @provider, assume_model_exists: @assume_model_exists).ask(prompt)
-            end.wait_result
+            request = Phronomy::LLMAdapter::Request.new(
+              model_config: {"model" => @model, "provider" => @provider&.to_s,
+                             "assume_model_exists" => @assume_model_exists}.compact,
+              message: prompt
+            )
+            response = CLIENT_FACTORIES.fetch(:client).call.complete_async(request).wait_result
             response.content.to_s.strip.scan(/-?\d+\.?\d*/).first.to_f.clamp(0.0, 1.0)
           rescue => error
             raise if @raise_on_error

data/lib/phronomy/testing/persistence_contract/a_content_store.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 RSpec.shared_examples "a persistence content store" do
-  let(:content_store) { persistence.contents }
+  let(:content_store) { stores.agent.contents }
 
   it "returns the same content_id for the same bytes" do
     first = content_store.put("same".b, canonicalization_version: 1)

data/lib/phronomy/testing/persistence_contract/a_journal_repository.rb

@@ -3,7 +3,7 @@
 require "securerandom"
 
 RSpec.shared_examples "a Journal repository" do
-  let(:journal_repository) { persistence.journals }
+  let(:journal_repository) { stores.agent.journals }
   let(:journal_agent_root) do
     Phronomy::Agent::AgentRoot.create(
       agent_id: "journal-agent-#{SecureRandom.uuid}",
@@ -25,7 +25,7 @@ RSpec.shared_examples "a Journal repository" do
   end
 
   before do
-    persistence.agents.create(journal_agent_root)
+    stores.agent.agents.create(journal_agent_root)
   end
 
   it "appends records at the expected position and assigns durable sequences" do

data/lib/phronomy/testing/persistence_contract/a_persistence_backend.rb

@@ -3,6 +3,9 @@
 require "securerandom"
 
 RSpec.shared_examples "a Persistence backend" do
+  include_examples "neutral storage primitives"
+  include_examples "storage transaction boundaries"
+
   let(:backend_agent_root) do
     Phronomy::Agent::AgentRoot.create(
       agent_id: "backend-agent-#{SecureRandom.uuid}",
@@ -23,27 +26,26 @@ RSpec.shared_examples "a Persistence backend" do
   end
 
   it "advertises every required capability" do
-    Phronomy::Persistence::REQUIRED_CAPABILITIES.each do |name, required_value|
-      expect(persistence.capabilities[name]).to eq(required_value)
+    Phronomy::Storage::Backend::REQUIRED_CAPABILITIES.each do |name, required_value|
+      expect(stores.coordinator.backend.capabilities[name]).to eq(required_value)
     end
   end
 
-  it "yields a transaction view that exposes the complete durable SPI" do
-    persistence.transaction do |tx|
-      expect(tx).to respond_to(
-        :contents,
-        :agents,
-        :journals,
-        :executions,
-        :workflow_states,
-        :handoff_states, :teams, :team_executions,
-        :assert_agent_watermark!
-      )
+  it "binds each domain to its own record protocol in one common scope" do
+    stores.coordinator.atomic do |scope|
+      stores.agent.participate(scope) do |records|
+        expect(records).to respond_to(:contents, :agents, :journals, :executions, :retentions, :cancellations, :assert_agent_watermark!)
+        expect(records).not_to respond_to(:teams, :team_executions, :workflow_states)
+      end
+      stores.multi_agent.participate(scope) do |records|
+        expect(records).to respond_to(:contents, :teams, :team_executions, :handoff_states)
+        expect(records).not_to respond_to(:agents, :executions, :workflow_states)
+      end
     end
   end
 
   it "returns the transaction block result" do
-    expect(persistence.transaction { |_tx| :contract_result }).to eq(:contract_result)
+    expect(stores.agent.transaction { |_tx| :contract_result }).to eq(:contract_result)
   end
 
   it "commits changes across durable repositories as one transaction" do
@@ -52,7 +54,7 @@ RSpec.shared_examples "a Persistence backend" do
     workflow_id = "workflow-#{SecureRandom.uuid}"
     content_id = nil
 
-    persistence.transaction do |tx|
+    stores.agent.transaction do |tx, scope|
       content_id = tx.contents.put_text("committed")
       tx.agents.create(root)
       appended = tx.journals.append(
@@ -70,11 +72,13 @@ RSpec.shared_examples "a Persistence backend" do
         ]
       )
       tx.executions.create_active(execution)
-      tx.workflow_states.save(
-        workflow_id,
-        expected_revision: nil,
-        snapshot: {fields: {value: "committed"}, phase: "pause"}
-      )
+      scope.participate(persistence: stores.coordinator, adapter: Phronomy::Workflow::Persistence::StateRepository) do |workflow|
+        workflow.save(
+          workflow_id,
+          expected_revision: nil,
+          snapshot: {fields: {value: "committed"}, phase: "pause"}
+        )
+      end
 
       updated_root = root.with(
         agent_revision: 1,
@@ -84,12 +88,12 @@ RSpec.shared_examples "a Persistence backend" do
       tx.agents.save(root.agent_id, expected_revision: 0, root: updated_root)
     end
 
-    expect(persistence.contents.exist?(content_id)).to be(true)
-    expect(persistence.agents.load(root.agent_id).agent_revision).to eq(1)
-    expect(persistence.journals.head(root.agent_id)).to eq(1)
-    expect(persistence.executions.load(execution.execution_id).execution_id)
+    expect(stores.agent.contents.exist?(content_id)).to be(true)
+    expect(stores.agent.agents.load(root.agent_id).agent_revision).to eq(1)
+    expect(stores.agent.journals.head(root.agent_id)).to eq(1)
+    expect(stores.agent.executions.load(execution.execution_id).execution_id)
       .to eq(execution.execution_id)
-    expect(persistence.workflow_states.load(workflow_id)).not_to be_nil
+    expect(stores.workflow.load(workflow_id)).not_to be_nil
   end
 
   it "rolls back all durable repositories when the transaction block raises" do
@@ -99,7 +103,7 @@ RSpec.shared_examples "a Persistence backend" do
     content_id = nil
 
     expect do
-      persistence.transaction do |tx|
+      stores.agent.transaction do |tx, scope|
         content_id = tx.contents.put_text("temporary-#{SecureRandom.uuid}")
         tx.agents.create(root)
         tx.journals.append(
@@ -117,32 +121,34 @@ RSpec.shared_examples "a Persistence backend" do
           ]
         )
         tx.executions.create_active(execution)
-        tx.workflow_states.save(
-          workflow_id,
-          expected_revision: nil,
-          snapshot: {fields: {value: "temporary"}, phase: "pause"}
-        )
+        scope.participate(persistence: stores.coordinator, adapter: Phronomy::Workflow::Persistence::StateRepository) do |workflow|
+          workflow.save(
+            workflow_id,
+            expected_revision: nil,
+            snapshot: {fields: {value: "temporary"}, phase: "pause"}
+          )
+        end
         raise "rollback-contract"
       end
     end.to raise_error("rollback-contract")
 
-    expect(persistence.contents.exist?(content_id)).to be(false)
+    expect(stores.agent.contents.exist?(content_id)).to be(false)
     expect do
-      persistence.agents.load(root.agent_id)
+      stores.agent.agents.load(root.agent_id)
     end.to raise_error(Phronomy::Persistence::NotFoundError)
-    expect(persistence.journals.head(root.agent_id)).to eq(0)
+    expect(stores.agent.journals.head(root.agent_id)).to eq(0)
     expect do
-      persistence.executions.load(execution.execution_id)
+      stores.agent.executions.load(execution.execution_id)
     end.to raise_error(Phronomy::Persistence::NotFoundError)
-    expect(persistence.workflow_states.load(workflow_id)).to be_nil
+    expect(stores.workflow.load(workflow_id)).to be_nil
   end
 
   it "accepts the current Agent revision and Journal position watermark" do
     root = backend_agent_root
-    persistence.agents.create(root)
+    stores.agent.agents.create(root)
 
     expect(
-      persistence.assert_agent_watermark!(
+      stores.agent.assert_agent_watermark!(
         agent_id: root.agent_id,
         agent_revision: root.agent_revision,
         journal_position: root.journal_position
@@ -152,12 +158,12 @@ RSpec.shared_examples "a Persistence backend" do
 
   it "raises ConflictError when the durable Agent revision has advanced" do
     root = backend_agent_root
-    persistence.agents.create(root)
+    stores.agent.agents.create(root)
     advanced = root.with(agent_revision: 1)
-    persistence.agents.save(root.agent_id, expected_revision: 0, root: advanced)
+    stores.agent.agents.save(root.agent_id, expected_revision: 0, root: advanced)
 
     expect do
-      persistence.assert_agent_watermark!(
+      stores.agent.assert_agent_watermark!(
         agent_id: root.agent_id,
         agent_revision: 0,
         journal_position: 0
@@ -167,8 +173,8 @@ RSpec.shared_examples "a Persistence backend" do
 
   it "raises ConflictError when the durable Journal position has advanced" do
     root = backend_agent_root
-    persistence.agents.create(root)
-    persistence.journals.append(
+    stores.agent.agents.create(root)
+    stores.agent.journals.append(
       root.agent_id,
       expected_position: 0,
       records: [
@@ -183,7 +189,7 @@ RSpec.shared_examples "a Persistence backend" do
     )
 
     expect do
-      persistence.assert_agent_watermark!(
+      stores.agent.assert_agent_watermark!(
         agent_id: root.agent_id,
         agent_revision: 0,
         journal_position: 0
@@ -193,13 +199,13 @@ RSpec.shared_examples "a Persistence backend" do
 
   it "rolls back earlier writes when a watermark precondition fails" do
     root = backend_agent_root
-    persistence.agents.create(root)
+    stores.agent.agents.create(root)
     advanced = root.with(agent_revision: 1)
-    persistence.agents.save(root.agent_id, expected_revision: 0, root: advanced)
+    stores.agent.agents.save(root.agent_id, expected_revision: 0, root: advanced)
     temporary_content_id = nil
 
     expect do
-      persistence.transaction do |tx|
+      stores.agent.transaction do |tx, scope|
         temporary_content_id = tx.contents.put_text(
           "watermark-rollback-#{SecureRandom.uuid}"
         )
@@ -211,6 +217,6 @@ RSpec.shared_examples "a Persistence backend" do
       end
     end.to raise_error(Phronomy::Persistence::ConflictError)
 
-    expect(persistence.contents.exist?(temporary_content_id)).to be(false)
+    expect(stores.agent.contents.exist?(temporary_content_id)).to be(false)
   end
 end

data/lib/phronomy/testing/persistence_contract/a_workflow_state_repository.rb

@@ -3,7 +3,7 @@
 require "securerandom"
 
 RSpec.shared_examples "a workflow state repository" do
-  let(:repository) { persistence.workflow_states }
+  let(:repository) { stores.workflow }
 
   def workflow_contract_value(hash, key)
     hash.key?(key) ? hash[key] : hash[key.to_s]

data/lib/phronomy/testing/persistence_contract/an_agent_repository.rb

@@ -3,7 +3,7 @@
 require "securerandom"
 
 RSpec.shared_examples "an Agent repository" do
-  let(:agent_repository) { persistence.agents }
+  let(:agent_repository) { stores.agent.agents }
   let(:agent_root) do
     Phronomy::Agent::AgentRoot.create(
       agent_id: "contract-agent-#{SecureRandom.uuid}",

data/lib/phronomy/testing/persistence_contract/an_execution_repository.rb

@@ -3,7 +3,7 @@
 require "securerandom"
 
 RSpec.shared_examples "an Execution repository" do
-  let(:execution_repository) { persistence.executions }
+  let(:execution_repository) { stores.agent.executions }
   let(:execution_agent_root) do
     Phronomy::Agent::AgentRoot.create(
       agent_id: "execution-agent-#{SecureRandom.uuid}",
@@ -27,7 +27,7 @@ RSpec.shared_examples "an Execution repository" do
   end
 
   before do
-    persistence.agents.create(execution_agent_root)
+    stores.agent.agents.create(execution_agent_root)
   end
 
   it "creates and loads an active execution" do
@@ -68,7 +68,7 @@ RSpec.shared_examples "an Execution repository" do
       agent_definition_id: "contract-agent",
       agent_definition_version: 1
     )
-    persistence.agents.create(other_root)
+    stores.agent.agents.create(other_root)
 
     expect do
       execution_repository.create_active(build_contract_execution(execution_agent_root))
@@ -118,7 +118,7 @@ RSpec.shared_examples "an Execution repository" do
       agent_definition_id: "contract-agent",
       agent_definition_version: 1
     )
-    persistence.agents.create(other_root)
+    stores.agent.agents.create(other_root)
     other = build_contract_execution(other_root).with(
       execution_revision: 1,
       status: :active,
@@ -188,7 +188,7 @@ RSpec.shared_examples "an Execution repository" do
       agent_definition_id: "contract-agent",
       agent_definition_version: 1
     )
-    persistence.agents.create(other_root)
+    stores.agent.agents.create(other_root)
     own = build_contract_execution(execution_agent_root)
     other = build_contract_execution(other_root)
     execution_repository.create_active(own)

data/lib/phronomy/testing/persistence_contract/coordination_repositories.rb

@@ -19,7 +19,7 @@ RSpec.shared_context "coordination repository values" do
   end
   let(:coordination_handoff) do
     now = Time.now.utc.iso8601(6)
-    Phronomy::Agent::HandoffState.new(main_agent_id: SecureRandom.uuid, handoff_revision: 1,
+    Phronomy::MultiAgent::HandoffState.new(main_agent_id: SecureRandom.uuid, handoff_revision: 1,
       active_agent_id: "contract-target", active_handoff_context_ref: nil, phase: "target_pending",
       pending_source_execution_id: "source-execution", pending_target_execution_id: "target-execution",
       created_at: now, updated_at: now, metadata: {})
@@ -30,26 +30,26 @@ RSpec.shared_examples "a Handoff state repository" do
   include_context "coordination repository values"
 
   it "returns nil only for an authoritative absent Handoff anchor" do
-    expect(persistence.handoff_states.load(SecureRandom.uuid)).to be_nil
+    expect(stores.multi_agent.handoff_states.load(SecureRandom.uuid)).to be_nil
   end
 
   it "round-trips the immutable Handoff snapshot and rejects stale routing CAS" do
     value = coordination_handoff
-    persistence.handoff_states.save(value.main_agent_id, expected_revision: nil, state: value)
-    loaded = persistence.handoff_states.load(value.main_agent_id)
+    stores.multi_agent.handoff_states.save(value.main_agent_id, expected_revision: nil, state: value)
+    loaded = stores.multi_agent.handoff_states.load(value.main_agent_id)
     expect(loaded.to_h).to eq(value.to_h)
     expect(loaded).to be_frozen
     updated = value.with(phase: "stable")
-    persistence.handoff_states.save(value.main_agent_id, expected_revision: 1, state: updated)
+    stores.multi_agent.handoff_states.save(value.main_agent_id, expected_revision: 1, state: updated)
     expect do
-      persistence.handoff_states.save(value.main_agent_id, expected_revision: 1, state: updated)
+      stores.multi_agent.handoff_states.save(value.main_agent_id, expected_revision: 1, state: updated)
     end.to raise_error(Phronomy::Persistence::ConflictError)
-    expect(persistence.handoff_states.load(value.main_agent_id).handoff_revision).to eq(2)
+    expect(stores.multi_agent.handoff_states.load(value.main_agent_id).handoff_revision).to eq(2)
   end
 
   it "rejects a snapshot for a different routing anchor" do
     expect do
-      persistence.handoff_states.save("other", expected_revision: nil, state: coordination_handoff)
+      stores.multi_agent.handoff_states.save("other", expected_revision: nil, state: coordination_handoff)
     end.to raise_error(Phronomy::Persistence::SerializationError)
   end
 end
@@ -58,51 +58,51 @@ RSpec.shared_examples "a Team repository" do
   include_context "coordination repository values"
 
   it "round-trips a Team lineage and rejects duplicate creation" do
-    persistence.teams.create(coordination_team)
-    expect(persistence.teams.load(coordination_team.team_id).to_h).to eq(coordination_team.to_h)
-    expect { persistence.teams.create(coordination_team) }.to raise_error(Phronomy::Persistence::ConflictError)
+    stores.multi_agent.teams.create(coordination_team)
+    expect(stores.multi_agent.teams.load(coordination_team.team_id).to_h).to eq(coordination_team.to_h)
+    expect { stores.multi_agent.teams.create(coordination_team) }.to raise_error(Phronomy::Persistence::ConflictError)
   end
 
   it "rejects a stale Team revision" do
-    persistence.teams.create(coordination_team)
+    stores.multi_agent.teams.create(coordination_team)
     updated = coordination_team.with(lifecycle_status: "active")
-    persistence.teams.save(coordination_team.team_id, expected_revision: 0, root: updated)
+    stores.multi_agent.teams.save(coordination_team.team_id, expected_revision: 0, root: updated)
     expect do
-      persistence.teams.save(coordination_team.team_id, expected_revision: 0, root: updated)
+      stores.multi_agent.teams.save(coordination_team.team_id, expected_revision: 0, root: updated)
     end.to raise_error(Phronomy::Persistence::ConflictError)
   end
 
   it "raises NotFoundError for an absent Team" do
-    expect { persistence.teams.load(SecureRandom.uuid) }.to raise_error(Phronomy::Persistence::NotFoundError)
+    expect { stores.multi_agent.teams.load(SecureRandom.uuid) }.to raise_error(Phronomy::Persistence::NotFoundError)
   end
 end
 
 RSpec.shared_examples "a Team execution repository" do
   include_context "coordination repository values"
-  before { persistence.teams.create(coordination_team) }
+  before { stores.multi_agent.teams.create(coordination_team) }
 
   it "atomically admits at most one active run per Team" do
-    persistence.team_executions.create_active(coordination_run)
+    stores.multi_agent.team_executions.create_active(coordination_run)
     other = coordination_run.with(team_execution_id: SecureRandom.uuid, execution_revision: 0)
-    expect { persistence.team_executions.create_active(other) }.to raise_error(Phronomy::AgentBusyError)
-    expect(persistence.team_executions.list_active(coordination_team.team_id).map(&:team_execution_id)).to eq([coordination_run.team_execution_id])
+    expect { stores.multi_agent.team_executions.create_active(other) }.to raise_error(Phronomy::AgentBusyError)
+    expect(stores.multi_agent.team_executions.list_active(coordination_team.team_id).map(&:team_execution_id)).to eq([coordination_run.team_execution_id])
   end
 
   it "releases admission after terminal CAS while retaining discoverable outcomes" do
-    persistence.team_executions.create_active(coordination_run)
+    stores.multi_agent.team_executions.create_active(coordination_run)
     completed = coordination_run.with(status: "completed", phase: "completed")
-    persistence.team_executions.save(coordination_run.team_execution_id, expected_revision: 0, execution: completed)
+    stores.multi_agent.team_executions.save(coordination_run.team_execution_id, expected_revision: 0, execution: completed)
     other = coordination_run.with(team_execution_id: SecureRandom.uuid, execution_revision: 0)
-    persistence.team_executions.create_active(other)
+    stores.multi_agent.team_executions.create_active(other)
     ids = [completed.team_execution_id, other.team_execution_id].sort
-    expect(persistence.team_executions.list(coordination_team.team_id, limit: 1).map(&:team_execution_id)).to eq(ids.first(1))
-    expect(persistence.team_executions.list(coordination_team.team_id, after: ids.first).map(&:team_execution_id)).to eq(ids.last(1))
-    expect(persistence.team_executions.list("other-team")).to be_empty
+    expect(stores.multi_agent.team_executions.list(coordination_team.team_id, limit: 1).map(&:team_execution_id)).to eq(ids.first(1))
+    expect(stores.multi_agent.team_executions.list(coordination_team.team_id, after: ids.first).map(&:team_execution_id)).to eq(ids.last(1))
+    expect(stores.multi_agent.team_executions.list("other-team")).to be_empty
     expect do
-      persistence.team_executions.save(completed.team_execution_id, expected_revision: 0, execution: completed)
+      stores.multi_agent.team_executions.save(completed.team_execution_id, expected_revision: 0, execution: completed)
     end.to raise_error(Phronomy::Persistence::ConflictError)
     expect do
-      persistence.team_executions.save(completed.team_execution_id, expected_revision: 1,
+      stores.multi_agent.team_executions.save(completed.team_execution_id, expected_revision: 1,
         execution: completed.with(status: "active", phase: "coordinator"))
     end.to raise_error(Phronomy::Persistence::ConflictError)
   end
@@ -112,26 +112,32 @@ RSpec.shared_examples "a Team execution repository" do
     root_id = "coordination-rollback-agent-#{SecureRandom.uuid}"
     content_ref = nil
     expect do
-      persistence.transaction do |tx|
-        tx.team_executions.create_active(coordination_run)
-        tx.teams.save(coordination_team.team_id, expected_revision: 0, root: coordination_team.with(lifecycle_status: "active"))
-        tx.handoff_states.save(handoff.main_agent_id, expected_revision: nil, state: handoff)
-        content_ref = tx.contents.put_text("coordination-rollback-#{SecureRandom.uuid}")
-        root = Phronomy::Agent::AgentRoot.create(agent_id: root_id, agent_definition_id: "rollback", agent_definition_version: 1)
-        tx.agents.create(root)
-        tx.journals.append(root_id, expected_position: 0, records: [])
-        record = Phronomy::Agent::JournalRecord.new(agent_id: root_id, kind: :input_received, channel: :external)
-        tx.executions.create_active(Phronomy::Agent::AgentExecution.start(agent_root: root, input_record: record))
-        tx.workflow_states.save(root_id, expected_revision: nil, snapshot: {fields: {value: "committed"}, phase: "pause"})
-        raise "rollback all eight"
+      stores.coordinator.atomic do |scope|
+        stores.multi_agent.participate(scope) do |team|
+          stores.agent.participate(scope) do |agent|
+            scope.participate(persistence: stores.coordinator, adapter: Phronomy::Workflow::Persistence::StateRepository) do |workflow|
+              team.team_executions.create_active(coordination_run)
+              team.teams.save(coordination_team.team_id, expected_revision: 0, root: coordination_team.with(lifecycle_status: "active"))
+              team.handoff_states.save(handoff.main_agent_id, expected_revision: nil, state: handoff)
+              content_ref = agent.contents.put_text("coordination-rollback-#{SecureRandom.uuid}")
+              root = Phronomy::Agent::AgentRoot.create(agent_id: root_id, agent_definition_id: "rollback", agent_definition_version: 1)
+              agent.agents.create(root)
+              agent.journals.append(root_id, expected_position: 0, records: [])
+              record = Phronomy::Agent::JournalRecord.new(agent_id: root_id, kind: :input_received, channel: :external)
+              agent.executions.create_active(Phronomy::Agent::AgentExecution.start(agent_root: root, input_record: record))
+              workflow.save(root_id, expected_revision: nil, snapshot: {fields: {value: "committed"}, phase: "pause"})
+              raise "rollback all eight"
+            end
+          end
+        end
       end
     end.to raise_error(RuntimeError, "rollback all eight")
-    expect(persistence.teams.load(coordination_team.team_id).team_revision).to eq(0)
-    expect(persistence.handoff_states.load(handoff.main_agent_id)).to be_nil
-    expect(persistence.team_executions.list(coordination_team.team_id)).to be_empty
-    expect { persistence.agents.load(root_id) }.to raise_error(Phronomy::Persistence::NotFoundError)
-    expect(persistence.executions.list(root_id)).to be_empty
-    expect(persistence.workflow_states.load(root_id)).to be_nil
-    expect(persistence.contents.exist?(content_ref)).to be(false)
+    expect(stores.multi_agent.teams.load(coordination_team.team_id).team_revision).to eq(0)
+    expect(stores.multi_agent.handoff_states.load(handoff.main_agent_id)).to be_nil
+    expect(stores.multi_agent.team_executions.list(coordination_team.team_id)).to be_empty
+    expect { stores.agent.agents.load(root_id) }.to raise_error(Phronomy::Persistence::NotFoundError)
+    expect(stores.agent.executions.list(root_id)).to be_empty
+    expect(stores.workflow.load(root_id)).to be_nil
+    expect(stores.agent.contents.exist?(content_ref)).to be(false)
   end
 end