lex-trust 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee93b725a6f165775e614f7dff64a7fe24d9ed596ca3782b22710df86895e763
+  data.tar.gz: bdab508af3b14b60d6821c572bbaaefa6ba59c18f79fd460ab90630319101710
+SHA512:
+  metadata.gz: 34b5000f12abe1eba146fca0bdb2dfd3badf793330e2d488111ceef7f238bd67a0d0f5a216c935e9abd7bb3e4458090c0e3403fad651dac266e094cc2849859b
+  data.tar.gz: 6c93059d3e4685de0d9607831104a58ca71ca3bf8aa1e339336ec5cc9133e557b97e2e5351ecb28e06fc93e01f99b2c371f3fc9f5c3ae1863cad36ee433df6e7

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.75', require: false
+gem 'rubocop-rspec', require: false
+
+gem 'sequel', '>= 5.70'
+gem 'sqlite3', '>= 2.0'

data/lex-trust.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/trust/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-trust'
+  spec.version       = Legion::Extensions::Trust::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Trust'
+  spec.description   = 'Emergent domain-specific trust modeling for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-trust'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-trust'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-trust'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-trust'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-trust/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-trust.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'sequel', '>= 5.70'
+  spec.add_development_dependency 'sqlite3', '>= 2.0'
+end

data/lib/legion/extensions/trust/actors/decay.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Trust
+      module Actor
+        class Decay < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::Trust::Runners::Trust
+          end
+
+          def runner_function
+            'decay_trust'
+          end
+
+          def time
+            300
+          end
+
+          def run_now?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/trust/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/trust/helpers/trust_model'
+require 'legion/extensions/trust/helpers/trust_map'
+require 'legion/extensions/trust/runners/trust'
+
+module Legion
+  module Extensions
+    module Trust
+      class Client
+        include Runners::Trust
+
+        def initialize(**)
+          @trust_map = Helpers::TrustMap.new
+        end
+
+        private
+
+        attr_reader :trust_map
+      end
+    end
+  end
+end

data/lib/legion/extensions/trust/helpers/trust_map.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Trust
+      module Helpers
+        class TrustMap
+          attr_reader :entries
+
+          def initialize
+            @entries = {} # key: "agent_id:domain"
+            load_from_local
+          end
+
+          def get(agent_id, domain: :general)
+            @entries[key(agent_id, domain)]
+          end
+
+          def get_or_create(agent_id, domain: :general)
+            @entries[key(agent_id, domain)] ||= TrustModel.new_trust_entry(agent_id: agent_id, domain: domain)
+          end
+
+          def record_interaction(agent_id, positive:, domain: :general)
+            entry = get_or_create(agent_id, domain: domain)
+            entry[:interaction_count] += 1
+            entry[:last_interaction] = Time.now.utc
+
+            if positive
+              entry[:positive_count] += 1
+              TrustModel::TRUST_DIMENSIONS.each do |dim|
+                entry[:dimensions][dim] = TrustModel.clamp(entry[:dimensions][dim] + TrustModel::TRUST_REINFORCEMENT)
+              end
+            else
+              entry[:negative_count] += 1
+              TrustModel::TRUST_DIMENSIONS.each do |dim|
+                entry[:dimensions][dim] = TrustModel.clamp(entry[:dimensions][dim] - TrustModel::TRUST_PENALTY)
+              end
+            end
+
+            entry[:composite] = TrustModel.composite_score(entry[:dimensions])
+            entry
+          end
+
+          def reinforce_dimension(agent_id, dimension:, domain: :general, amount: TrustModel::TRUST_REINFORCEMENT)
+            entry = get_or_create(agent_id, domain: domain)
+            return unless TrustModel::TRUST_DIMENSIONS.include?(dimension)
+
+            entry[:dimensions][dimension] = TrustModel.clamp(entry[:dimensions][dimension] + amount)
+            entry[:composite] = TrustModel.composite_score(entry[:dimensions])
+          end
+
+          def decay_all
+            decayed = 0
+            @entries.each_value do |entry|
+              TrustModel::TRUST_DIMENSIONS.each do |dim|
+                old = entry[:dimensions][dim]
+                entry[:dimensions][dim] = TrustModel.clamp(old - TrustModel::TRUST_DECAY_RATE)
+              end
+              entry[:composite] = TrustModel.composite_score(entry[:dimensions])
+              decayed += 1
+            end
+            decayed
+          end
+
+          def trusted_agents(domain: :general, min_trust: TrustModel::TRUST_CONSIDER_THRESHOLD)
+            @entries.values
+                    .select { |e| e[:domain] == domain && e[:composite] >= min_trust }
+                    .sort_by { |e| -e[:composite] }
+          end
+
+          def delegatable_agents(domain: :general)
+            trusted_agents(domain: domain, min_trust: TrustModel::TRUST_DELEGATE_THRESHOLD)
+          end
+
+          def count
+            @entries.size
+          end
+
+          def save_to_local
+            return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+            dataset = Legion::Data::Local.connection[:trust_entries]
+
+            @entries.each_value do |entry|
+              row = {
+                agent_id:          entry[:agent_id].to_s,
+                domain:            entry[:domain].to_s,
+                reliability:       entry[:dimensions][:reliability],
+                competence:        entry[:dimensions][:competence],
+                integrity:         entry[:dimensions][:integrity],
+                benevolence:       entry[:dimensions][:benevolence],
+                composite:         entry[:composite],
+                interaction_count: entry[:interaction_count],
+                positive_count:    entry[:positive_count],
+                negative_count:    entry[:negative_count],
+                last_interaction:  entry[:last_interaction],
+                created_at:        entry[:created_at]
+              }
+              existing = dataset.where(agent_id: row[:agent_id], domain: row[:domain]).first
+              if existing
+                dataset.where(agent_id: row[:agent_id], domain: row[:domain])
+                       .update(row.except(:agent_id, :domain))
+              else
+                dataset.insert(row)
+              end
+            end
+
+            # Remove DB rows for entries no longer in memory
+            memory_pairs = @entries.values.map { |e| [e[:agent_id].to_s, e[:domain].to_s] }
+            dataset.each do |row|
+              pair = [row[:agent_id], row[:domain]]
+              dataset.where(agent_id: pair[0], domain: pair[1]).delete unless memory_pairs.include?(pair)
+            end
+          rescue StandardError => e
+            Legion::Logging.warn "[trust] save_to_local failed: #{e.message}" if defined?(Legion::Logging)
+          end
+
+          def load_from_local
+            return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+            Legion::Data::Local.connection[:trust_entries].each do |row|
+              agent_id   = row[:agent_id]
+              domain_str = row[:domain]
+              domain_val = domain_str.to_sym
+              entry_key  = "#{agent_id}:#{domain_str}"
+              @entries[entry_key] = {
+                agent_id:          agent_id,
+                domain:            domain_val,
+                dimensions:        {
+                  reliability: row[:reliability].to_f,
+                  competence:  row[:competence].to_f,
+                  integrity:   row[:integrity].to_f,
+                  benevolence: row[:benevolence].to_f
+                },
+                composite:         row[:composite].to_f,
+                interaction_count: row[:interaction_count].to_i,
+                positive_count:    row[:positive_count].to_i,
+                negative_count:    row[:negative_count].to_i,
+                last_interaction:  row[:last_interaction],
+                created_at:        row[:created_at]
+              }
+            end
+          rescue StandardError => e
+            Legion::Logging.warn "[trust] load_from_local failed: #{e.message}" if defined?(Legion::Logging)
+          end
+
+          private
+
+          def key(agent_id, domain)
+            "#{agent_id}:#{domain}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/trust/helpers/trust_model.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Trust
+      module Helpers
+        module TrustModel
+          # Trust is emergent, multidimensional, domain-specific (spec design-decisions-v5 #4)
+          TRUST_DIMENSIONS = %i[reliability competence integrity benevolence].freeze
+
+          # Thresholds
+          TRUST_CONSIDER_THRESHOLD = 0.3  # minimum trust to consider agent's input
+          TRUST_DELEGATE_THRESHOLD = 0.7  # minimum trust to delegate actions
+          TRUST_DECAY_RATE         = 0.005 # per-cycle decay
+          TRUST_REINFORCEMENT      = 0.05  # per positive interaction
+          TRUST_PENALTY            = 0.15  # per negative interaction (asymmetric)
+          NEUTRAL_TRUST            = 0.3   # starting trust for new agents
+
+          module_function
+
+          def new_trust_entry(agent_id:, domain: :general)
+            {
+              agent_id:          agent_id,
+              domain:            domain,
+              dimensions:        TRUST_DIMENSIONS.to_h { |d| [d, NEUTRAL_TRUST] },
+              composite:         NEUTRAL_TRUST,
+              interaction_count: 0,
+              positive_count:    0,
+              negative_count:    0,
+              last_interaction:  nil,
+              created_at:        Time.now.utc
+            }
+          end
+
+          def composite_score(dimensions)
+            return 0.0 if dimensions.empty?
+
+            dimensions.values.sum / dimensions.size
+          end
+
+          def clamp(value, min = 0.0, max = 1.0)
+            value.clamp(min, max)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/trust/local_migrations/20260316000020_create_trust_entries.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:trust_entries) do
+      primary_key :id
+      String :agent_id, null: false
+      String :domain, null: false
+      Float :reliability, default: 0.3
+      Float :competence, default: 0.3
+      Float :integrity, default: 0.3
+      Float :benevolence, default: 0.3
+      Float :composite, default: 0.3
+      Integer :interaction_count, default: 0
+      Integer :positive_count, default: 0
+      Integer :negative_count, default: 0
+      DateTime :last_interaction
+      DateTime :created_at, null: false
+      unique %i[agent_id domain]
+      index [:agent_id]
+    end
+  end
+end

data/lib/legion/extensions/trust/runners/trust.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Trust
+      module Runners
+        module Trust
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def get_trust(agent_id:, domain: :general, **)
+            entry = trust_map.get(agent_id, domain: domain)
+            if entry
+              Legion::Logging.debug "[trust] get agent=#{agent_id} domain=#{domain} composite=#{entry[:composite].round(2)}"
+              { found: true, trust: entry }
+            else
+              Legion::Logging.debug "[trust] get agent=#{agent_id} domain=#{domain} not found"
+              { found: false, agent_id: agent_id, domain: domain }
+            end
+          end
+
+          def record_trust_interaction(agent_id:, positive:, domain: :general, **)
+            entry = trust_map.record_interaction(agent_id, domain: domain, positive: positive)
+            msg = "[trust] interaction: agent=#{agent_id} domain=#{domain} positive=#{positive} " \
+                  "composite=#{entry[:composite].round(2)} total=#{entry[:interaction_count]}"
+            Legion::Logging.info msg
+            {
+              agent_id:     agent_id,
+              domain:       domain,
+              positive:     positive,
+              composite:    entry[:composite],
+              interactions: entry[:interaction_count]
+            }
+          end
+
+          def reinforce_trust_dimension(agent_id:, dimension:, domain: :general, amount: nil, **)
+            amt = amount || Helpers::TrustModel::TRUST_REINFORCEMENT
+            trust_map.reinforce_dimension(agent_id, domain: domain, dimension: dimension, amount: amt)
+            entry = trust_map.get(agent_id, domain: domain)
+            Legion::Logging.debug "[trust] reinforce: agent=#{agent_id} dimension=#{dimension} amount=#{amt} composite=#{entry[:composite].round(2)}"
+            { agent_id: agent_id, domain: domain, dimension: dimension, composite: entry[:composite] }
+          end
+
+          def decay_trust(**)
+            decayed = trust_map.decay_all
+            Legion::Logging.debug "[trust] decay cycle: entries_updated=#{decayed}"
+            { decayed: decayed }
+          end
+
+          def trusted_agents(domain: :general, min_trust: nil, **)
+            min = min_trust || Helpers::TrustModel::TRUST_CONSIDER_THRESHOLD
+            agents = trust_map.trusted_agents(domain: domain, min_trust: min)
+            Legion::Logging.debug "[trust] trusted agents: domain=#{domain} min=#{min} count=#{agents.size}"
+            { agents: agents, count: agents.size }
+          end
+
+          def delegatable_agents(domain: :general, **)
+            agents = trust_map.delegatable_agents(domain: domain)
+            Legion::Logging.debug "[trust] delegatable agents: domain=#{domain} count=#{agents.size}"
+            { agents: agents, count: agents.size }
+          end
+
+          def trust_status(**)
+            { total_entries: trust_map.count }
+          end
+
+          private
+
+          def trust_map
+            @trust_map ||= Helpers::TrustMap.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/trust/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Trust
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/trust.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/trust/version'
+require 'legion/extensions/trust/helpers/trust_model'
+require 'legion/extensions/trust/helpers/trust_map'
+require 'legion/extensions/trust/runners/trust'
+
+module Legion
+  module Extensions
+    module Trust
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end
+
+if defined?(Legion::Data::Local)
+  Legion::Data::Local.register_migrations(
+    name: :trust,
+    path: File.join(__dir__, 'trust', 'local_migrations')
+  )
+end

data/spec/legion/extensions/trust/actors/decay_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class since legionio gem is not available in test
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+# Intercept the require in the actor file so it doesn't fail
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/trust/actors/decay'
+
+RSpec.describe Legion::Extensions::Trust::Actor::Decay do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it 'returns the Trust module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Trust::Runners::Trust)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns decay_trust' do
+      expect(actor.runner_function).to eq('decay_trust')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 300 seconds' do
+      expect(actor.time).to eq(300)
+    end
+  end
+
+  describe '#run_now?' do
+    it 'returns false' do
+      expect(actor.run_now?).to be false
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+end

data/spec/legion/extensions/trust/client_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/trust/client'
+
+RSpec.describe Legion::Extensions::Trust::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to trust runner methods' do
+    expect(client).to respond_to(:get_trust)
+    expect(client).to respond_to(:record_trust_interaction)
+    expect(client).to respond_to(:reinforce_trust_dimension)
+    expect(client).to respond_to(:decay_trust)
+    expect(client).to respond_to(:trusted_agents)
+    expect(client).to respond_to(:delegatable_agents)
+    expect(client).to respond_to(:trust_status)
+  end
+end