lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/consent/local_persistence_spec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sequel'
+require 'json'
+require 'tmpdir'
+
+RSpec.describe 'lex-consent local SQLite persistence' do
+  let(:db_path) { File.join(Dir.tmpdir, "consent_test_#{Process.pid}_#{rand(9999)}.db") }
+  let(:db) { Sequel.sqlite(db_path) }
+
+  before do
+    # Create the schema in the temp DB
+    db.create_table(:consent_domains) do
+      primary_key :id
+      String :domain_key, null: false, unique: true
+      String :tier, null: false, default: 'consult'
+      Integer :success_count, default: 0
+      Integer :failure_count, default: 0
+      Integer :total_actions, default: 0
+      DateTime :last_changed_at
+      String :history, text: true
+    end
+
+    # Stub Legion::Data::Local to use our temp DB
+    stub_const('Legion::Data::Local', Module.new do
+      def self.connected?
+        true
+      end
+
+      def self.connection
+        @_connection
+      end
+
+      def self._set_connection(conn)
+        @_connection = conn
+      end
+    end)
+
+    Legion::Data::Local._set_connection(db)
+  end
+
+  after do
+    db.disconnect
+    FileUtils.rm_f(db_path)
+  end
+
+  describe 'save_to_local' do
+    it 'writes domain state to the database' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.record_outcome('email', success: true)
+      map.record_outcome('email', success: true)
+      map.save_to_local
+
+      row = db[:consent_domains].where(domain_key: 'email').first
+      expect(row).not_to be_nil
+      expect(row[:domain_key]).to eq('email')
+      expect(row[:tier]).to eq('consult')
+      expect(row[:success_count]).to eq(2)
+      expect(row[:total_actions]).to eq(2)
+    end
+
+    it 'updates an existing row on second save' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.record_outcome('email', success: true)
+      map.save_to_local
+
+      map.record_outcome('email', success: false)
+      map.save_to_local
+
+      rows = db[:consent_domains].where(domain_key: 'email').all
+      expect(rows.size).to eq(1)
+      expect(rows.first[:failure_count]).to eq(1)
+      expect(rows.first[:total_actions]).to eq(2)
+    end
+
+    it 'serializes tier as a string' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.set_tier('scheduling', :autonomous)
+      map.save_to_local
+
+      row = db[:consent_domains].where(domain_key: 'scheduling').first
+      expect(row[:tier]).to eq('autonomous')
+    end
+
+    it 'serializes history as JSON' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.set_tier('scheduling', :autonomous)
+      map.save_to_local
+
+      row = db[:consent_domains].where(domain_key: 'scheduling').first
+      parsed = JSON.parse(row[:history])
+      expect(parsed).to be_an(Array)
+      expect(parsed.first['from']).to eq('consult')
+      expect(parsed.first['to']).to eq('autonomous')
+    end
+
+    it 'persists multiple domains' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.record_outcome('email', success: true)
+      map.record_outcome('calendar', success: false)
+      map.save_to_local
+
+      expect(db[:consent_domains].count).to eq(2)
+    end
+  end
+
+  describe 'load_from_local' do
+    it 'restores domain state from the database' do
+      db[:consent_domains].insert(
+        domain_key:    'email',
+        tier:          'act_notify',
+        success_count: 5,
+        failure_count: 1,
+        total_actions: 6,
+        history:       '[]'
+      )
+
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map.get_tier('email')).to eq(:act_notify)
+      expect(map.domains['email'][:success_count]).to eq(5)
+      expect(map.domains['email'][:total_actions]).to eq(6)
+    end
+
+    it 'restores history as an array of hashes with symbol keys' do
+      history_json = JSON.generate([{ 'from' => 'consult', 'to' => 'act_notify', 'at' => Time.now.utc.to_s }])
+      db[:consent_domains].insert(
+        domain_key:    'scheduling',
+        tier:          'act_notify',
+        success_count: 10,
+        failure_count: 0,
+        total_actions: 10,
+        history:       history_json
+      )
+
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      history = map.domains['scheduling'][:history]
+      expect(history).to be_an(Array)
+      expect(history.first[:from]).to eq(:consult)
+      expect(history.first[:to]).to eq(:act_notify)
+    end
+
+    it 'handles empty history JSON gracefully' do
+      db[:consent_domains].insert(
+        domain_key:    'empty_history',
+        tier:          'consult',
+        success_count: 0,
+        failure_count: 0,
+        total_actions: 0,
+        history:       '[]'
+      )
+
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map.domains['empty_history'][:history]).to eq([])
+    end
+  end
+
+  describe 'round-trip persistence' do
+    it 'saves and restores earned tier' do
+      # First instance: build history and promote
+      map1 = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      15.times { map1.record_outcome('tasks', success: true) }
+      map1.set_tier('tasks', :act_notify)
+      map1.save_to_local
+
+      # Second instance: loads from DB
+      map2 = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map2.get_tier('tasks')).to eq(:act_notify)
+      expect(map2.domains['tasks'][:success_count]).to eq(15)
+      expect(map2.domains['tasks'][:total_actions]).to eq(15)
+    end
+
+    it 'round-trips multiple domains independently' do
+      map1 = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map1.set_tier('email', :autonomous)
+      map1.record_outcome('calendar', success: true)
+      map1.record_outcome('calendar', success: false)
+      map1.save_to_local
+
+      map2 = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map2.get_tier('email')).to eq(:autonomous)
+      expect(map2.get_tier('calendar')).to eq(:consult)
+      expect(map2.domains['calendar'][:success_count]).to eq(1)
+      expect(map2.domains['calendar'][:failure_count]).to eq(1)
+    end
+  end
+
+  describe 'graceful no-op when Legion::Data::Local is unavailable' do
+    before do
+      # Simulate no Legion::Data::Local defined
+      hide_const('Legion::Data::Local')
+    end
+
+    it 'save_to_local does nothing without raising' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.record_outcome('email', success: true)
+      expect { map.save_to_local }.not_to raise_error
+    end
+
+    it 'load_from_local does nothing without raising (no DB loaded at init)' do
+      expect { Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new }.not_to raise_error
+    end
+
+    it 'starts with default in-memory state' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map.get_tier('email')).to eq(:consult)
+    end
+  end
+
+  describe 'graceful no-op when Legion::Data::Local is defined but not connected' do
+    before do
+      stub_const('Legion::Data::Local', Module.new do
+        def self.connected?
+          false
+        end
+      end)
+    end
+
+    it 'save_to_local does nothing without raising' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      map.record_outcome('email', success: true)
+      expect { map.save_to_local }.not_to raise_error
+    end
+
+    it 'initialize completes without raising' do
+      expect { Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new }.not_to raise_error
+    end
+
+    it 'starts with default in-memory state' do
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map.get_tier('email')).to eq(:consult)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/consent/runners/consent_spec.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/consent/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Consent::Runners::Consent do
+  let(:client) { Legion::Extensions::Agentic::Social::Consent::Client.new }
+
+  describe '#check_consent' do
+    it 'returns default tier for new domain' do
+      result = client.check_consent(domain: 'email')
+      expect(result[:tier]).to eq(:consult)
+      expect(result[:needs_consult]).to be true
+    end
+  end
+
+  describe '#record_action' do
+    it 'records action outcome' do
+      result = client.record_action(domain: 'email', success: true)
+      expect(result[:success]).to be true
+      expect(result[:total]).to eq(1)
+    end
+
+    it 'tracks success rate' do
+      3.times { client.record_action(domain: 'email', success: true) }
+      client.record_action(domain: 'email', success: false)
+      result = client.record_action(domain: 'email', success: true)
+      expect(result[:success_rate]).to eq(0.8)
+    end
+  end
+
+  describe '#evaluate_tier_change' do
+    it 'returns ineligible when not enough actions' do
+      result = client.evaluate_tier_change(domain: 'email')
+      expect(result[:recommendation]).to eq(:ineligible)
+    end
+
+    it 'recommends promotion with high success rate' do
+      15.times { client.record_action(domain: 'calendar', success: true) }
+      result = client.evaluate_tier_change(domain: 'calendar')
+      expect(result[:recommendation]).to eq(:promote)
+      expect(result[:proposed_tier]).to eq(:act_notify)
+    end
+
+    it 'recommends demotion with low success rate' do
+      4.times { client.record_action(domain: 'risky', success: true) }
+      8.times { client.record_action(domain: 'risky', success: false) }
+      result = client.evaluate_tier_change(domain: 'risky')
+      expect(result[:recommendation]).to eq(:demote)
+      expect(result[:proposed_tier]).to eq(:human_only)
+    end
+  end
+
+  describe '#apply_tier_change' do
+    it 'changes tier' do
+      result = client.apply_tier_change(domain: 'email', new_tier: :autonomous)
+      expect(result[:new_tier]).to eq(:autonomous)
+      expect(result[:changed]).to be true
+    end
+
+    it 'rejects invalid tier' do
+      result = client.apply_tier_change(domain: 'email', new_tier: :invalid)
+      expect(result[:error]).to eq(:invalid_tier)
+    end
+  end
+
+  describe '#evaluate_all_tiers' do
+    it 'returns zero evaluated for empty consent map' do
+      result = client.evaluate_all_tiers
+      expect(result[:evaluated]).to eq(0)
+      expect(result[:promotions]).to eq([])
+      expect(result[:demotions]).to eq([])
+    end
+
+    it 'includes promoted domains in promotions list' do
+      15.times { client.record_action(domain: 'calendar', success: true) }
+      result = client.evaluate_all_tiers
+      expect(result[:promotions]).to include('calendar')
+    end
+
+    it 'includes demoted domains in demotions list' do
+      4.times { client.record_action(domain: 'risky', success: true) }
+      8.times { client.record_action(domain: 'risky', success: false) }
+      result = client.evaluate_all_tiers
+      expect(result[:demotions]).to include('risky')
+    end
+
+    it 'returns evaluated count matching number of known domains' do
+      client.record_action(domain: 'email', success: true)
+      client.record_action(domain: 'calendar', success: true)
+      result = client.evaluate_all_tiers
+      expect(result[:evaluated]).to eq(2)
+    end
+
+    it 'does not include ineligible domains in promotions or demotions' do
+      client.record_action(domain: 'email', success: true)
+      result = client.evaluate_all_tiers
+      expect(result[:promotions]).not_to include('email')
+      expect(result[:demotions]).not_to include('email')
+    end
+  end
+
+  describe '#request_autonomous_approval' do
+    it 'sets pending state for non-autonomous domain' do
+      client.record_action(domain: 'email', success: true)
+      result = client.request_autonomous_approval(domain: 'email')
+      expect(result[:requested]).to be true
+      expect(result[:proposed_tier]).to eq(:autonomous)
+    end
+
+    it 'rejects if already autonomous' do
+      client.apply_tier_change(domain: 'email', new_tier: :autonomous)
+      result = client.request_autonomous_approval(domain: 'email')
+      expect(result[:requested]).to be false
+      expect(result[:error]).to eq('already_autonomous')
+    end
+
+    it 'rejects if already pending' do
+      client.request_autonomous_approval(domain: 'email')
+      result = client.request_autonomous_approval(domain: 'email')
+      expect(result[:requested]).to be false
+      expect(result[:error]).to eq('already_pending')
+    end
+  end
+
+  describe '#approve_promotion' do
+    it 'applies pending tier change' do
+      client.request_autonomous_approval(domain: 'email')
+      result = client.approve_promotion(domain: 'email', approved_by: 'admin')
+      expect(result[:approved]).to be true
+      expect(result[:new_tier]).to eq(:autonomous)
+      expect(result[:approved_by]).to eq('admin')
+    end
+
+    it 'rejects when no pending approval' do
+      result = client.approve_promotion(domain: 'email', approved_by: 'admin')
+      expect(result[:approved]).to be false
+      expect(result[:error]).to eq('no_pending_approval')
+    end
+  end
+
+  describe '#reject_promotion' do
+    it 'clears pending state' do
+      client.request_autonomous_approval(domain: 'email')
+      result = client.reject_promotion(domain: 'email', rejected_by: 'admin', reason: 'not ready')
+      expect(result[:rejected]).to be true
+      expect(result[:reason]).to eq('not ready')
+    end
+
+    it 'rejects when no pending approval' do
+      result = client.reject_promotion(domain: 'email', rejected_by: 'admin')
+      expect(result[:rejected]).to be false
+    end
+  end
+
+  describe '#expire_pending_approvals' do
+    it 'expires stale approvals' do
+      client.request_autonomous_approval(domain: 'email')
+      result = client.expire_pending_approvals(timeout: 0)
+      expect(result[:expired]).to eq(1)
+    end
+
+    it 'does not expire fresh approvals' do
+      client.request_autonomous_approval(domain: 'email')
+      result = client.expire_pending_approvals(timeout: 999_999)
+      expect(result[:expired]).to eq(0)
+    end
+  end
+
+  describe '#evaluate_and_apply_tiers' do
+    it 'returns summary with zero counts for empty map' do
+      result = client.evaluate_and_apply_tiers
+      expect(result[:evaluated]).to eq(0)
+      expect(result[:applied_promotions]).to eq(0)
+      expect(result[:applied_demotions]).to eq(0)
+      expect(result[:approval_requests]).to eq(0)
+    end
+
+    it 'auto-applies non-autonomous promotions' do
+      15.times { client.record_action(domain: 'calendar', success: true) }
+      result = client.evaluate_and_apply_tiers
+      expect(result[:applied_promotions]).to eq(1)
+      status = client.consent_status(domain: 'calendar')
+      expect(status[:tier]).to eq(:act_notify)
+    end
+
+    it 'requests approval for autonomous promotions instead of auto-applying' do
+      client.apply_tier_change(domain: 'calendar', new_tier: :act_notify)
+      # Backdate last_changed_at to bypass the 24h cooldown
+      map = client.send(:consent_map)
+      map.domains['calendar'][:last_changed_at] = Time.now.utc - 100_000
+      15.times { client.record_action(domain: 'calendar', success: true) }
+      result = client.evaluate_and_apply_tiers
+      expect(result[:approval_requests]).to eq(1)
+      expect(result[:applied_promotions]).to eq(0)
+      status = client.consent_status(domain: 'calendar')
+      expect(status[:tier]).to eq(:act_notify)
+    end
+
+    it 'auto-applies demotions' do
+      4.times { client.record_action(domain: 'risky', success: true) }
+      8.times { client.record_action(domain: 'risky', success: false) }
+      result = client.evaluate_and_apply_tiers
+      expect(result[:applied_demotions]).to eq(1)
+      status = client.consent_status(domain: 'risky')
+      expect(status[:tier]).to eq(:human_only)
+    end
+  end
+
+  describe '#consent_status' do
+    it 'returns domain-specific status' do
+      client.record_action(domain: 'email', success: true)
+      result = client.consent_status(domain: 'email')
+      expect(result[:tier]).to eq(:consult)
+      expect(result[:total]).to eq(1)
+    end
+
+    it 'returns all domains when no domain specified' do
+      client.record_action(domain: 'email', success: true)
+      client.record_action(domain: 'calendar', success: true)
+      result = client.consent_status
+      expect(result[:count]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/entrainment/client_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Entrainment::Client do
+  subject(:client) { described_class.new }
+
+  it 'creates a pairing and records interaction' do
+    created = client.create_entrainment_pairing(
+      agent_a: 'alpha', agent_b: 'beta', domain: :reasoning
+    )
+    result = client.record_entrainment_interaction(
+      pairing_id: created[:pairing_id], aligned: true
+    )
+    expect(result[:success]).to be true
+    expect(result[:synchrony]).to be > 0.0
+  end
+
+  it 'returns stats' do
+    result = client.cognitive_entrainment_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/social/entrainment/helpers/entrainment_engine_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Entrainment::Helpers::EntrainmentEngine do
+  subject(:engine) { described_class.new }
+
+  let(:pairing) { engine.create_pairing(agent_a: 'alpha', agent_b: 'beta', domain: :reasoning) }
+
+  describe '#create_pairing' do
+    it 'creates a pairing' do
+      result = pairing
+      expect(result).to be_a(Legion::Extensions::Agentic::Social::Entrainment::Helpers::Pairing)
+    end
+
+    it 'returns existing pairing for same agents and domain' do
+      first = pairing
+      second = engine.create_pairing(agent_a: 'alpha', agent_b: 'beta', domain: :reasoning)
+      expect(second.id).to eq(first.id)
+    end
+
+    it 'records history' do
+      pairing
+      expect(engine.history.size).to eq(1)
+    end
+  end
+
+  describe '#record_interaction' do
+    it 'records an aligned interaction' do
+      result = engine.record_interaction(pairing_id: pairing.id, aligned: true)
+      expect(result[:success]).to be true
+      expect(result[:synchrony]).to be > 0.0
+    end
+
+    it 'returns error for unknown pairing' do
+      result = engine.record_interaction(pairing_id: 'bad', aligned: true)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#pairings_for' do
+    it 'finds pairings involving an agent' do
+      pairing
+      results = engine.pairings_for(agent_id: 'alpha')
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#entrained_pairings' do
+    it 'returns entrained pairings' do
+      10.times { engine.record_interaction(pairing_id: pairing.id, aligned: true) }
+      expect(engine.entrained_pairings.size).to eq(1)
+    end
+  end
+
+  describe '#entrained_partners' do
+    it 'returns entrained partner agent ids' do
+      10.times { engine.record_interaction(pairing_id: pairing.id, aligned: true) }
+      partners = engine.entrained_partners(agent_id: 'alpha')
+      expect(partners).to include('beta')
+    end
+  end
+
+  describe '#strongest_pairings' do
+    it 'returns sorted by synchrony' do
+      other = engine.create_pairing(agent_a: 'alpha', agent_b: 'gamma', domain: :planning)
+      5.times { engine.record_interaction(pairing_id: pairing.id, aligned: true) }
+      2.times { engine.record_interaction(pairing_id: other.id, aligned: true) }
+      results = engine.strongest_pairings(limit: 2)
+      expect(results.first.synchrony).to be >= results.last.synchrony
+    end
+  end
+
+  describe '#by_domain' do
+    it 'filters by domain' do
+      pairing
+      results = engine.by_domain(domain: :reasoning)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#overall_entrainment' do
+    it 'returns 0.0 with no pairings' do
+      expect(engine.overall_entrainment).to eq(0.0)
+    end
+
+    it 'returns mean synchrony' do
+      3.times { engine.record_interaction(pairing_id: pairing.id, aligned: true) }
+      expect(engine.overall_entrainment).to be > 0.0
+    end
+  end
+
+  describe '#drift_all' do
+    it 'reduces synchrony' do
+      5.times { engine.record_interaction(pairing_id: pairing.id, aligned: true) }
+      original = pairing.synchrony
+      engine.drift_all
+      expect(pairing.synchrony).to be < original
+    end
+  end
+
+  describe '#prune_independent' do
+    it 'removes very low synchrony pairings' do
+      pairing
+      pruned = engine.prune_independent
+      expect(pruned).to be >= 1
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats' do
+      pairing
+      stats = engine.to_h
+      expect(stats[:total_pairings]).to be >= 0
+      expect(stats).to include(:entrained_count, :overall_sync)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/entrainment/helpers/pairing_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Entrainment::Helpers::Pairing do
+  subject(:pairing) do
+    described_class.new(agent_a: 'alpha', agent_b: 'beta', domain: :reasoning)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(pairing.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with zero synchrony' do
+      expect(pairing.synchrony).to eq(0.0)
+    end
+  end
+
+  describe '#interact!' do
+    it 'increases synchrony on aligned interaction' do
+      pairing.interact!(aligned: true)
+      expect(pairing.synchrony).to be > 0.0
+    end
+
+    it 'decreases synchrony on misaligned interaction' do
+      3.times { pairing.interact!(aligned: true) }
+      original = pairing.synchrony
+      pairing.interact!(aligned: false)
+      expect(pairing.synchrony).to be < original
+    end
+
+    it 'increments interaction count' do
+      expect { pairing.interact!(aligned: true) }.to change(pairing, :interaction_count).by(1)
+    end
+  end
+
+  describe '#drift!' do
+    it 'reduces synchrony' do
+      3.times { pairing.interact!(aligned: true) }
+      original = pairing.synchrony
+      pairing.drift!
+      expect(pairing.synchrony).to be < original
+    end
+  end
+
+  describe '#entrained?' do
+    it 'returns false initially' do
+      expect(pairing).not_to be_entrained
+    end
+
+    it 'returns true after many aligned interactions' do
+      10.times { pairing.interact!(aligned: true) }
+      expect(pairing).to be_entrained
+    end
+  end
+
+  describe '#partially_entrained?' do
+    it 'returns true at moderate synchrony' do
+      5.times { pairing.interact!(aligned: true) }
+      expect(pairing).to be_partially_entrained
+    end
+  end
+
+  describe '#sync_label' do
+    it 'returns a symbol' do
+      expect(pairing.sync_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#involves?' do
+    it 'returns true for agent_a' do
+      expect(pairing.involves?('alpha')).to be true
+    end
+
+    it 'returns true for agent_b' do
+      expect(pairing.involves?('beta')).to be true
+    end
+
+    it 'returns false for other agent' do
+      expect(pairing.involves?('gamma')).to be false
+    end
+  end
+
+  describe '#partner_of' do
+    it 'returns agent_b for agent_a' do
+      expect(pairing.partner_of('alpha')).to eq('beta')
+    end
+
+    it 'returns agent_a for agent_b' do
+      expect(pairing.partner_of('beta')).to eq('alpha')
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(pairing.partner_of('gamma')).to be_nil
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash representation' do
+      hash = pairing.to_h
+      expect(hash).to include(:id, :agent_a, :agent_b, :synchrony, :entrained)
+    end
+  end
+end