lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/symbiosis/runners/cognitive_symbiosis_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/symbiosis/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Symbiosis::Runners::CognitiveSymbiosis do
+  let(:client) { Legion::Extensions::Agentic::Social::Symbiosis::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Social::Symbiosis::Helpers::SymbiosisEngine.new }
+
+  describe '#create_bond' do
+    it 'creates a mutualistic bond' do
+      result = client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+      expect(result[:success]).to be true
+      expect(result[:bond][:relationship_type]).to eq(:mutualistic)
+    end
+
+    it 'creates a parasitic bond' do
+      result = client.create_bond(subsystem_a: 'cortex', subsystem_b: 'tick', relationship_type: :parasitic)
+      expect(result[:success]).to be true
+    end
+
+    it 'creates a commensal bond' do
+      result = client.create_bond(subsystem_a: 'trust', subsystem_b: 'identity', relationship_type: :commensal)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success: false for duplicate bond' do
+      client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+      result = client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns success: false for invalid relationship_type' do
+      result = client.create_bond(subsystem_a: 'a', subsystem_b: 'b', relationship_type: :invalid)
+      expect(result[:success]).to be false
+      expect(result[:error]).to be_a(String)
+    end
+
+    it 'uses injected engine' do
+      result = client.create_bond(subsystem_a: 'a', subsystem_b: 'b', relationship_type: :mutualistic, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'ignores extra keyword arguments via ** splat' do
+      result = client.create_bond(subsystem_a: 'x', subsystem_b: 'y', relationship_type: :commensal, extra: :ignored)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#activate' do
+    before { client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic) }
+
+    it 'activates an existing bond' do
+      result = client.activate(subsystem_a: 'memory', subsystem_b: 'emotion')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success: false for unknown pair' do
+      result = client.activate(subsystem_a: 'x', subsystem_b: 'y')
+      expect(result[:success]).to be false
+    end
+
+    it 'includes relationship_type in result' do
+      result = client.activate(subsystem_a: 'memory', subsystem_b: 'emotion')
+      expect(result[:relationship_type]).to eq(:mutualistic)
+    end
+
+    it 'clamps amount to 1.0' do
+      result = client.activate(subsystem_a: 'memory', subsystem_b: 'emotion', amount: 99.0)
+      expect(result[:success]).to be true
+    end
+
+    it 'uses injected engine' do
+      engine.create_bond(subsystem_a: 'p', subsystem_b: 'q', relationship_type: :commensal)
+      result = client.activate(subsystem_a: 'p', subsystem_b: 'q', engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#health_status' do
+    it 'returns success: true' do
+      result = client.health_status
+      expect(result[:success]).to be true
+    end
+
+    it 'includes score and label' do
+      result = client.health_status
+      expect(result).to include(:score, :label)
+    end
+
+    it 'label improves after adding mutualistic bonds' do
+      client.create_bond(subsystem_a: 'a', subsystem_b: 'b', relationship_type: :mutualistic)
+      result = client.health_status
+      expect(result[:score]).to be >= 0
+    end
+  end
+
+  describe '#list_bonds' do
+    before do
+      client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+      client.create_bond(subsystem_a: 'cortex', subsystem_b: 'tick', relationship_type: :parasitic)
+      client.create_bond(subsystem_a: 'memory', subsystem_b: 'trust', relationship_type: :commensal)
+    end
+
+    it 'returns all bonds when no filter' do
+      result = client.list_bonds
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'filters by subsystem_id' do
+      result = client.list_bonds(subsystem_id: 'memory')
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by relationship_type' do
+      result = client.list_bonds(relationship_type: :mutualistic)
+      types = result[:bonds].map { |b| b[:relationship_type] }
+      expect(types).to all(eq(:mutualistic))
+    end
+
+    it 'returns empty bonds for unknown subsystem' do
+      result = client.list_bonds(subsystem_id: 'nobody')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#detect_parasites' do
+    before do
+      client.create_bond(subsystem_a: 'cortex', subsystem_b: 'emotion', relationship_type: :parasitic)
+      client.create_bond(subsystem_a: 'memory', subsystem_b: 'trust', relationship_type: :mutualistic)
+    end
+
+    it 'returns success: true' do
+      result = client.detect_parasites
+      expect(result[:success]).to be true
+    end
+
+    it 'returns only parasitic bonds' do
+      result = client.detect_parasites
+      types = result[:parasites].map { |b| b[:relationship_type] }
+      expect(types).to all(eq(:parasitic))
+    end
+
+    it 'includes count' do
+      result = client.detect_parasites
+      expect(result[:count]).to be_a(Integer)
+    end
+
+    it 'filters by strength_threshold' do
+      result = client.detect_parasites(strength_threshold: 0.99)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#ecosystem_report' do
+    before do
+      client.create_bond(subsystem_a: 'memory', subsystem_b: 'emotion', relationship_type: :mutualistic)
+    end
+
+    it 'returns success: true' do
+      result = client.ecosystem_report
+      expect(result[:success]).to be true
+    end
+
+    it 'includes bonds_by_type for all three types' do
+      result = client.ecosystem_report
+      expect(result[:bonds_by_type].keys).to include(:mutualistic, :parasitic, :commensal)
+    end
+
+    it 'total_bonds is correct' do
+      result = client.ecosystem_report
+      expect(result[:total_bonds]).to eq(1)
+    end
+
+    it 'uses injected engine' do
+      engine.create_bond(subsystem_a: 'p', subsystem_b: 'q', relationship_type: :commensal)
+      result = client.ecosystem_report(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:total_bonds]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::TheoryOfMind::Client do
+  describe '#initialize' do
+    it 'creates a default mental state tracker' do
+      client = described_class.new
+      expect(client.tracker).to be_a(Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::MentalStateTracker)
+    end
+
+    it 'accepts an injected tracker' do
+      tracker = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::MentalStateTracker.new
+      client = described_class.new(tracker: tracker)
+      expect(client.tracker).to equal(tracker)
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect { described_class.new(unknown: true) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    subject(:client) { described_class.new }
+
+    it 'responds to observe_agent' do
+      expect(client).to respond_to(:observe_agent)
+    end
+
+    it 'responds to predict_behavior' do
+      expect(client).to respond_to(:predict_behavior)
+    end
+
+    it 'responds to check_false_beliefs' do
+      expect(client).to respond_to(:check_false_beliefs)
+    end
+
+    it 'responds to perspective_take' do
+      expect(client).to respond_to(:perspective_take)
+    end
+
+    it 'can perform a full ToM workflow' do
+      client.observe_agent(agent_id: :bob, observations: { domain: :location, belief: 'office', confidence: 0.9 })
+      client.observe_agent(agent_id: :bob, observations: { goal: 'finish_report', goal_priority: :high })
+      client.observe_agent(agent_id: :bob, observations: { action: :typing, action_confidence: :certain })
+
+      prediction = client.predict_behavior(agent_id: :bob)
+      expect(prediction[:predicted_action]).to eq(:typing)
+      expect(prediction[:underlying_desire]).to eq('finish_report')
+
+      false_beliefs = client.check_false_beliefs(agent_id: :bob, known_truths: { location: 'home' })
+      expect(false_beliefs[:count]).to eq(1)
+      expect(false_beliefs[:false_beliefs][:location][:agent_believes]).to eq('office')
+
+      perspective = client.perspective_take(agent_id: :bob)
+      expect(perspective[:perspective][:knowledge][:location]).to eq('office')
+
+      client.record_outcome(agent_id: :bob, outcome: :correct)
+      state = client.mental_state(agent_id: :bob)
+      expect(state[:accuracy]).to be > 0.5
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/theory_of_mind/helpers/agent_model_spec.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::AgentModel do
+  subject(:model) { described_class.new(:agent_alpha) }
+
+  describe '#initialize' do
+    it 'sets the agent_id' do
+      expect(model.agent_id).to eq(:agent_alpha)
+    end
+
+    it 'starts with empty beliefs' do
+      expect(model.beliefs).to be_empty
+    end
+
+    it 'starts with empty desires' do
+      expect(model.desires).to be_empty
+    end
+
+    it 'starts with empty intentions' do
+      expect(model.intentions).to be_empty
+    end
+
+    it 'starts with 0.5 prediction accuracy' do
+      expect(model.prediction_accuracy).to eq(0.5)
+    end
+  end
+
+  describe '#update_belief' do
+    it 'stores a belief for the domain' do
+      model.update_belief(domain: :location, content: 'office', confidence: 0.8)
+      expect(model.beliefs[:location][:content]).to eq('office')
+    end
+
+    it 'clamps confidence to 0..1' do
+      model.update_belief(domain: :mood, content: 'happy', confidence: 5.0)
+      expect(model.beliefs[:mood][:confidence]).to eq(1.0)
+    end
+
+    it 'records the source' do
+      model.update_belief(domain: :role, content: 'leader', confidence: 0.7, source: :direct_observation)
+      expect(model.beliefs[:role][:source]).to eq(:direct_observation)
+    end
+
+    it 'overwrites existing belief for same domain' do
+      model.update_belief(domain: :location, content: 'office', confidence: 0.8)
+      model.update_belief(domain: :location, content: 'home', confidence: 0.9)
+      expect(model.beliefs[:location][:content]).to eq('home')
+    end
+
+    it 'trims beliefs beyond MAX_BELIEFS_PER_AGENT' do
+      max = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::MAX_BELIEFS_PER_AGENT
+      (max + 5).times { |i| model.update_belief(domain: :"domain_#{i}", content: "val_#{i}", confidence: 0.5 + (i * 0.001)) }
+      expect(model.beliefs.size).to eq(max)
+    end
+  end
+
+  describe '#update_desire' do
+    it 'adds a new desire' do
+      model.update_desire(goal: 'complete_task')
+      expect(model.desires.size).to eq(1)
+    end
+
+    it 'defaults priority to medium' do
+      model.update_desire(goal: 'learn')
+      expect(model.desires.first[:priority]).to eq(:medium)
+    end
+
+    it 'updates existing desire priority' do
+      model.update_desire(goal: 'learn', priority: :low)
+      model.update_desire(goal: 'learn', priority: :critical)
+      expect(model.desires.size).to eq(1)
+      expect(model.desires.first[:priority]).to eq(:critical)
+    end
+
+    it 'trims desires beyond MAX_DESIRES_PER_AGENT' do
+      max = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::MAX_DESIRES_PER_AGENT
+      (max + 5).times { |i| model.update_desire(goal: "goal_#{i}") }
+      expect(model.desires.size).to eq(max)
+    end
+  end
+
+  describe '#update_intention' do
+    it 'adds a new intention' do
+      model.update_intention(action: :send_message, confidence: :likely)
+      expect(model.intentions.size).to eq(1)
+    end
+
+    it 'updates existing intention confidence' do
+      model.update_intention(action: :send_message, confidence: :possible)
+      model.update_intention(action: :send_message, confidence: :certain)
+      expect(model.intentions.size).to eq(1)
+      expect(model.intentions.first[:confidence]).to eq(:certain)
+    end
+
+    it 'trims intentions beyond MAX_INTENTIONS_PER_AGENT' do
+      max = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::MAX_INTENTIONS_PER_AGENT
+      (max + 3).times { |i| model.update_intention(action: :"action_#{i}") }
+      expect(model.intentions.size).to eq(max)
+    end
+  end
+
+  describe '#belief_for' do
+    it 'returns the belief for a domain' do
+      model.update_belief(domain: :location, content: 'lab', confidence: 0.9)
+      expect(model.belief_for(:location)[:content]).to eq('lab')
+    end
+
+    it 'returns nil for unknown domain' do
+      expect(model.belief_for(:unknown)).to be_nil
+    end
+  end
+
+  describe '#strongest_desire' do
+    it 'returns the highest-priority desire' do
+      model.update_desire(goal: 'rest', priority: :low)
+      model.update_desire(goal: 'work', priority: :critical)
+      model.update_desire(goal: 'eat', priority: :medium)
+      expect(model.strongest_desire[:goal]).to eq('work')
+    end
+
+    it 'returns nil when no desires' do
+      expect(model.strongest_desire).to be_nil
+    end
+  end
+
+  describe '#most_likely_intention' do
+    it 'returns the highest-confidence intention' do
+      model.update_intention(action: :wait, confidence: :unlikely)
+      model.update_intention(action: :attack, confidence: :certain)
+      model.update_intention(action: :flee, confidence: :possible)
+      expect(model.most_likely_intention[:action]).to eq(:attack)
+    end
+
+    it 'returns nil when no intentions' do
+      expect(model.most_likely_intention).to be_nil
+    end
+  end
+
+  describe '#false_beliefs' do
+    before do
+      model.update_belief(domain: :weather, content: 'sunny', confidence: 0.8)
+      model.update_belief(domain: :time, content: 'morning', confidence: 0.7)
+    end
+
+    it 'identifies beliefs that contradict known truths' do
+      truths = { weather: 'rainy', time: 'morning' }
+      result = model.false_beliefs(truths)
+      expect(result).to have_key(:weather)
+      expect(result[:weather][:agent_believes]).to eq('sunny')
+      expect(result[:weather][:actual_truth]).to eq('rainy')
+    end
+
+    it 'does not flag correct beliefs' do
+      truths = { weather: 'sunny' }
+      result = model.false_beliefs(truths)
+      expect(result).to be_empty
+    end
+
+    it 'ignores domains not in known truths' do
+      truths = { unrelated: 'value' }
+      result = model.false_beliefs(truths)
+      expect(result).to be_empty
+    end
+  end
+
+  describe '#update_prediction_accuracy' do
+    it 'increases accuracy on correct predictions' do
+      initial = model.prediction_accuracy
+      model.update_prediction_accuracy(:correct)
+      expect(model.prediction_accuracy).to be > initial
+    end
+
+    it 'decreases accuracy on incorrect predictions' do
+      initial = model.prediction_accuracy
+      model.update_prediction_accuracy(:incorrect)
+      expect(model.prediction_accuracy).to be < initial
+    end
+
+    it 'increments interaction count' do
+      model.update_prediction_accuracy(:correct)
+      expect(model.interaction_count).to eq(1)
+    end
+
+    it 'ignores unknown outcomes' do
+      model.update_prediction_accuracy(:nonsense)
+      expect(model.interaction_count).to eq(0)
+    end
+  end
+
+  describe '#decay_beliefs' do
+    it 'reduces belief confidence' do
+      model.update_belief(domain: :test, content: 'val', confidence: 0.5)
+      initial = model.beliefs[:test][:confidence]
+      model.decay_beliefs
+      expect(model.beliefs[:test][:confidence]).to be < initial
+    end
+
+    it 'removes beliefs below CONFIDENCE_THRESHOLD' do
+      threshold = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::CONFIDENCE_THRESHOLD
+      model.update_belief(domain: :weak, content: 'val', confidence: threshold + 0.005)
+      model.decay_beliefs
+      expect(model.beliefs).not_to have_key(:weak)
+    end
+  end
+
+  describe '#perspective' do
+    before do
+      model.update_belief(domain: :location, content: 'office', confidence: 0.9)
+      model.update_desire(goal: 'finish_report', priority: :high)
+      model.update_intention(action: :write, confidence: :likely)
+    end
+
+    it 'returns knowledge from beliefs' do
+      expect(model.perspective[:knowledge][:location]).to eq('office')
+    end
+
+    it 'returns goals from desires' do
+      expect(model.perspective[:goals]).to include('finish_report')
+    end
+
+    it 'returns recent actions from intentions' do
+      expect(model.perspective[:recent_actions]).to include(:write)
+    end
+
+    it 'includes emotional state' do
+      expect(model.perspective[:emotional_state]).to be_a(Symbol)
+    end
+
+    it 'includes constraints' do
+      expect(model.perspective[:constraints]).to have_key(:uncertain_domains)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a summary hash' do
+      result = model.to_h
+      expect(result[:agent_id]).to eq(:agent_alpha)
+      expect(result).to have_key(:belief_count)
+      expect(result).to have_key(:prediction_accuracy)
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants do
+  describe 'PERSPECTIVE_DIMENSIONS' do
+    it 'contains 5 dimensions' do
+      expect(described_class::PERSPECTIVE_DIMENSIONS.size).to eq(5)
+    end
+
+    it 'is frozen' do
+      expect(described_class::PERSPECTIVE_DIMENSIONS).to be_frozen
+    end
+  end
+
+  describe 'BELIEF_SOURCES' do
+    it 'contains 5 sources' do
+      expect(described_class::BELIEF_SOURCES.size).to eq(5)
+    end
+
+    it 'is frozen' do
+      expect(described_class::BELIEF_SOURCES).to be_frozen
+    end
+  end
+
+  describe 'INTENTION_CONFIDENCE_LEVELS' do
+    it 'is ordered from highest to lowest' do
+      thresholds = described_class::INTENTION_CONFIDENCE_LEVELS.values
+      expect(thresholds).to eq(thresholds.sort.reverse)
+    end
+  end
+
+  describe 'DESIRE_PRIORITIES' do
+    it 'is ordered from highest to lowest' do
+      thresholds = described_class::DESIRE_PRIORITIES.values
+      expect(thresholds).to eq(thresholds.sort.reverse)
+    end
+  end
+
+  describe 'PREDICTION_OUTCOMES' do
+    it 'contains 4 outcomes' do
+      expect(described_class::PREDICTION_OUTCOMES.size).to eq(4)
+    end
+
+    it 'is frozen' do
+      expect(described_class::PREDICTION_OUTCOMES).to be_frozen
+    end
+  end
+
+  describe 'scalar constants' do
+    it 'has positive MAX_AGENT_MODELS' do
+      expect(described_class::MAX_AGENT_MODELS).to be > 0
+    end
+
+    it 'has positive MAX_BELIEFS_PER_AGENT' do
+      expect(described_class::MAX_BELIEFS_PER_AGENT).to be > 0
+    end
+
+    it 'has BELIEF_DECAY_RATE between 0 and 1' do
+      expect(described_class::BELIEF_DECAY_RATE).to be_between(0.0, 1.0)
+    end
+
+    it 'has CONFIDENCE_THRESHOLD between 0 and 1' do
+      expect(described_class::CONFIDENCE_THRESHOLD).to be_between(0.0, 1.0)
+    end
+
+    it 'has PREDICTION_ALPHA between 0 and 1' do
+      expect(described_class::PREDICTION_ALPHA).to be_between(0.0, 1.0)
+    end
+  end
+end