lex-agentic-self 0.1.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionStore do
+  subject(:store) { described_class.new }
+
+  let(:reflection) do
+    Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory.new_reflection(
+      category:       :prediction_calibration,
+      observation:    'Low accuracy',
+      severity:       :significant,
+      recommendation: :increase_curiosity
+    )
+  end
+
+  describe '#store and #get' do
+    it 'stores and retrieves a reflection' do
+      store.store(reflection)
+      expect(store.get(reflection[:reflection_id])).to eq(reflection)
+    end
+
+    it 'increments total_generated' do
+      store.store(reflection)
+      expect(store.total_generated).to eq(1)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns reflections in reverse chronological order' do
+      r1 = Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :trust_drift, observation: 'first'
+      )
+      store.store(r1)
+      r2 = Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :memory_health, observation: 'second'
+      )
+      store.store(r2)
+
+      recent = store.recent(limit: 2)
+      expect(recent.first[:observation]).to eq('second')
+    end
+  end
+
+  describe '#by_category' do
+    it 'filters by category' do
+      store.store(reflection)
+      other = Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :trust_drift, observation: 'other'
+      )
+      store.store(other)
+
+      results = store.by_category(:prediction_calibration)
+      expect(results.size).to eq(1)
+      expect(results.first[:category]).to eq(:prediction_calibration)
+    end
+  end
+
+  describe '#mark_acted_on' do
+    it 'marks a reflection as acted on' do
+      store.store(reflection)
+      store.mark_acted_on(reflection[:reflection_id])
+      expect(store.get(reflection[:reflection_id])[:acted_on]).to be true
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.mark_acted_on('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#cognitive_health' do
+    it 'returns 1.0 when all scores are at default' do
+      expect(store.cognitive_health).to eq(1.0)
+    end
+
+    it 'decreases when category scores drop' do
+      store.update_category_score(:prediction_calibration, 0.3)
+      expect(store.cognitive_health).to be < 1.0
+    end
+  end
+
+  describe '#severity_counts' do
+    it 'counts reflections by severity' do
+      store.store(reflection)
+      critical = Legion::Extensions::Agentic::Self::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :cognitive_load, observation: 'overload', severity: :critical
+      )
+      store.store(critical)
+
+      counts = store.severity_counts
+      expect(counts[:significant]).to eq(1)
+      expect(counts[:critical]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Runners::Reflection do
+  let(:client) { Legion::Extensions::Agentic::Self::Reflection::Client.new }
+
+  describe '#reflect' do
+    it 'returns results with no tick data' do
+      result = client.reflect(tick_results: {})
+      expect(result[:reflections_generated]).to eq(0)
+      expect(result[:cognitive_health]).to eq(1.0)
+    end
+
+    it 'generates reflections from problematic tick results' do
+      result = client.reflect(tick_results: {
+                                prediction_engine:    { confidence: 0.2 },
+                                emotional_evaluation: { stability: 0.1 },
+                                memory_consolidation: { pruned: 90, total: 100 }
+                              })
+      expect(result[:reflections_generated]).to be >= 2
+      expect(result[:cognitive_health]).to be < 1.0
+    end
+
+    it 'accumulates metric history over multiple calls' do
+      5.times { client.reflect(tick_results: { prediction_engine: { confidence: 0.9 } }) }
+      5.times { client.reflect(tick_results: { prediction_engine: { confidence: 0.4 } }) }
+
+      # Should detect trend
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.3 } })
+      predictions = result[:new_reflections].select { |r| r[:category] == :prediction_calibration }
+      expect(predictions).not_to be_empty
+    end
+  end
+
+  describe '#cognitive_health' do
+    it 'returns full health with no data' do
+      result = client.cognitive_health
+      expect(result[:health]).to eq(1.0)
+    end
+
+    it 'degrades with bad tick results' do
+      client.reflect(tick_results: {
+                       prediction_engine:    { confidence: 0.2 },
+                       emotional_evaluation: { stability: 0.1 }
+                     })
+      result = client.cognitive_health
+      expect(result[:health]).to be < 1.0
+      expect(result[:category_scores][:prediction_calibration]).to eq(0.2)
+    end
+  end
+
+  describe '#recent_reflections' do
+    it 'returns recent reflections' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      result = client.recent_reflections(limit: 5)
+      expect(result[:reflections]).not_to be_empty
+    end
+  end
+
+  describe '#reflections_by_category' do
+    it 'filters by category' do
+      client.reflect(tick_results: {
+                       prediction_engine:    { confidence: 0.1 },
+                       emotional_evaluation: { stability: 0.1 }
+                     })
+      result = client.reflections_by_category(category: :emotional_stability)
+      result[:reflections].each do |r|
+        expect(r[:category]).to eq(:emotional_stability)
+      end
+    end
+  end
+
+  describe '#adapt' do
+    it 'marks a reflection as acted upon' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      reflections = client.recent_reflections[:reflections]
+      id = reflections.first[:reflection_id]
+
+      result = client.adapt(reflection_id: id)
+      expect(result[:adapted]).to be true
+    end
+
+    it 'returns error for unknown id' do
+      result = client.adapt(reflection_id: 'nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#reflection_stats' do
+    it 'returns comprehensive stats' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      stats = client.reflection_stats
+      expect(stats[:total_generated]).to be >= 1
+      expect(stats[:cognitive_health]).to be_a(Float)
+      expect(stats[:severity_counts]).to be_a(Hash)
+    end
+  end
+
+  describe '#reflect with LLM enhancement' do
+    let(:fake_chat) { double }
+    let(:llm_observation) { 'My prediction confidence is critically low at 10%, strongly correlated with declining memory health.' }
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        EMOTION: Emotional state appears stable this tick.
+        PREDICTION: #{llm_observation}
+        MEMORY: Memory health is nominal.
+        TRUST: Trust scores unchanged.
+        CURIOSITY: Curiosity levels normal.
+        IDENTITY: Identity entropy within bounds.
+      TEXT
+    end
+
+    before do
+      stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+      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 'replaces mechanical observation text with LLM-generated text' do
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      prediction_reflection = result[:new_reflections].find { |r| r[:category] == :prediction_calibration }
+      expect(prediction_reflection).not_to be_nil
+      expect(prediction_reflection[:observation]).to include('critically low')
+    end
+
+    it 'does not change recommendation symbols when using LLM' do
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      prediction_reflection = result[:new_reflections].find { |r| r[:category] == :prediction_calibration }
+      expect(prediction_reflection).not_to be_nil
+      expect(prediction_reflection[:recommendation]).to eq(:increase_curiosity)
+    end
+
+    it 'falls back to mechanical observations when LLM returns nil' do
+      allow(fake_chat).to receive(:ask).and_return(double(content: nil))
+
+      result = client.reflect(tick_results: {
+                                prediction_engine:    { confidence: 0.2 },
+                                emotional_evaluation: { stability: 0.1 }
+                              })
+      expect(result[:reflections_generated]).to be >= 1
+      # Mechanical observations still present (LLM returned nil)
+      result[:new_reflections].each do |r|
+        expect(r[:observation]).to be_a(String)
+        expect(r[:observation]).not_to be_empty
+      end
+    end
+  end
+
+  describe '#reflect_on_dream' do
+    context 'without LLM' do
+      it 'uses mechanical fallback for empty dream results' do
+        result = client.reflect_on_dream(dream_results: {})
+        expect(result[:reflection]).to eq('Dream cycle completed.')
+        expect(result[:source]).to eq(:mechanical)
+      end
+
+      it 'builds mechanical reflection from dream phase data' do
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit:             { decayed: 3, unresolved_count: 2 },
+                                           contradiction_resolution: { detected: 1, resolved: 1 },
+                                           agenda_formation:         { agenda_items: 3 }
+                                         })
+        expect(result[:reflection]).to include('Memory audit')
+        expect(result[:source]).to eq(:mechanical)
+      end
+    end
+
+    context 'with LLM available' do
+      let(:fake_chat) { double }
+      let(:fake_response) do
+        double(content: <<~TEXT)
+          REFLECTION: The dream cycle consolidated 3 traces and resolved a contradiction in the identity domain. I notice a strengthening of procedural memory pathways.
+        TEXT
+      end
+
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+        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 'uses LLM-generated reflection when available' do
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit:             { decayed: 3, unresolved_count: 2 },
+                                           contradiction_resolution: { detected: 1, resolved: 1 }
+                                         })
+        expect(result[:reflection]).to include('consolidated 3 traces')
+        expect(result[:source]).to eq(:llm)
+      end
+
+      it 'falls back to mechanical when LLM returns nil' do
+        allow(fake_chat).to receive(:ask).and_return(double(content: nil))
+
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit: { decayed: 1, unresolved_count: 0 }
+                                         })
+        expect(result[:source]).to eq(:mechanical)
+        expect(result[:reflection]).to be_a(String)
+        expect(result[:reflection]).not_to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfModel::Client do
+  subject(:client) { described_class.new }
+
+  it 'full lifecycle: add capability and knowledge, predict, record, introspect' do
+    cap_result = client.add_self_capability(name: 'problem solving', domain: :cognitive, competence: 0.6)
+    expect(cap_result[:success]).to be true
+
+    dom_result = client.add_self_knowledge(name: 'algorithms', depth: 0.5, breadth: 0.4)
+    expect(dom_result[:success]).to be true
+
+    pred = client.predict_own_success(capability_id: cap_result[:capability_id])
+    expect(pred[:success]).to be true
+    expect(pred[:predicted_probability]).to be_a(Float)
+
+    outcome = client.record_self_outcome(
+      capability_id: cap_result[:capability_id],
+      predicted:     true,
+      actual:        true
+    )
+    expect(outcome[:success]).to be true
+
+    introspection = client.self_introspection
+    expect(introspection[:success]).to be true
+    expect(introspection[:strengths]).to be_an(Array)
+
+    report = client.self_calibration_report
+    expect(report[:success]).to be true
+
+    stats = client.self_model_stats
+    expect(stats[:capability_count]).to eq(1)
+    expect(stats[:knowledge_domain_count]).to eq(1)
+  end
+
+  it 'accepts injected model' do
+    injected = Legion::Extensions::Agentic::Self::SelfModel::Helpers::SelfModel.new
+    c = described_class.new(model: injected)
+    c.add_self_capability(name: 'testing')
+    expect(injected.capabilities.size).to eq(1)
+  end
+
+  it 'tracks strengths and weaknesses separately' do
+    client.add_self_capability(name: 'expert task', competence: 0.9)
+    client.add_self_capability(name: 'beginner task', competence: 0.1)
+
+    strengths  = client.self_strengths
+    weaknesses = client.self_weaknesses
+
+    expect(strengths[:count]).to eq(1)
+    expect(weaknesses[:count]).to eq(1)
+    expect(strengths[:strengths].first[:name]).to eq('expert task')
+    expect(weaknesses[:weaknesses].first[:name]).to eq('beginner task')
+  end
+end

data/spec/legion/extensions/agentic/self/self_model/helpers/capability_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfModel::Helpers::Capability do
+  subject(:cap) do
+    described_class.new(id: :cap_one, name: 'write code', domain: :engineering, competence: 0.6)
+  end
+
+  describe '#initialize' do
+    it 'sets id, name, domain' do
+      expect(cap.id).to eq(:cap_one)
+      expect(cap.name).to eq('write code')
+      expect(cap.domain).to eq(:engineering)
+    end
+
+    it 'sets competence' do
+      expect(cap.competence).to eq(0.6)
+    end
+
+    it 'starts with zero attempts and successes' do
+      expect(cap.attempts).to eq(0)
+      expect(cap.successes).to eq(0)
+    end
+
+    it 'starts with zero calibration error' do
+      expect(cap.calibration_error).to eq(0.0)
+    end
+
+    it 'clamps competence to floor' do
+      c = described_class.new(id: :x, name: 'x', competence: -1.0)
+      expect(c.competence).to eq(Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::COMPETENCE_FLOOR)
+    end
+
+    it 'clamps competence to ceiling' do
+      c = described_class.new(id: :x, name: 'x', competence: 2.0)
+      expect(c.competence).to eq(Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::COMPETENCE_CEILING)
+    end
+
+    it 'sets initial state based on competence' do
+      expect(cap.state).to eq(:competent)
+    end
+  end
+
+  describe '#record_attempt' do
+    it 'increments attempts' do
+      cap.record_attempt(predicted_success: true, actual_success: true)
+      expect(cap.attempts).to eq(1)
+    end
+
+    it 'increments successes on actual success' do
+      cap.record_attempt(predicted_success: true, actual_success: true)
+      expect(cap.successes).to eq(1)
+    end
+
+    it 'does not increment successes on failure' do
+      cap.record_attempt(predicted_success: true, actual_success: false)
+      expect(cap.successes).to eq(0)
+    end
+
+    it 'updates competence toward actual outcome' do
+      original = cap.competence
+      cap.record_attempt(predicted_success: true, actual_success: false)
+      expect(cap.competence).to be < original
+    end
+
+    it 'updates calibration error toward prediction error' do
+      cap.record_attempt(predicted_success: true, actual_success: false)
+      expect(cap.calibration_error).not_to eq(0.0)
+    end
+
+    it 'keeps competence within floor/ceiling' do
+      low_cap = described_class.new(id: :x, name: 'x', competence: 0.06)
+      20.times { low_cap.record_attempt(predicted_success: false, actual_success: false) }
+      expect(low_cap.competence).to be >= Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::COMPETENCE_FLOOR
+    end
+  end
+
+  describe '#state transitions' do
+    it 'returns :unknown for competence < 0.2' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.1)
+      expect(c.state).to eq(:unknown)
+    end
+
+    it 'returns :developing for competence 0.2-0.5' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.35)
+      expect(c.state).to eq(:developing)
+    end
+
+    it 'returns :competent for competence 0.5-0.8' do
+      expect(cap.state).to eq(:competent)
+    end
+
+    it 'returns :expert for competence >= 0.8' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.9)
+      expect(c.state).to eq(:expert)
+    end
+  end
+
+  describe '#competence_label' do
+    it 'returns a symbol' do
+      expect(cap.competence_label).to be_a(Symbol)
+    end
+
+    it 'returns :moderate for 0.6' do
+      expect(cap.competence_label).to eq(:moderate)
+    end
+
+    it 'returns :high for 0.8' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.8)
+      expect(c.competence_label).to eq(:high)
+    end
+  end
+
+  describe '#calibrated?' do
+    it 'returns true when calibration_error is within threshold' do
+      expect(cap.calibrated?).to be true
+    end
+
+    it 'returns false after many overconfident predictions' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.9)
+      20.times { c.record_attempt(predicted_success: true, actual_success: false) }
+      expect(c.calibrated?).to be false
+    end
+  end
+
+  describe '#overconfident?' do
+    it 'returns false initially' do
+      expect(cap.overconfident?).to be false
+    end
+
+    it 'returns true after sustained overconfident predictions' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.9)
+      30.times { c.record_attempt(predicted_success: true, actual_success: false) }
+      expect(c.overconfident?).to be true
+    end
+  end
+
+  describe '#underconfident?' do
+    it 'returns false initially' do
+      expect(cap.underconfident?).to be false
+    end
+
+    it 'returns true after sustained underconfident predictions' do
+      c = described_class.new(id: :x, name: 'x', competence: 0.1)
+      30.times { c.record_attempt(predicted_success: false, actual_success: true) }
+      expect(c.underconfident?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = cap.to_h
+      expect(h).to include(:id, :name, :domain, :competence, :state, :attempts, :successes,
+                           :calibration_error, :calibrated, :overconfident, :underconfident)
+    end
+
+    it 'rounds competence to 4 decimal places' do
+      expect(cap.to_h[:competence]).to eq(cap.competence.round(4))
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_model/helpers/knowledge_domain_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfModel::Helpers::KnowledgeDomain do
+  subject(:dom) do
+    described_class.new(id: :dom_one, name: 'machine learning', depth: 0.4, breadth: 0.3)
+  end
+
+  describe '#initialize' do
+    it 'sets id and name' do
+      expect(dom.id).to eq(:dom_one)
+      expect(dom.name).to eq('machine learning')
+    end
+
+    it 'sets depth and breadth' do
+      expect(dom.depth).to be_within(0.001).of(0.4)
+      expect(dom.breadth).to be_within(0.001).of(0.3)
+    end
+
+    it 'computes confidence as average of depth and breadth' do
+      expect(dom.confidence).to be_within(0.001).of(0.35)
+    end
+
+    it 'starts with nil last_accessed' do
+      expect(dom.last_accessed).to be_nil
+    end
+
+    it 'clamps depth to 0-1' do
+      d = described_class.new(id: :x, name: 'x', depth: 2.0, breadth: 0.0)
+      expect(d.depth).to eq(1.0)
+    end
+
+    it 'clamps breadth to 0-1' do
+      d = described_class.new(id: :x, name: 'x', depth: 0.0, breadth: -0.5)
+      expect(d.breadth).to eq(0.0)
+    end
+  end
+
+  describe '#deepen' do
+    it 'increases depth' do
+      original = dom.depth
+      dom.deepen(amount: 0.2)
+      expect(dom.depth).to be > original
+    end
+
+    it 'updates confidence after deepening' do
+      original = dom.confidence
+      dom.deepen(amount: 0.3)
+      expect(dom.confidence).to be > original
+    end
+
+    it 'clamps depth at 1.0' do
+      dom.deepen(amount: 5.0)
+      expect(dom.depth).to eq(1.0)
+    end
+
+    it 'updates state after deepening' do
+      d = described_class.new(id: :x, name: 'x', depth: 0.0, breadth: 0.0)
+      d.deepen(amount: 0.9)
+      expect(d.state).not_to eq(:ignorant)
+    end
+  end
+
+  describe '#broaden' do
+    it 'increases breadth' do
+      original = dom.breadth
+      dom.broaden(amount: 0.2)
+      expect(dom.breadth).to be > original
+    end
+
+    it 'updates confidence after broadening' do
+      original = dom.confidence
+      dom.broaden(amount: 0.3)
+      expect(dom.confidence).to be > original
+    end
+
+    it 'clamps breadth at 1.0' do
+      dom.broaden(amount: 5.0)
+      expect(dom.breadth).to eq(1.0)
+    end
+  end
+
+  describe '#access!' do
+    it 'sets last_accessed to current time' do
+      dom.access!
+      expect(dom.last_accessed).not_to be_nil
+      expect(dom.last_accessed).to be_a(Time)
+    end
+  end
+
+  describe '#state' do
+    it 'returns :ignorant for very low scores' do
+      d = described_class.new(id: :x, name: 'x', depth: 0.05, breadth: 0.05)
+      expect(d.state).to eq(:ignorant)
+    end
+
+    it 'returns :aware for low scores' do
+      d = described_class.new(id: :x, name: 'x', depth: 0.3, breadth: 0.3)
+      expect(d.state).to eq(:aware)
+    end
+
+    it 'returns :familiar for moderate scores' do
+      expect(dom.state).to eq(:aware)
+    end
+
+    it 'returns :expert for high scores' do
+      d = described_class.new(id: :x, name: 'x', depth: 0.9, breadth: 0.9)
+      expect(d.state).to eq(:expert)
+    end
+  end
+
+  describe '#knowledge_label' do
+    it 'returns a symbol' do
+      expect(dom.knowledge_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = dom.to_h
+      expect(h).to include(:id, :name, :depth, :breadth, :confidence, :state, :knowledge_label, :last_accessed)
+    end
+
+    it 'rounds depth and breadth' do
+      expect(dom.to_h[:depth]).to eq(dom.depth.round(4))
+      expect(dom.to_h[:breadth]).to eq(dom.breadth.round(4))
+    end
+  end
+end