lex-agentic-social 0.1.0

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

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

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        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
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        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
+  end
+end

data/lib/legion/extensions/agentic/social/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/agentic/social/trust/runners/trust.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        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
+  end
+end

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

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

data/lib/legion/extensions/agentic/social/trust.rb

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

data/lib/legion/extensions/agentic/social/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        VERSION = '0.1.0'
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'social/version'
+require_relative 'social/mirror'
+require_relative 'social/entrainment'
+require_relative 'social/symbiosis'
+require_relative 'social/apprenticeship'
+require_relative 'social/theory_of_mind'
+require_relative 'social/mentalizing'
+require_relative 'social/social'
+require_relative 'social/social_learning'
+require_relative 'social/perspective_shifting'
+require_relative 'social/trust'
+require_relative 'social/conflict'
+require_relative 'social/conscience'
+require_relative 'social/consent'
+require_relative 'social/moral_reasoning'
+require_relative 'social/governance'
+require_relative 'social/joint_attention'
+require_relative 'social/mirror_system'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+        def remote_invocable?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/apprenticeship/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:create_apprenticeship)
+    expect(client).to respond_to(:conduct_apprenticeship_session)
+    expect(client).to respond_to(:recommend_apprenticeship_method)
+    expect(client).to respond_to(:graduated_apprenticeships)
+    expect(client).to respond_to(:active_apprenticeships)
+    expect(client).to respond_to(:mentor_apprenticeships)
+    expect(client).to respond_to(:apprentice_apprenticeships)
+    expect(client).to respond_to(:domain_apprenticeships)
+    expect(client).to respond_to(:update_cognitive_apprenticeship)
+    expect(client).to respond_to(:cognitive_apprenticeship_stats)
+  end
+end

data/spec/legion/extensions/agentic/social/apprenticeship/cognitive_apprenticeship_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Social::Apprenticeship::VERSION).not_to be_nil
+  end
+
+  it 'has a version that is a string' do
+    expect(Legion::Extensions::Agentic::Social::Apprenticeship::VERSION).to be_a(String)
+  end
+end

data/spec/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_engine_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipEngine do
+  let(:engine) { described_class.new }
+
+  let(:params) do
+    {
+      skill_name:    'terraform',
+      domain:        'infrastructure',
+      mentor_id:     'mentor-1',
+      apprentice_id: 'learner-1'
+    }
+  end
+
+  def create_one
+    engine.create_apprenticeship(**params)
+  end
+
+  describe '#create_apprenticeship' do
+    it 'returns a new Apprenticeship' do
+      appr = create_one
+      expect(appr).to be_a(Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::Apprenticeship)
+    end
+
+    it 'stores the apprenticeship' do
+      appr = create_one
+      expect(engine.get(appr.id)).to eq(appr)
+    end
+
+    it 'increments count' do
+      expect { create_one }.to change(engine, :count).by(1)
+    end
+
+    it 'returns nil at capacity' do
+      stub_const('Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel::MAX_APPRENTICESHIPS', 1)
+      create_one
+      expect(engine.create_apprenticeship(**params)).to be_nil
+    end
+  end
+
+  describe '#conduct_session' do
+    it 'returns the apprenticeship after learning' do
+      appr = create_one
+      result = engine.conduct_session(apprenticeship_id: appr.id, method: :modeling, success: true)
+      expect(result).to eq(appr)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.conduct_session(apprenticeship_id: 'nope', method: :modeling, success: true)).to be_nil
+    end
+
+    it 'records the session' do
+      appr = create_one
+      engine.conduct_session(apprenticeship_id: appr.id, method: :coaching, success: true)
+      expect(engine.sessions.size).to eq(1)
+    end
+  end
+
+  describe '#recommend_method' do
+    it 'returns the recommended method' do
+      appr = create_one
+      method = engine.recommend_method(apprenticeship_id: appr.id)
+      expect(Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel::METHODS).to include(method)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.recommend_method(apprenticeship_id: 'nope')).to be_nil
+    end
+  end
+
+  describe '#graduated_apprenticeships' do
+    it 'returns apprenticeships that have graduated' do
+      appr = create_one
+      30.times { engine.conduct_session(apprenticeship_id: appr.id, method: :exploration, success: true) }
+      expect(engine.graduated_apprenticeships).to include(appr)
+    end
+
+    it 'excludes non-graduated apprenticeships' do
+      create_one
+      expect(engine.graduated_apprenticeships).to be_empty
+    end
+  end
+
+  describe '#active_apprenticeships' do
+    it 'returns non-graduated apprenticeships' do
+      create_one
+      expect(engine.active_apprenticeships.size).to eq(1)
+    end
+
+    it 'excludes graduated apprenticeships' do
+      appr = create_one
+      30.times { engine.conduct_session(apprenticeship_id: appr.id, method: :exploration, success: true) }
+      expect(engine.active_apprenticeships).to be_empty
+    end
+  end
+
+  describe '#by_mentor' do
+    it 'returns apprenticeships for the given mentor' do
+      create_one
+      result = engine.by_mentor(mentor_id: 'mentor-1')
+      expect(result.size).to eq(1)
+    end
+
+    it 'returns empty for unknown mentor' do
+      create_one
+      expect(engine.by_mentor(mentor_id: 'nobody')).to be_empty
+    end
+  end
+
+  describe '#by_apprentice' do
+    it 'returns apprenticeships for the given apprentice' do
+      create_one
+      result = engine.by_apprentice(apprentice_id: 'learner-1')
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#by_domain' do
+    it 'returns apprenticeships in the given domain' do
+      create_one
+      result = engine.by_domain(domain: 'infrastructure')
+      expect(result.size).to eq(1)
+    end
+
+    it 'returns empty for unknown domain' do
+      create_one
+      expect(engine.by_domain(domain: 'unknown')).to be_empty
+    end
+  end
+
+  describe '#decay_all' do
+    it 'applies decay to all apprenticeships and returns count' do
+      create_one
+      expect(engine.decay_all).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a summary hash' do
+      create_one
+      h = engine.to_h
+      expect(h).to include(:total, :active, :graduated, :sessions)
+      expect(h[:total]).to eq(1)
+    end
+  end
+end