lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/personality/helpers/personality_store_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Personality::Helpers::PersonalityStore do
+  subject(:store) { described_class.new }
+
+  describe '#update' do
+    it 'delegates to the trait model' do
+      store.update(curiosity: { intensity: 0.8 })
+      expect(store.model.observation_count).to be >= 0
+    end
+
+    it 'extracts signals from tick results' do
+      store.update(
+        working_memory_integration: { intensity: 0.8, wonder_count: 5 },
+        prediction_engine:          { accuracy: 0.9 },
+        mesh_interface:             { message_count: 10 },
+        emotional_evaluation:       { volatility: 0.3 },
+        mood:                       { stability: 0.8 }
+      )
+      expect(store.model.observation_count).to eq(1)
+    end
+  end
+
+  describe '#full_description' do
+    it 'returns not-formed message before threshold' do
+      desc = store.full_description
+      expect(desc).to include('not yet formed')
+    end
+
+    it 'returns trait descriptions after formation' do
+      Legion::Extensions::Agentic::Self::Personality::Helpers::Constants::FORMATION_THRESHOLD.times do
+        store.update(
+          working_memory_integration: { intensity: 0.9, wonder_count: 8 },
+          prediction_engine:          { accuracy: 0.95 }
+        )
+      end
+      desc = store.full_description
+      expect(desc).not_to include('not yet formed')
+      expect(desc).to be_a(String)
+    end
+  end
+
+  describe '#compatibility_score' do
+    it 'returns nil for non-hash input' do
+      expect(store.compatibility_score('invalid')).to be_nil
+    end
+
+    it 'returns 1.0 for identical profiles' do
+      profile = store.model.profile
+      score = store.compatibility_score(profile)
+      expect(score).to eq(1.0)
+    end
+
+    it 'returns lower score for divergent profiles' do
+      opposite = {
+        openness:          0.0,
+        conscientiousness: 0.0,
+        extraversion:      0.0,
+        agreeableness:     0.0,
+        neuroticism:       0.0
+      }
+      score = store.compatibility_score(opposite)
+      expect(score).to be < 1.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/personality/helpers/trait_model_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Personality::Helpers::TraitModel do
+  subject(:model) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts all traits at 0.5' do
+      Legion::Extensions::Agentic::Self::Personality::Helpers::Constants::TRAITS.each do |trait|
+        expect(model.trait(trait)).to eq(0.5)
+      end
+    end
+
+    it 'starts with zero observation count' do
+      expect(model.observation_count).to eq(0)
+    end
+
+    it 'starts with empty history' do
+      expect(model.history).to be_empty
+    end
+  end
+
+  describe '#update' do
+    it 'increments observation count' do
+      model.update(curiosity_intensity: 0.8)
+      expect(model.observation_count).to eq(1)
+    end
+
+    it 'shifts openness with curiosity signals' do
+      10.times { model.update(curiosity_intensity: 0.9, novel_domains: 0.8) }
+      expect(model.trait(:openness)).to be > 0.5
+    end
+
+    it 'shifts conscientiousness with accuracy signals' do
+      10.times { model.update(prediction_accuracy: 0.95, habit_automatic_ratio: 0.7) }
+      expect(model.trait(:conscientiousness)).to be > 0.5
+    end
+
+    it 'shifts neuroticism with volatility signals' do
+      10.times { model.update(emotional_volatility: 0.9, anxiety_frequency: 0.8) }
+      expect(model.trait(:neuroticism)).to be > 0.5
+    end
+
+    it 'ignores nil values' do
+      model.update(curiosity_intensity: nil)
+      expect(model.observation_count).to eq(0)
+    end
+
+    it 'records snapshots in history' do
+      model.update(curiosity_intensity: 0.8)
+      expect(model.history.size).to eq(1)
+    end
+  end
+
+  describe '#formed?' do
+    it 'returns false before formation threshold' do
+      expect(model.formed?).to be false
+    end
+
+    it 'returns true after enough observations' do
+      Legion::Extensions::Agentic::Self::Personality::Helpers::Constants::FORMATION_THRESHOLD.times do
+        model.update(curiosity_intensity: 0.7)
+      end
+      expect(model.formed?).to be true
+    end
+  end
+
+  describe '#dominant_trait' do
+    it 'returns the trait furthest from neutral' do
+      20.times { model.update(curiosity_intensity: 0.95, novel_domains: 0.9) }
+      expect(model.dominant_trait).to eq(:openness)
+    end
+  end
+
+  describe '#trait_level' do
+    it 'returns :mid for default trait values' do
+      expect(model.trait_level(:openness)).to eq(:mid)
+    end
+
+    it 'returns :high for elevated traits' do
+      50.times { model.update(curiosity_intensity: 0.99, novel_domains: 0.99) }
+      expect(model.trait_level(:openness)).to eq(:high)
+    end
+
+    it 'returns nil for unknown trait' do
+      expect(model.trait_level(:nonexistent)).to be_nil
+    end
+  end
+
+  describe '#describe' do
+    it 'returns descriptor string for known trait' do
+      desc = model.describe(:openness)
+      expect(desc).to be_a(String)
+    end
+
+    it 'returns nil for unknown trait' do
+      expect(model.describe(:nonexistent)).to be_nil
+    end
+  end
+
+  describe '#profile' do
+    it 'returns all 5 traits' do
+      p = model.profile
+      expect(p.keys.size).to eq(5)
+      Legion::Extensions::Agentic::Self::Personality::Helpers::Constants::TRAITS.each do |t|
+        expect(p).to have_key(t)
+      end
+    end
+
+    it 'rounds values to 3 decimal places' do
+      model.update(curiosity_intensity: 0.8)
+      p = model.profile
+      p.each_value do |v|
+        expect(v.to_s.split('.').last&.length || 0).to be <= 3
+      end
+    end
+  end
+
+  describe '#stability' do
+    it 'returns 0.0 with insufficient history' do
+      expect(model.stability).to eq(0.0)
+    end
+
+    it 'returns high stability with consistent inputs' do
+      10.times { model.update(curiosity_intensity: 0.7) }
+      expect(model.stability).to be > 0.5
+    end
+  end
+
+  describe '#trend' do
+    it 'returns :insufficient_data with few entries' do
+      expect(model.trend(:openness)).to eq(:insufficient_data)
+    end
+
+    it 'detects increasing trend' do
+      20.times { model.update(curiosity_intensity: 0.1, novel_domains: 0.1) }
+      20.times { model.update(curiosity_intensity: 0.99, novel_domains: 0.99) }
+      expect(model.trend(:openness)).to eq(:increasing)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete state hash' do
+      h = model.to_h
+      expect(h).to include(:traits, :observation_count, :formed, :stability,
+                           :dominant_trait, :history_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/personality/runners/personality_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Personality::Runners::Personality do
+  let(:client) { Legion::Extensions::Agentic::Self::Personality::Client.new }
+
+  describe '#update_personality' do
+    it 'returns update result' do
+      result = client.update_personality(tick_results: {
+                                           working_memory_integration: { intensity: 0.7 }
+                                         })
+      expect(result[:updated]).to be true
+      expect(result).to include(:observation_count, :formed, :profile, :dominant_trait)
+    end
+
+    it 'handles empty tick results' do
+      result = client.update_personality(tick_results: {})
+      expect(result[:updated]).to be true
+    end
+  end
+
+  describe '#personality_profile' do
+    it 'returns profile with all traits' do
+      result = client.personality_profile
+      expect(result[:traits].keys.size).to eq(5)
+      expect(result).to include(:formed, :stability, :dominant, :observations)
+    end
+  end
+
+  describe '#describe_personality' do
+    it 'returns description' do
+      result = client.describe_personality
+      expect(result[:description]).to be_a(String)
+      expect(result).to have_key(:formed)
+    end
+  end
+
+  describe '#trait_detail' do
+    it 'returns detail for known trait' do
+      result = client.trait_detail(trait: :openness)
+      expect(result[:trait]).to eq(:openness)
+      expect(result).to include(:value, :level, :description, :trend)
+    end
+
+    it 'returns error for unknown trait' do
+      result = client.trait_detail(trait: :nonexistent)
+      expect(result[:error]).to eq(:unknown_trait)
+    end
+  end
+
+  describe '#personality_compatibility' do
+    it 'scores compatibility with another profile' do
+      other = { openness: 0.5, conscientiousness: 0.5, extraversion: 0.5,
+                agreeableness: 0.5, neuroticism: 0.5 }
+      result = client.personality_compatibility(other_profile: other)
+      expect(result[:compatibility]).to be_a(Numeric)
+      expect(result[:interpretation]).to be_a(Symbol)
+    end
+  end
+
+  describe '#personality_stats' do
+    it 'returns stats summary' do
+      result = client.personality_stats
+      expect(result).to include(:observation_count, :formed, :stability,
+                                :dominant_trait, :profile, :trait_trends)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/reflection/client_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Client do
+  subject(:client) { described_class.new }
+
+  it 'initializes with a default reflection store' do
+    expect(client.reflection_store).to be_a(Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionStore)
+  end
+
+  it 'accepts an injected store' do
+    custom = Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionStore.new
+    client = described_class.new(store: custom)
+    expect(client.reflection_store).to be(custom)
+  end
+
+  it 'includes the Reflection runner' do
+    expect(client).to respond_to(:reflect)
+    expect(client).to respond_to(:cognitive_health)
+    expect(client).to respond_to(:recent_reflections)
+    expect(client).to respond_to(:reflections_by_category)
+    expect(client).to respond_to(:adapt)
+    expect(client).to respond_to(:reflection_stats)
+  end
+end

data/spec/legion/extensions/agentic/self/reflection/helpers/llm_enhancer_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Helpers::LlmEnhancer do
+  describe '.available?' do
+    context 'when Legion::LLM is not defined' do
+      it 'returns a falsy value' do
+        # Legion::LLM is not defined in the test environment
+        expect(described_class.available?).to be_falsy
+      end
+    end
+
+    context 'when Legion::LLM is defined but not started' do
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: false))
+      end
+
+      it 'returns false' do
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is started' do
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+      end
+
+      it 'returns true' do
+        expect(described_class.available?).to be true
+      end
+    end
+
+    context 'when an error is raised' do
+      before do
+        stub_const('Legion::LLM', double)
+        allow(Legion::LLM).to receive(:respond_to?).and_raise(StandardError)
+      end
+
+      it 'returns false' do
+        expect(described_class.available?).to be false
+      end
+    end
+  end
+
+  describe '.enhance_reflection' do
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        EMOTION: My arousal is elevated at 0.7 while stability holds at 0.8, suggesting urgency without destabilization.
+        PREDICTION: Confidence at 65% with a declining trend and 3 pending predictions signals I am losing ground in forward modeling.
+        MEMORY: Memory health appears nominal with no concerning decay patterns detected this cycle.
+        TRUST: Trust scores remain stable with no significant drift observed.
+        CURIOSITY: Curiosity intensity is moderate; resolution rates suggest effective exploration.
+        IDENTITY: Identity entropy is within expected bounds; no drift detected.
+      TEXT
+    end
+    let(:fake_chat) { double }
+    let(:monitors_data) do
+      [
+        {
+          category:       :emotional_stability,
+          observation:    'original',
+          severity:       :notable,
+          metrics:        { stability: 0.8 },
+          recommendation: :no_action
+        },
+        {
+          category:       :prediction_calibration,
+          observation:    'original',
+          severity:       :notable,
+          metrics:        { confidence: 0.65 },
+          recommendation: :increase_curiosity
+        }
+      ]
+    end
+    let(:health_scores) do
+      {
+        prediction_calibration:  0.65,
+        curiosity_effectiveness: 0.8,
+        emotional_stability:     0.8,
+        trust_drift:             1.0,
+        memory_health:           0.95,
+        cognitive_load:          0.9,
+        mode_patterns:           1.0
+      }
+    end
+
+    before do
+      stub_const('Legion::LLM', double)
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+    end
+
+    it 'returns observations hash with at least some categories' do
+      result = described_class.enhance_reflection(
+        monitors_data: monitors_data,
+        health_scores: health_scores
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:observations]).to be_a(Hash)
+      expect(result[:observations]).not_to be_empty
+    end
+
+    it 'parses per-category observation text' do
+      result = described_class.enhance_reflection(
+        monitors_data: monitors_data,
+        health_scores: health_scores
+      )
+      expect(result[:observations][:emotional_stability]).to include('arousal')
+      expect(result[:observations][:prediction_calibration]).to include('Confidence')
+    end
+
+    context 'when LLM returns nil content' do
+      before { allow(fake_chat).to receive(:ask).and_return(double(content: nil)) }
+
+      it 'returns nil' do
+        result = described_class.enhance_reflection(
+          monitors_data: monitors_data,
+          health_scores: health_scores
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when LLM raises an error' do
+      before { allow(fake_chat).to receive(:ask).and_raise(StandardError, 'LLM timeout') }
+
+      it 'returns nil and logs a warning' do
+        expect(Legion::Logging).to receive(:warn).with(/enhance_reflection failed/)
+        result = described_class.enhance_reflection(
+          monitors_data: monitors_data,
+          health_scores: health_scores
+        )
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe '.reflect_on_dream' do
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        REFLECTION: The dream cycle surfaced 3 unresolved traces and resolved 1 contradiction. Memory consolidation is progressing normally with agenda items focused on identity coherence.
+      TEXT
+    end
+    let(:fake_chat) { double }
+    let(:dream_results) do
+      {
+        memory_audit:             { decayed: 5, pruned: 2, unresolved_count: 3 },
+        contradiction_resolution: { detected: 2, resolved: 1 },
+        agenda_formation:         { agenda_items: 4 }
+      }
+    end
+
+    before do
+      stub_const('Legion::LLM', double)
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+    end
+
+    it 'returns a reflection string' do
+      result = described_class.reflect_on_dream(dream_results: dream_results)
+      expect(result).to be_a(Hash)
+      expect(result[:reflection]).to be_a(String)
+      expect(result[:reflection]).not_to be_empty
+    end
+
+    it 'includes dream cycle content in the reflection' do
+      result = described_class.reflect_on_dream(dream_results: dream_results)
+      expect(result[:reflection]).to include('unresolved traces')
+    end
+
+    context 'when LLM returns nil content' do
+      before { allow(fake_chat).to receive(:ask).and_return(double(content: nil)) }
+
+      it 'returns nil' do
+        result = described_class.reflect_on_dream(dream_results: dream_results)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when LLM raises an error' do
+      before { allow(fake_chat).to receive(:ask).and_raise(StandardError, 'model error') }
+
+      it 'returns nil and logs a warning' do
+        expect(Legion::Logging).to receive(:warn).with(/reflect_on_dream failed/)
+        result = described_class.reflect_on_dream(dream_results: dream_results)
+        expect(result).to be_nil
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/reflection/helpers/monitors_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Helpers::Monitors do
+  describe '.monitor_predictions' do
+    it 'generates reflection for low confidence' do
+      results = described_class.monitor_predictions(
+        { prediction_engine: { confidence: 0.2 } },
+        []
+      )
+      expect(results.size).to be >= 1
+      expect(results.first[:category]).to eq(:prediction_calibration)
+      expect(results.first[:recommendation]).to eq(:increase_curiosity)
+    end
+
+    it 'returns empty for good confidence' do
+      results = described_class.monitor_predictions(
+        { prediction_engine: { confidence: 0.9 } },
+        []
+      )
+      expect(results).to be_empty
+    end
+
+    it 'detects accuracy trend drop' do
+      history = Array.new(5) { { prediction_engine: { confidence: 0.9 } } } +
+                Array.new(5) { { prediction_engine: { confidence: 0.5 } } }
+
+      results = described_class.monitor_predictions(
+        { prediction_engine: { confidence: 0.5 } },
+        history
+      )
+      trend = results.find { |r| r[:metrics][:trend_drop] }
+      expect(trend).not_to be_nil
+    end
+  end
+
+  describe '.monitor_curiosity' do
+    it 'generates reflection for low resolution rate' do
+      results = described_class.monitor_curiosity(
+        working_memory_integration: { resolution_rate: 0.1 }
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:recommendation]).to eq(:decrease_curiosity)
+    end
+
+    it 'celebrates high resolution rate' do
+      results = described_class.monitor_curiosity(
+        working_memory_integration: { resolution_rate: 0.9 }
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:recommendation]).to eq(:celebrate_success)
+    end
+  end
+
+  describe '.monitor_emotions' do
+    it 'generates reflection for instability' do
+      results = described_class.monitor_emotions(
+        emotional_evaluation: { stability: 0.1 }
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:category]).to eq(:emotional_stability)
+      expect(results.first[:severity]).to eq(:significant)
+    end
+
+    it 'detects emotional flatness' do
+      results = described_class.monitor_emotions(
+        emotional_evaluation: { stability: 0.99 }
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:observation]).to include('flat')
+    end
+  end
+
+  describe '.monitor_memory' do
+    it 'generates reflection for high decay ratio' do
+      results = described_class.monitor_memory(
+        memory_consolidation: { pruned: 90, total: 100 }
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:recommendation]).to eq(:consolidate_memory)
+    end
+
+    it 'returns empty for healthy memory' do
+      results = described_class.monitor_memory(
+        memory_consolidation: { pruned: 5, total: 100 }
+      )
+      expect(results).to be_empty
+    end
+  end
+
+  describe '.monitor_cognitive_load' do
+    it 'generates reflection when near budget' do
+      results = described_class.monitor_cognitive_load(
+        elapsed: 4.8, budget: 5.0
+      )
+      expect(results.size).to eq(1)
+      expect(results.first[:category]).to eq(:cognitive_load)
+    end
+
+    it 'returns empty when within budget' do
+      results = described_class.monitor_cognitive_load(
+        elapsed: 1.0, budget: 5.0
+      )
+      expect(results).to be_empty
+    end
+  end
+
+  describe '.run_all' do
+    it 'aggregates results from all monitors' do
+      tick_results = {
+        prediction_engine:    { confidence: 0.2 },
+        emotional_evaluation: { stability: 0.1 },
+        memory_consolidation: { pruned: 90, total: 100 },
+        elapsed:              4.8,
+        budget:               5.0
+      }
+      results = described_class.run_all(tick_results, [])
+      expect(results.size).to be >= 3
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/reflection/helpers/reflection_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory do
+  describe '.new_reflection' do
+    it 'creates a reflection with required fields' do
+      r = described_class.new_reflection(
+        category:    :prediction_calibration,
+        observation: 'Low accuracy detected'
+      )
+      expect(r[:reflection_id]).to be_a(String)
+      expect(r[:category]).to eq(:prediction_calibration)
+      expect(r[:observation]).to eq('Low accuracy detected')
+      expect(r[:severity]).to eq(:notable)
+      expect(r[:recommendation]).to eq(:no_action)
+      expect(r[:acted_on]).to be false
+    end
+
+    it 'raises on invalid category' do
+      expect { described_class.new_reflection(category: :invalid, observation: 'x') }
+        .to raise_error(ArgumentError, /invalid category/)
+    end
+
+    it 'raises on invalid severity' do
+      expect { described_class.new_reflection(category: :trust_drift, observation: 'x', severity: :invalid) }
+        .to raise_error(ArgumentError, /invalid severity/)
+    end
+  end
+
+  describe '.severity_weight' do
+    it 'returns 1.0 for critical' do
+      expect(described_class.severity_weight(:critical)).to eq(1.0)
+    end
+
+    it 'returns lower weights for lower severities' do
+      expect(described_class.severity_weight(:trivial)).to be < described_class.severity_weight(:notable)
+      expect(described_class.severity_weight(:notable)).to be < described_class.severity_weight(:significant)
+    end
+  end
+
+  describe '.severity_for_drop' do
+    it 'returns critical for large drops' do
+      expect(described_class.severity_for_drop(0.5)).to eq(:critical)
+    end
+
+    it 'returns trivial for small drops' do
+      expect(described_class.severity_for_drop(0.05)).to eq(:trivial)
+    end
+  end
+end