lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/social_learning/helpers/model_agent_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Helpers::ModelAgent do
+  subject(:model) do
+    described_class.new(agent_id: 'agent-abc', domain: :ops, prestige: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(model.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets the agent_id' do
+      expect(model.agent_id).to eq('agent-abc')
+    end
+
+    it 'sets prestige' do
+      expect(model.prestige).to eq(0.5)
+    end
+
+    it 'starts with zero observation_count' do
+      expect(model.observation_count).to eq(0)
+    end
+
+    it 'starts with empty observed_behaviors' do
+      expect(model.observed_behaviors).to be_empty
+    end
+
+    it 'clamps prestige above ceiling to 1.0' do
+      m = described_class.new(agent_id: 'x', domain: :test, prestige: 5.0)
+      expect(m.prestige).to eq(1.0)
+    end
+
+    it 'clamps prestige below floor to 0.0' do
+      m = described_class.new(agent_id: 'x', domain: :test, prestige: -1.0)
+      expect(m.prestige).to eq(0.0)
+    end
+  end
+
+  describe '#observe!' do
+    let(:fake_behavior) { double('ObservedBehavior') }
+
+    it 'increments observation_count' do
+      expect { model.observe!(behavior: fake_behavior, outcome: :neutral) }
+        .to change(model, :observation_count).by(1)
+    end
+
+    it 'increases prestige on positive outcome' do
+      before = model.prestige
+      model.observe!(behavior: fake_behavior, outcome: :positive)
+      expect(model.prestige).to be > before
+    end
+
+    it 'decreases prestige on negative outcome' do
+      before = model.prestige
+      model.observe!(behavior: fake_behavior, outcome: :negative)
+      expect(model.prestige).to be < before
+    end
+
+    it 'does not change prestige on neutral outcome' do
+      before = model.prestige
+      model.observe!(behavior: fake_behavior, outcome: :neutral)
+      expect(model.prestige).to eq(before)
+    end
+
+    it 'tracks success_count for positive outcomes' do
+      model.observe!(behavior: fake_behavior, outcome: :positive)
+      expect(model.success_count).to eq(1)
+    end
+  end
+
+  describe '#prestige_label' do
+    it 'returns :expert for prestige >= 0.8' do
+      model.prestige = 0.9
+      expect(model.prestige_label).to eq(:expert)
+    end
+
+    it 'returns :proficient for prestige in 0.6...0.8' do
+      model.prestige = 0.7
+      expect(model.prestige_label).to eq(:proficient)
+    end
+
+    it 'returns :peer for prestige in 0.4...0.6' do
+      model.prestige = 0.5
+      expect(model.prestige_label).to eq(:peer)
+    end
+
+    it 'returns :novice for prestige in 0.2...0.4' do
+      model.prestige = 0.3
+      expect(model.prestige_label).to eq(:novice)
+    end
+
+    it 'returns :unreliable for prestige below 0.2' do
+      model.prestige = 0.1
+      expect(model.prestige_label).to eq(:unreliable)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no observations' do
+      expect(model.success_rate).to eq(0.0)
+    end
+
+    it 'returns correct ratio after observations' do
+      fake_behavior = double('ObservedBehavior')
+      model.observe!(behavior: fake_behavior, outcome: :positive)
+      model.observe!(behavior: fake_behavior, outcome: :negative)
+      expect(model.success_rate).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      hash = model.to_h
+      expect(hash).to include(:id, :agent_id, :domain, :prestige, :prestige_label,
+                              :observation_count, :success_count, :success_rate,
+                              :behavior_count, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/social_learning/helpers/observed_behavior_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Helpers::ObservedBehavior do
+  subject(:behavior) do
+    described_class.new(
+      model_agent_id: 'model-123',
+      action:         'write_test',
+      domain:         :coding,
+      outcome:        :positive,
+      context:        { language: 'ruby' }
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(behavior.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets retention to 1.0' do
+      expect(behavior.retention).to eq(1.0)
+    end
+
+    it 'sets reproduced to false' do
+      expect(behavior.reproduced).to be false
+    end
+
+    it 'stores the action' do
+      expect(behavior.action).to eq('write_test')
+    end
+
+    it 'stores the domain' do
+      expect(behavior.domain).to eq(:coding)
+    end
+
+    it 'stores the outcome' do
+      expect(behavior.outcome).to eq(:positive)
+    end
+
+    it 'stores context' do
+      expect(behavior.context).to eq({ language: 'ruby' })
+    end
+  end
+
+  describe '#decay_retention!' do
+    it 'reduces retention by RETENTION_DECAY' do
+      before = behavior.retention
+      behavior.decay_retention!
+      expect(behavior.retention).to be < before
+    end
+
+    it 'does not go below 0.0' do
+      50.times { behavior.decay_retention! }
+      expect(behavior.retention).to be >= 0.0
+    end
+  end
+
+  describe '#retained?' do
+    it 'returns true when retention is above REPRODUCTION_CONFIDENCE' do
+      expect(behavior.retained?).to be true
+    end
+
+    it 'returns false when retention has decayed below threshold' do
+      behavior.retention = 0.4
+      expect(behavior.retained?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      hash = behavior.to_h
+      expect(hash).to include(:id, :model_agent_id, :action, :domain, :outcome,
+                              :retention, :reproduced, :retained, :created_at)
+    end
+
+    it 'rounds retention to 4 decimal places' do
+      behavior.decay_retention!
+      hash = behavior.to_h
+      expect(hash[:retention].to_s.split('.').last.length).to be <= 4
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/social_learning/helpers/social_learning_engine_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Helpers::SocialLearningEngine do
+  subject(:engine) { described_class.new }
+
+  let(:model) { engine.register_model(agent_id: 'agent-1', domain: :coding) }
+
+  describe '#register_model' do
+    it 'returns a ModelAgent' do
+      expect(model).to be_a(Legion::Extensions::Agentic::Social::SocialLearning::Helpers::ModelAgent)
+    end
+
+    it 'assigns agent_id and domain' do
+      expect(model.agent_id).to eq('agent-1')
+      expect(model.domain).to eq(:coding)
+    end
+
+    it 'uses DEFAULT_PRESTIGE when none given' do
+      expect(model.prestige).to eq(Legion::Extensions::Agentic::Social::SocialLearning::Helpers::Constants::DEFAULT_PRESTIGE)
+    end
+  end
+
+  describe '#observe_behavior' do
+    it 'returns nil for unknown model' do
+      result = engine.observe_behavior(
+        model_id: 'nonexistent', action: 'do_thing', domain: :coding, outcome: :positive
+      )
+      expect(result).to be_nil
+    end
+
+    it 'returns nil when model prestige is below ATTENTION_THRESHOLD' do
+      low_model = engine.register_model(agent_id: 'low', domain: :coding, prestige: 0.1)
+      result = engine.observe_behavior(
+        model_id: low_model.id, action: 'do_thing', domain: :coding, outcome: :positive
+      )
+      expect(result).to be_nil
+    end
+
+    it 'returns an ObservedBehavior when model passes attention threshold' do
+      behavior = engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      expect(behavior).to be_a(Legion::Extensions::Agentic::Social::SocialLearning::Helpers::ObservedBehavior)
+    end
+
+    it 'updates model prestige on positive outcome' do
+      before = model.prestige
+      engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      expect(model.prestige).to be > before
+    end
+  end
+
+  describe '#retained_behaviors' do
+    before do
+      engine.observe_behavior(
+        model_id: model.id, action: 'action_a', domain: :coding, outcome: :positive
+      )
+    end
+
+    it 'returns behaviors with retention above REPRODUCTION_CONFIDENCE' do
+      result = engine.retained_behaviors
+      expect(result).not_to be_empty
+    end
+
+    it 'filters by domain when given' do
+      engine.observe_behavior(
+        model_id: model.id, action: 'action_b', domain: :ops, outcome: :positive
+      )
+      result = engine.retained_behaviors(domain: :coding)
+      expect(result.all? { |beh| beh.domain == :coding }).to be true
+    end
+  end
+
+  describe '#reproducible_behaviors' do
+    it 'returns behaviors above REPRODUCTION_CONFIDENCE' do
+      engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      result = engine.reproducible_behaviors
+      expect(result).not_to be_empty
+    end
+  end
+
+  describe '#reproduce_behavior' do
+    let(:behavior) do
+      engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+    end
+
+    it 'marks the behavior as reproduced' do
+      engine.reproduce_behavior(behavior_id: behavior.id)
+      expect(behavior.reproduced).to be true
+    end
+
+    it 'returns nil for unknown behavior_id' do
+      result = engine.reproduce_behavior(behavior_id: 'nonexistent')
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#reinforce_reproduction' do
+    let(:behavior) do
+      engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+    end
+
+    it 'boosts model prestige on positive outcome' do
+      before = model.prestige
+      engine.reinforce_reproduction(behavior_id: behavior.id, outcome: :positive)
+      expect(model.prestige).to be > before
+    end
+
+    it 'penalizes model prestige on negative outcome' do
+      before = model.prestige
+      engine.reinforce_reproduction(behavior_id: behavior.id, outcome: :negative)
+      expect(model.prestige).to be < before
+    end
+
+    it 'returns nil for unknown behavior_id' do
+      result = engine.reinforce_reproduction(behavior_id: 'nonexistent', outcome: :positive)
+      expect(result).to be_nil
+    end
+
+    it 'returns a hash with behavior and model_prestige' do
+      result = engine.reinforce_reproduction(behavior_id: behavior.id, outcome: :positive)
+      expect(result).to include(:behavior, :model_prestige)
+    end
+  end
+
+  describe '#best_models' do
+    before do
+      engine.register_model(agent_id: 'agent-2', domain: :ops,    prestige: 0.9)
+      engine.register_model(agent_id: 'agent-3', domain: :coding, prestige: 0.3)
+    end
+
+    it 'returns models sorted by prestige descending' do
+      models = engine.best_models(limit: 3)
+      prestiges = models.map(&:prestige)
+      expect(prestiges).to eq(prestiges.sort.reverse)
+    end
+
+    it 'respects the limit' do
+      models = engine.best_models(limit: 2)
+      expect(models.size).to be <= 2
+    end
+  end
+
+  describe '#by_domain' do
+    before do
+      engine.register_model(agent_id: 'agent-ops', domain: :ops)
+    end
+
+    it 'returns only models in the given domain' do
+      result = engine.by_domain(domain: :ops)
+      expect(result.all? { |mod| mod.domain == :ops }).to be true
+    end
+
+    it 'returns empty array for unknown domain' do
+      result = engine.by_domain(domain: :unknown_domain)
+      expect(result).to be_empty
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays retention on all behaviors' do
+      behavior = engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      before = behavior.retention
+      engine.decay_all
+      expect(behavior.retention).to be < before
+    end
+  end
+
+  describe '#prune_forgotten' do
+    it 'removes behaviors below 0.05 retention' do
+      behavior = engine.observe_behavior(
+        model_id: model.id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      behavior.retention = 0.04
+      engine.prune_forgotten
+      expect(engine.retained_behaviors).not_to include(behavior)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      result = engine.to_h
+      expect(result).to include(:model_count, :behavior_count, :retained_count, :reproducible_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/social_learning/runners/social_learning_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Runners::SocialLearning do
+  let(:client) { Legion::Extensions::Agentic::Social::SocialLearning::Client.new }
+
+  describe '#register_model_agent' do
+    it 'returns success with model hash' do
+      result = client.register_model_agent(agent_id: 'agent-1', domain: :coding)
+      expect(result[:success]).to be true
+      expect(result[:model]).to include(:id, :agent_id, :domain, :prestige)
+    end
+
+    it 'accepts custom prestige' do
+      result = client.register_model_agent(agent_id: 'agent-1', domain: :coding, prestige: 0.8)
+      expect(result[:model][:prestige]).to eq(0.8)
+    end
+  end
+
+  describe '#observe_agent_behavior' do
+    let(:model_id) do
+      client.register_model_agent(agent_id: 'agent-1', domain: :coding)[:model][:id]
+    end
+
+    it 'returns success with behavior hash when model passes attention threshold' do
+      result = client.observe_agent_behavior(
+        model_id: model_id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+      expect(result[:success]).to be true
+      expect(result[:behavior]).to include(:id, :action, :retention)
+    end
+
+    it 'returns success: false for unknown model_id' do
+      result = client.observe_agent_behavior(
+        model_id: 'nonexistent', action: 'do_thing', domain: :coding, outcome: :positive
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#retained_behaviors' do
+    before do
+      model_id = client.register_model_agent(agent_id: 'agent-1', domain: :coding)[:model][:id]
+      client.observe_agent_behavior(
+        model_id: model_id, action: 'write_test', domain: :coding, outcome: :positive
+      )
+    end
+
+    it 'returns behaviors with count' do
+      result = client.retained_behaviors
+      expect(result[:success]).to be true
+      expect(result).to include(:behaviors, :count)
+    end
+
+    it 'filters by domain' do
+      result = client.retained_behaviors(domain: :coding)
+      expect(result[:behaviors].all? { |beh| beh[:domain] == :coding }).to be true
+    end
+  end
+
+  describe '#reproducible_behaviors' do
+    it 'returns success: true with behaviors list' do
+      result = client.reproducible_behaviors
+      expect(result[:success]).to be true
+      expect(result).to include(:behaviors, :count)
+    end
+  end
+
+  describe '#reproduce_observed_behavior' do
+    let(:behavior_id) do
+      model_id = client.register_model_agent(agent_id: 'agent-1', domain: :coding)[:model][:id]
+      client.observe_agent_behavior(
+        model_id: model_id, action: 'write_test', domain: :coding, outcome: :positive
+      )[:behavior][:id]
+    end
+
+    it 'returns success with reproduced behavior' do
+      result = client.reproduce_observed_behavior(behavior_id: behavior_id)
+      expect(result[:success]).to be true
+      expect(result[:behavior][:reproduced]).to be true
+    end
+
+    it 'returns success: false for unknown behavior_id' do
+      result = client.reproduce_observed_behavior(behavior_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#reinforce_reproduction' do
+    let(:behavior_id) do
+      model_id = client.register_model_agent(agent_id: 'agent-1', domain: :coding)[:model][:id]
+      client.observe_agent_behavior(
+        model_id: model_id, action: 'write_test', domain: :coding, outcome: :positive
+      )[:behavior][:id]
+    end
+
+    it 'returns success with model_prestige on positive outcome' do
+      result = client.reinforce_reproduction(behavior_id: behavior_id, outcome: :positive)
+      expect(result[:success]).to be true
+      expect(result[:model_prestige]).to be_a(Float)
+    end
+
+    it 'returns success: false for unknown behavior_id' do
+      result = client.reinforce_reproduction(behavior_id: 'nonexistent', outcome: :positive)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#best_model_agents' do
+    before do
+      client.register_model_agent(agent_id: 'agent-1', domain: :coding, prestige: 0.9)
+      client.register_model_agent(agent_id: 'agent-2', domain: :ops,    prestige: 0.4)
+    end
+
+    it 'returns models sorted by prestige' do
+      result = client.best_model_agents(limit: 2)
+      expect(result[:success]).to be true
+      prestiges = result[:models].map { |mod| mod[:prestige] }
+      expect(prestiges).to eq(prestiges.sort.reverse)
+    end
+  end
+
+  describe '#domain_models' do
+    before do
+      client.register_model_agent(agent_id: 'agent-1', domain: :coding)
+      client.register_model_agent(agent_id: 'agent-2', domain: :ops)
+    end
+
+    it 'returns only models for the given domain' do
+      result = client.domain_models(domain: :coding)
+      expect(result[:success]).to be true
+      expect(result[:models].all? { |mod| mod[:domain] == :coding }).to be true
+    end
+  end
+
+  describe '#update_social_learning' do
+    it 'returns success with stats' do
+      result = client.update_social_learning
+      expect(result[:success]).to be true
+      expect(result).to include(:model_count, :behavior_count)
+    end
+  end
+
+  describe '#social_learning_stats' do
+    it 'returns success with stats hash' do
+      result = client.social_learning_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:model_count, :behavior_count, :retained_count, :reproducible_count)
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/symbiosis/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Symbiosis::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to create_bond' do
+    expect(client).to respond_to(:create_bond)
+  end
+
+  it 'responds to activate' do
+    expect(client).to respond_to(:activate)
+  end
+
+  it 'responds to health_status' do
+    expect(client).to respond_to(:health_status)
+  end
+
+  it 'responds to list_bonds' do
+    expect(client).to respond_to(:list_bonds)
+  end
+
+  it 'responds to detect_parasites' do
+    expect(client).to respond_to(:detect_parasites)
+  end
+
+  it 'responds to ecosystem_report' do
+    expect(client).to respond_to(:ecosystem_report)
+  end
+
+  it 'creates a fresh engine per instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.create_bond(subsystem_a: 'a', subsystem_b: 'b', relationship_type: :mutualistic)
+    expect(c2.list_bonds[:count]).to eq(0)
+  end
+
+  it 'maintains state across calls on same instance' do
+    client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+    expect(client.list_bonds[:count]).to eq(1)
+    client.create_bond(subsystem_a: 'trust', subsystem_b: 'consent', relationship_type: :mutualistic)
+    expect(client.list_bonds[:count]).to eq(2)
+  end
+end

data/spec/legion/extensions/agentic/social/symbiosis/helpers/constants_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Symbiosis::Helpers::Constants do
+  describe 'RELATIONSHIP_TYPES' do
+    it 'contains the three canonical types' do
+      expect(described_class::RELATIONSHIP_TYPES).to contain_exactly(:mutualistic, :parasitic, :commensal)
+    end
+
+    it 'is frozen' do
+      expect(described_class::RELATIONSHIP_TYPES).to be_frozen
+    end
+  end
+
+  describe 'INTERACTION_STRENGTHS' do
+    it 'maps range 0.0..0.2 to :dormant' do
+      label = described_class::INTERACTION_STRENGTHS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:dormant)
+    end
+
+    it 'maps range 0.6..0.8 to :strong' do
+      label = described_class::INTERACTION_STRENGTHS.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:strong)
+    end
+
+    it 'maps range 0.8..1.0 to :dominant' do
+      label = described_class::INTERACTION_STRENGTHS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:dominant)
+    end
+  end
+
+  describe 'MAX_BONDS' do
+    it 'is 200' do
+      expect(described_class::MAX_BONDS).to eq(200)
+    end
+  end
+
+  describe 'BOND_DECAY' do
+    it 'is a positive float' do
+      expect(described_class::BOND_DECAY).to be > 0
+      expect(described_class::BOND_DECAY).to be < 1
+    end
+  end
+
+  describe 'BENEFIT_RATIO_RANGES' do
+    it 'has positive range for mutualistic' do
+      range = described_class::BENEFIT_RATIO_RANGES[:mutualistic]
+      expect(range.min).to be > 0
+    end
+
+    it 'has negative range for parasitic' do
+      range = described_class::BENEFIT_RATIO_RANGES[:parasitic]
+      expect(range.max).to be < 0
+    end
+
+    it 'has near-zero range for commensal' do
+      range = described_class::BENEFIT_RATIO_RANGES[:commensal]
+      expect(range.min.abs).to be < 0.1
+      expect(range.max.abs).to be < 0.1
+    end
+  end
+
+  describe 'ECOSYSTEM_HEALTH_LABELS' do
+    it 'maps 0.0..0.2 to :critical' do
+      label = described_class::ECOSYSTEM_HEALTH_LABELS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:critical)
+    end
+
+    it 'maps 0.8..1.0 to :flourishing' do
+      label = described_class::ECOSYSTEM_HEALTH_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:flourishing)
+    end
+  end
+end