lex-trust 0.1.0

data/spec/legion/extensions/trust/helpers/trust_map_spec.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Trust::Helpers::TrustMap do
+  subject(:map) { described_class.new }
+
+  let(:agent_id) { 'agent-001' }
+
+  describe '#initialize' do
+    it 'starts with an empty entries hash' do
+      expect(map.entries).to eq({})
+    end
+  end
+
+  describe '#get' do
+    it 'returns nil for an unknown agent' do
+      expect(map.get(agent_id)).to be_nil
+    end
+
+    it 'returns nil for a known agent in a different domain' do
+      map.get_or_create(agent_id, domain: :code)
+      expect(map.get(agent_id, domain: :ops)).to be_nil
+    end
+
+    it 'returns the entry after it has been created' do
+      map.get_or_create(agent_id)
+      expect(map.get(agent_id)).not_to be_nil
+    end
+
+    it 'retrieves an entry for the correct domain' do
+      map.get_or_create(agent_id, domain: :code)
+      entry = map.get(agent_id, domain: :code)
+      expect(entry[:domain]).to eq(:code)
+    end
+
+    it 'defaults domain to :general' do
+      map.get_or_create(agent_id)
+      entry = map.get(agent_id)
+      expect(entry[:domain]).to eq(:general)
+    end
+  end
+
+  describe '#get_or_create' do
+    it 'creates a new entry for a new agent' do
+      entry = map.get_or_create(agent_id)
+      expect(entry).not_to be_nil
+    end
+
+    it 'returns the same entry on subsequent calls' do
+      first  = map.get_or_create(agent_id)
+      second = map.get_or_create(agent_id)
+      expect(first).to equal(second)
+    end
+
+    it 'initializes composite to NEUTRAL_TRUST' do
+      entry = map.get_or_create(agent_id)
+      expect(entry[:composite]).to eq(Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST)
+    end
+
+    it 'creates independent entries per domain' do
+      general = map.get_or_create(agent_id, domain: :general)
+      code    = map.get_or_create(agent_id, domain: :code)
+      expect(general).not_to equal(code)
+    end
+
+    it 'creates independent entries per agent' do
+      a = map.get_or_create('agent-a')
+      b = map.get_or_create('agent-b')
+      expect(a).not_to equal(b)
+    end
+  end
+
+  describe '#record_interaction' do
+    context 'with a positive interaction' do
+      it 'increments interaction_count by 1' do
+        map.record_interaction(agent_id, positive: true)
+        expect(map.get(agent_id)[:interaction_count]).to eq(1)
+      end
+
+      it 'increments positive_count by 1' do
+        map.record_interaction(agent_id, positive: true)
+        expect(map.get(agent_id)[:positive_count]).to eq(1)
+      end
+
+      it 'does not increment negative_count' do
+        map.record_interaction(agent_id, positive: true)
+        expect(map.get(agent_id)[:negative_count]).to eq(0)
+      end
+
+      it 'increases all dimension values above NEUTRAL_TRUST' do
+        map.record_interaction(agent_id, positive: true)
+        entry = map.get(agent_id)
+        Legion::Extensions::Trust::Helpers::TrustModel::TRUST_DIMENSIONS.each do |dim|
+          expect(entry[:dimensions][dim]).to be > Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST
+        end
+      end
+
+      it 'increases composite above NEUTRAL_TRUST' do
+        map.record_interaction(agent_id, positive: true)
+        expect(map.get(agent_id)[:composite]).to be > Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST
+      end
+
+      it 'sets last_interaction to a recent time' do
+        before = Time.now.utc
+        map.record_interaction(agent_id, positive: true)
+        expect(map.get(agent_id)[:last_interaction]).to be >= before
+      end
+    end
+
+    context 'with a negative interaction' do
+      it 'increments interaction_count by 1' do
+        map.record_interaction(agent_id, positive: false)
+        expect(map.get(agent_id)[:interaction_count]).to eq(1)
+      end
+
+      it 'increments negative_count by 1' do
+        map.record_interaction(agent_id, positive: false)
+        expect(map.get(agent_id)[:negative_count]).to eq(1)
+      end
+
+      it 'does not increment positive_count' do
+        map.record_interaction(agent_id, positive: false)
+        expect(map.get(agent_id)[:positive_count]).to eq(0)
+      end
+
+      it 'decreases composite below NEUTRAL_TRUST' do
+        map.record_interaction(agent_id, positive: false)
+        expect(map.get(agent_id)[:composite]).to be < Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST
+      end
+
+      it 'applies the asymmetric penalty (penalty > reinforcement)' do
+        map.record_interaction(agent_id, positive: true)
+        positive_composite = map.get(agent_id)[:composite]
+        map2 = described_class.new
+        map2.record_interaction(agent_id, positive: false)
+        negative_composite = map2.get(agent_id)[:composite]
+        delta_positive = positive_composite - Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST
+        delta_negative = Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST - negative_composite
+        expect(delta_negative).to be > delta_positive
+      end
+    end
+
+    it 'creates the entry if it does not exist' do
+      map.record_interaction('new-agent', positive: true)
+      expect(map.get('new-agent')).not_to be_nil
+    end
+
+    it 'tracks trust separately per domain' do
+      map.record_interaction(agent_id, positive: true, domain: :code)
+      map.record_interaction(agent_id, positive: false, domain: :ops)
+      expect(map.get(agent_id, domain: :code)[:composite]).to be > map.get(agent_id, domain: :ops)[:composite]
+    end
+  end
+
+  describe '#reinforce_dimension' do
+    it 'increases the targeted dimension' do
+      map.get_or_create(agent_id)
+      map.reinforce_dimension(agent_id, dimension: :competence, amount: 0.2)
+      entry = map.get(agent_id)
+      expect(entry[:dimensions][:competence]).to be > Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST
+    end
+
+    it 'does not change non-targeted dimensions' do
+      map.get_or_create(agent_id)
+      map.reinforce_dimension(agent_id, dimension: :competence, amount: 0.1)
+      entry = map.get(agent_id)
+      expect(entry[:dimensions][:reliability]).to eq(Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST)
+    end
+
+    it 'updates composite after reinforcement' do
+      map.get_or_create(agent_id)
+      original_composite = map.get(agent_id)[:composite]
+      map.reinforce_dimension(agent_id, dimension: :competence, amount: 0.2)
+      expect(map.get(agent_id)[:composite]).to be > original_composite
+    end
+
+    it 'ignores an invalid dimension' do
+      map.get_or_create(agent_id)
+      original = map.get(agent_id)[:composite]
+      map.reinforce_dimension(agent_id, dimension: :invalid_dim)
+      expect(map.get(agent_id)[:composite]).to eq(original)
+    end
+
+    it 'clamps dimension to 1.0 maximum' do
+      map.get_or_create(agent_id)
+      map.reinforce_dimension(agent_id, dimension: :reliability, amount: 5.0)
+      expect(map.get(agent_id)[:dimensions][:reliability]).to eq(1.0)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns 0 when no entries exist' do
+      expect(map.decay_all).to eq(0)
+    end
+
+    it 'returns the number of entries decayed' do
+      map.get_or_create('agent-a')
+      map.get_or_create('agent-b')
+      expect(map.decay_all).to eq(2)
+    end
+
+    it 'reduces each dimension by TRUST_DECAY_RATE' do
+      map.get_or_create(agent_id)
+      map.decay_all
+      entry = map.get(agent_id)
+      Legion::Extensions::Trust::Helpers::TrustModel::TRUST_DIMENSIONS.each do |dim|
+        expected = Legion::Extensions::Trust::Helpers::TrustModel::NEUTRAL_TRUST -
+                   Legion::Extensions::Trust::Helpers::TrustModel::TRUST_DECAY_RATE
+        expect(entry[:dimensions][dim]).to be_within(0.0001).of(expected)
+      end
+    end
+
+    it 'floors dimensions at 0.0 when trust is already near-zero' do
+      map.get_or_create(agent_id)
+      200.times { map.decay_all }
+      entry = map.get(agent_id)
+      Legion::Extensions::Trust::Helpers::TrustModel::TRUST_DIMENSIONS.each do |dim|
+        expect(entry[:dimensions][dim]).to eq(0.0)
+      end
+    end
+
+    it 'recomputes composite after decay' do
+      map.get_or_create(agent_id)
+      before = map.get(agent_id)[:composite]
+      map.decay_all
+      expect(map.get(agent_id)[:composite]).to be < before
+    end
+  end
+
+  describe '#trusted_agents' do
+    it 'returns empty array when no entries exist' do
+      expect(map.trusted_agents).to be_empty
+    end
+
+    it 'returns entries with composite >= min_trust' do
+      5.times { map.record_interaction(agent_id, positive: true) }
+      result = map.trusted_agents
+      expect(result).not_to be_empty
+      result.each do |entry|
+        expect(entry[:composite]).to be >= Legion::Extensions::Trust::Helpers::TrustModel::TRUST_CONSIDER_THRESHOLD
+      end
+    end
+
+    it 'excludes entries below min_trust' do
+      map.record_interaction(agent_id, positive: false)
+      expect(map.trusted_agents).to be_empty
+    end
+
+    it 'filters by domain' do
+      5.times { map.record_interaction(agent_id, positive: true, domain: :code) }
+      map.record_interaction('other-agent', positive: true, domain: :ops)
+      result = map.trusted_agents(domain: :code)
+      expect(result.all? { |e| e[:domain] == :code }).to be true
+    end
+
+    it 'sorts by composite descending' do
+      5.times { map.record_interaction('agent-high', positive: true) }
+      3.times { map.record_interaction('agent-low', positive: true) }
+      result = map.trusted_agents
+      composites = result.map { |e| e[:composite] }
+      expect(composites).to eq(composites.sort.reverse)
+    end
+
+    it 'accepts a custom min_trust threshold' do
+      5.times { map.record_interaction(agent_id, positive: true) }
+      strict_result = map.trusted_agents(min_trust: 0.9)
+      loose_result  = map.trusted_agents(min_trust: 0.3)
+      expect(strict_result.size).to be <= loose_result.size
+    end
+  end
+
+  describe '#delegatable_agents' do
+    it 'requires TRUST_DELEGATE_THRESHOLD (higher than trusted_agents default)' do
+      5.times { map.record_interaction(agent_id, positive: true) }
+      trusted = map.trusted_agents.size
+      delegatable = map.delegatable_agents.size
+      expect(delegatable).to be <= trusted
+    end
+
+    it 'returns empty array when no entries meet the delegation threshold' do
+      map.record_interaction(agent_id, positive: true)
+      expect(map.delegatable_agents).to be_empty
+    end
+  end
+
+  describe '#count' do
+    it 'returns 0 for an empty map' do
+      expect(map.count).to eq(0)
+    end
+
+    it 'counts total entries across all agents and domains' do
+      map.get_or_create('a', domain: :general)
+      map.get_or_create('a', domain: :code)
+      map.get_or_create('b', domain: :general)
+      expect(map.count).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/trust/helpers/trust_model_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Trust::Helpers::TrustModel do
+  describe 'TRUST_DIMENSIONS' do
+    it 'is a frozen array of symbols' do
+      expect(described_class::TRUST_DIMENSIONS).to be_a(Array)
+      expect(described_class::TRUST_DIMENSIONS).to be_frozen
+    end
+
+    it 'contains exactly four dimensions' do
+      expect(described_class::TRUST_DIMENSIONS.size).to eq(4)
+    end
+
+    it 'includes reliability' do
+      expect(described_class::TRUST_DIMENSIONS).to include(:reliability)
+    end
+
+    it 'includes competence' do
+      expect(described_class::TRUST_DIMENSIONS).to include(:competence)
+    end
+
+    it 'includes integrity' do
+      expect(described_class::TRUST_DIMENSIONS).to include(:integrity)
+    end
+
+    it 'includes benevolence' do
+      expect(described_class::TRUST_DIMENSIONS).to include(:benevolence)
+    end
+  end
+
+  describe 'threshold constants' do
+    it 'TRUST_CONSIDER_THRESHOLD is 0.3' do
+      expect(described_class::TRUST_CONSIDER_THRESHOLD).to eq(0.3)
+    end
+
+    it 'TRUST_DELEGATE_THRESHOLD is 0.7' do
+      expect(described_class::TRUST_DELEGATE_THRESHOLD).to eq(0.7)
+    end
+
+    it 'delegate threshold is higher than consider threshold' do
+      expect(described_class::TRUST_DELEGATE_THRESHOLD).to be > described_class::TRUST_CONSIDER_THRESHOLD
+    end
+
+    it 'TRUST_DECAY_RATE is 0.005' do
+      expect(described_class::TRUST_DECAY_RATE).to eq(0.005)
+    end
+
+    it 'TRUST_REINFORCEMENT is 0.05' do
+      expect(described_class::TRUST_REINFORCEMENT).to eq(0.05)
+    end
+
+    it 'TRUST_PENALTY is 0.15' do
+      expect(described_class::TRUST_PENALTY).to eq(0.15)
+    end
+
+    it 'penalty is asymmetrically larger than reinforcement' do
+      expect(described_class::TRUST_PENALTY).to be > described_class::TRUST_REINFORCEMENT
+    end
+
+    it 'NEUTRAL_TRUST is 0.3' do
+      expect(described_class::NEUTRAL_TRUST).to eq(0.3)
+    end
+
+    it 'NEUTRAL_TRUST equals TRUST_CONSIDER_THRESHOLD (new agents are borderline trustworthy)' do
+      expect(described_class::NEUTRAL_TRUST).to eq(described_class::TRUST_CONSIDER_THRESHOLD)
+    end
+  end
+
+  describe '.new_trust_entry' do
+    let(:entry) { described_class.new_trust_entry(agent_id: 'agent-42') }
+
+    it 'sets agent_id' do
+      expect(entry[:agent_id]).to eq('agent-42')
+    end
+
+    it 'defaults domain to :general' do
+      expect(entry[:domain]).to eq(:general)
+    end
+
+    it 'respects a custom domain' do
+      custom = described_class.new_trust_entry(agent_id: 'agent-1', domain: :code)
+      expect(custom[:domain]).to eq(:code)
+    end
+
+    it 'initializes all four dimensions to NEUTRAL_TRUST' do
+      described_class::TRUST_DIMENSIONS.each do |dim|
+        expect(entry[:dimensions][dim]).to eq(described_class::NEUTRAL_TRUST)
+      end
+    end
+
+    it 'sets composite to NEUTRAL_TRUST' do
+      expect(entry[:composite]).to eq(described_class::NEUTRAL_TRUST)
+    end
+
+    it 'starts with zero interaction_count' do
+      expect(entry[:interaction_count]).to eq(0)
+    end
+
+    it 'starts with zero positive_count' do
+      expect(entry[:positive_count]).to eq(0)
+    end
+
+    it 'starts with zero negative_count' do
+      expect(entry[:negative_count]).to eq(0)
+    end
+
+    it 'sets last_interaction to nil' do
+      expect(entry[:last_interaction]).to be_nil
+    end
+
+    it 'sets created_at to a recent UTC time' do
+      before = Time.now.utc
+      e = described_class.new_trust_entry(agent_id: 'x')
+      expect(e[:created_at]).to be >= before
+    end
+
+    it 'returns a different hash for each call' do
+      a = described_class.new_trust_entry(agent_id: 'a')
+      b = described_class.new_trust_entry(agent_id: 'b')
+      expect(a).not_to equal(b)
+    end
+  end
+
+  describe '.composite_score' do
+    it 'returns the arithmetic mean of dimension values' do
+      dims = { reliability: 0.8, competence: 0.6, integrity: 0.4, benevolence: 0.2 }
+      expect(described_class.composite_score(dims)).to be_within(0.0001).of(0.5)
+    end
+
+    it 'returns 1.0 when all dimensions are 1.0' do
+      dims = described_class::TRUST_DIMENSIONS.to_h { |d| [d, 1.0] }
+      expect(described_class.composite_score(dims)).to eq(1.0)
+    end
+
+    it 'returns 0.0 when all dimensions are 0.0' do
+      dims = described_class::TRUST_DIMENSIONS.to_h { |d| [d, 0.0] }
+      expect(described_class.composite_score(dims)).to eq(0.0)
+    end
+
+    it 'returns NEUTRAL_TRUST for freshly initialized dimensions' do
+      dims = described_class::TRUST_DIMENSIONS.to_h { |d| [d, described_class::NEUTRAL_TRUST] }
+      expect(described_class.composite_score(dims)).to eq(described_class::NEUTRAL_TRUST)
+    end
+
+    it 'returns 0.0 for an empty dimensions hash' do
+      expect(described_class.composite_score({})).to eq(0.0)
+    end
+  end
+
+  describe '.clamp' do
+    it 'returns the value when within range' do
+      expect(described_class.clamp(0.5)).to eq(0.5)
+    end
+
+    it 'clamps to 0.0 when value is negative' do
+      expect(described_class.clamp(-0.1)).to eq(0.0)
+    end
+
+    it 'clamps to 1.0 when value exceeds 1.0' do
+      expect(described_class.clamp(1.5)).to eq(1.0)
+    end
+
+    it 'returns exactly 0.0 at the lower boundary' do
+      expect(described_class.clamp(0.0)).to eq(0.0)
+    end
+
+    it 'returns exactly 1.0 at the upper boundary' do
+      expect(described_class.clamp(1.0)).to eq(1.0)
+    end
+
+    it 'accepts custom min/max bounds' do
+      expect(described_class.clamp(5.0, 0.0, 10.0)).to eq(5.0)
+      expect(described_class.clamp(15.0, 0.0, 10.0)).to eq(10.0)
+      expect(described_class.clamp(-1.0, 0.0, 10.0)).to eq(0.0)
+    end
+  end
+end

data/spec/legion/extensions/trust/runners/trust_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/trust/client'
+
+RSpec.describe Legion::Extensions::Trust::Runners::Trust do
+  let(:client) { Legion::Extensions::Trust::Client.new }
+
+  describe '#get_trust' do
+    it 'returns found: false for unknown agent' do
+      result = client.get_trust(agent_id: 'unknown')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#record_trust_interaction' do
+    it 'creates entry and records positive interaction' do
+      result = client.record_trust_interaction(agent_id: 'agent-1', positive: true)
+      expect(result[:positive]).to be true
+      expect(result[:composite]).to be > 0.3 # above neutral
+    end
+
+    it 'creates entry and records negative interaction' do
+      result = client.record_trust_interaction(agent_id: 'agent-1', positive: false)
+      expect(result[:composite]).to be < 0.3 # below neutral
+    end
+
+    it 'asymmetric: penalty > reinforcement' do
+      client.record_trust_interaction(agent_id: 'agent-1', positive: true)
+      client.get_trust(agent_id: 'agent-1')[:trust][:composite]
+
+      client.record_trust_interaction(agent_id: 'agent-1', positive: false)
+      after_negative = client.get_trust(agent_id: 'agent-1')[:trust][:composite]
+
+      # Net of one positive + one negative should be below starting point
+      expect(after_negative).to be < 0.3
+    end
+
+    it 'tracks per domain' do
+      client.record_trust_interaction(agent_id: 'agent-1', domain: :code, positive: true)
+      client.record_trust_interaction(agent_id: 'agent-1', domain: :ops, positive: false)
+
+      code_trust = client.get_trust(agent_id: 'agent-1', domain: :code)
+      ops_trust = client.get_trust(agent_id: 'agent-1', domain: :ops)
+
+      expect(code_trust[:trust][:composite]).to be > ops_trust[:trust][:composite]
+    end
+  end
+
+  describe '#reinforce_trust_dimension' do
+    it 'reinforces specific dimension' do
+      client.record_trust_interaction(agent_id: 'agent-1', positive: true)
+      client.reinforce_trust_dimension(agent_id: 'agent-1', dimension: :competence, amount: 0.2)
+      entry = client.get_trust(agent_id: 'agent-1')[:trust]
+      expect(entry[:dimensions][:competence]).to be > entry[:dimensions][:reliability]
+    end
+  end
+
+  describe '#decay_trust' do
+    it 'decays all entries' do
+      client.record_trust_interaction(agent_id: 'agent-1', positive: true)
+      before = client.get_trust(agent_id: 'agent-1')[:trust][:composite]
+      client.decay_trust
+      after = client.get_trust(agent_id: 'agent-1')[:trust][:composite]
+      expect(after).to be < before
+    end
+  end
+
+  describe '#trusted_agents' do
+    it 'returns agents above threshold' do
+      5.times { client.record_trust_interaction(agent_id: 'agent-1', positive: true) }
+      result = client.trusted_agents
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#delegatable_agents' do
+    it 'requires higher trust for delegation' do
+      3.times { client.record_trust_interaction(agent_id: 'agent-1', positive: true) }
+      trusted = client.trusted_agents
+      delegatable = client.delegatable_agents
+      expect(delegatable[:count]).to be <= trusted[:count]
+    end
+  end
+end