lex-agentic-self 0.1.0

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfModel::Helpers::SelfModel do
+  subject(:sm) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty capabilities' do
+      expect(sm.capabilities).to be_empty
+    end
+
+    it 'starts with empty knowledge domains' do
+      expect(sm.knowledge_domains).to be_empty
+    end
+
+    it 'starts with empty predictions and history' do
+      expect(sm.predictions).to be_empty
+      expect(sm.history).to be_empty
+    end
+  end
+
+  describe '#add_capability' do
+    it 'adds and returns a capability' do
+      cap = sm.add_capability(name: 'reasoning', domain: :cognitive)
+      expect(cap).to be_a(Legion::Extensions::Agentic::Self::SelfModel::Helpers::Capability)
+      expect(cap.name).to eq('reasoning')
+    end
+
+    it 'assigns unique symbol ids' do
+      a = sm.add_capability(name: 'a')
+      b = sm.add_capability(name: 'b')
+      expect(a.id).to be_a(Symbol)
+      expect(b.id).to be_a(Symbol)
+      expect(a.id).not_to eq(b.id)
+    end
+
+    it 'returns nil at capacity limit' do
+      Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::MAX_CAPABILITIES.times do |i|
+        sm.add_capability(name: "cap_#{i}")
+      end
+      expect(sm.add_capability(name: 'overflow')).to be_nil
+    end
+  end
+
+  describe '#add_knowledge_domain' do
+    it 'adds and returns a knowledge domain' do
+      dom = sm.add_knowledge_domain(name: 'graph theory', depth: 0.6, breadth: 0.4)
+      expect(dom).to be_a(Legion::Extensions::Agentic::Self::SelfModel::Helpers::KnowledgeDomain)
+      expect(dom.name).to eq('graph theory')
+    end
+
+    it 'assigns unique symbol ids' do
+      a = sm.add_knowledge_domain(name: 'a')
+      b = sm.add_knowledge_domain(name: 'b')
+      expect(a.id).to be_a(Symbol)
+      expect(b.id).to be_a(Symbol)
+      expect(a.id).not_to eq(b.id)
+    end
+
+    it 'returns nil at capacity limit' do
+      Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::MAX_KNOWLEDGE_DOMAINS.times do |i|
+        sm.add_knowledge_domain(name: "dom_#{i}")
+      end
+      expect(sm.add_knowledge_domain(name: 'overflow')).to be_nil
+    end
+  end
+
+  describe '#predict_success' do
+    it 'returns a prediction hash for a known capability' do
+      cap = sm.add_capability(name: 'analysis', competence: 0.7)
+      pred = sm.predict_success(capability_id: cap.id)
+      expect(pred).to include(:capability_id, :predicted_probability, :at)
+      expect(pred[:predicted_probability]).to be_within(0.01).of(0.7)
+    end
+
+    it 'returns nil for unknown capability' do
+      expect(sm.predict_success(capability_id: :bogus)).to be_nil
+    end
+
+    it 'logs prediction to predictions array' do
+      cap = sm.add_capability(name: 'x')
+      sm.predict_success(capability_id: cap.id)
+      expect(sm.predictions.size).to eq(1)
+    end
+  end
+
+  describe '#record_outcome' do
+    it 'returns an event for a known capability' do
+      cap = sm.add_capability(name: 'writing')
+      event = sm.record_outcome(capability_id: cap.id, predicted: true, actual: true)
+      expect(event).to include(:type, :capability_id, :predicted, :actual, :at)
+    end
+
+    it 'returns nil for unknown capability' do
+      expect(sm.record_outcome(capability_id: :bogus, predicted: true, actual: false)).to be_nil
+    end
+
+    it 'updates capability competence' do
+      cap = sm.add_capability(name: 'math', competence: 0.3)
+      original = cap.competence
+      sm.record_outcome(capability_id: cap.id, predicted: false, actual: true)
+      expect(cap.competence).to be > original
+    end
+
+    it 'logs event to history' do
+      cap = sm.add_capability(name: 'x')
+      sm.record_outcome(capability_id: cap.id, predicted: true, actual: true)
+      expect(sm.history.size).to eq(1)
+    end
+  end
+
+  describe '#introspect' do
+    it 'returns a complete introspection hash' do
+      sm.add_capability(name: 'coding', competence: 0.85)
+      sm.add_capability(name: 'guessing', competence: 0.15)
+      sm.add_knowledge_domain(name: 'ruby', depth: 0.2, breadth: 0.1)
+
+      result = sm.introspect
+      expect(result).to include(:overall_confidence, :strengths, :weaknesses, :blind_spots,
+                                :knowledge_gaps, :calibration)
+    end
+  end
+
+  describe '#strengths' do
+    it 'returns capabilities with competence > 0.7' do
+      sm.add_capability(name: 'strong', competence: 0.8)
+      sm.add_capability(name: 'weak', competence: 0.2)
+      expect(sm.strengths.map(&:name)).to include('strong')
+      expect(sm.strengths.map(&:name)).not_to include('weak')
+    end
+  end
+
+  describe '#weaknesses' do
+    it 'returns capabilities with competence < 0.3' do
+      sm.add_capability(name: 'strong', competence: 0.8)
+      sm.add_capability(name: 'weak', competence: 0.2)
+      expect(sm.weaknesses.map(&:name)).to include('weak')
+      expect(sm.weaknesses.map(&:name)).not_to include('strong')
+    end
+  end
+
+  describe '#blind_spots' do
+    it 'returns empty initially' do
+      sm.add_capability(name: 'x', competence: 0.7)
+      expect(sm.blind_spots).to be_empty
+    end
+
+    it 'returns capabilities that are overconfident after bad predictions' do
+      cap = sm.add_capability(name: 'overestimated', competence: 0.9)
+      30.times { sm.record_outcome(capability_id: cap.id, predicted: true, actual: false) }
+      expect(sm.blind_spots).not_to be_empty
+    end
+  end
+
+  describe '#calibration_report' do
+    it 'returns uncalibrated label when no capabilities exist' do
+      report = sm.calibration_report
+      expect(report[:label]).to eq(:uncalibrated)
+      expect(report[:total]).to eq(0)
+    end
+
+    it 'returns a label and mean_error when capabilities exist' do
+      sm.add_capability(name: 'x', competence: 0.5)
+      report = sm.calibration_report
+      expect(report).to include(:label, :mean_error, :calibrated_count, :total)
+    end
+  end
+
+  describe '#knowledge_gaps' do
+    it 'returns domains with depth < 0.3' do
+      sm.add_knowledge_domain(name: 'shallow', depth: 0.1, breadth: 0.5)
+      sm.add_knowledge_domain(name: 'deep', depth: 0.8, breadth: 0.5)
+      gaps = sm.knowledge_gaps.map(&:name)
+      expect(gaps).to include('shallow')
+      expect(gaps).not_to include('deep')
+    end
+  end
+
+  describe '#can_do?' do
+    it 'returns true for high-competence capability by name' do
+      sm.add_capability(name: 'fly', competence: 0.8)
+      expect(sm.can_do?('fly')).to be true
+    end
+
+    it 'returns false for low-competence capability' do
+      sm.add_capability(name: 'swim', competence: 0.2)
+      expect(sm.can_do?('swim')).to be false
+    end
+
+    it 'returns false for unknown capability name' do
+      expect(sm.can_do?('teleport')).to be false
+    end
+  end
+
+  describe '#knows_about?' do
+    it 'returns true for high-confidence domain by name' do
+      sm.add_knowledge_domain(name: 'physics', depth: 0.7, breadth: 0.6)
+      expect(sm.knows_about?('physics')).to be true
+    end
+
+    it 'returns false for low-confidence domain' do
+      sm.add_knowledge_domain(name: 'astrology', depth: 0.1, breadth: 0.1)
+      expect(sm.knows_about?('astrology')).to be false
+    end
+
+    it 'returns false for unknown domain name' do
+      expect(sm.knows_about?('magic')).to be false
+    end
+  end
+
+  describe '#overall_confidence' do
+    it 'returns DEFAULT_COMPETENCE when no capabilities exist' do
+      expect(sm.overall_confidence).to eq(Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::DEFAULT_COMPETENCE)
+    end
+
+    it 'returns average competence across capabilities' do
+      sm.add_capability(name: 'a', competence: 0.4)
+      sm.add_capability(name: 'b', competence: 0.6)
+      expect(sm.overall_confidence).to be_within(0.01).of(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = sm.to_h
+      expect(h).to include(:capability_count, :knowledge_domain_count, :overall_confidence,
+                           :strength_count, :weakness_count, :blind_spot_count,
+                           :knowledge_gap_count, :prediction_count, :history_size)
+    end
+
+    it 'reflects correct counts' do
+      sm.add_capability(name: 'x', competence: 0.8)
+      sm.add_knowledge_domain(name: 'y', depth: 0.1, breadth: 0.1)
+      h = sm.to_h
+      expect(h[:capability_count]).to eq(1)
+      expect(h[:knowledge_domain_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_model/runners/self_model_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfModel::Runners::SelfModel do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#add_self_capability' do
+    it 'adds a capability and returns success' do
+      result = runner.add_self_capability(name: 'planning', domain: :cognitive)
+      expect(result[:success]).to be true
+      expect(result[:capability_id]).to be_a(Symbol)
+      expect(result[:state]).to be_a(Symbol)
+    end
+
+    it 'returns failure when limit is reached' do
+      Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::MAX_CAPABILITIES.times do |i|
+        runner.add_self_capability(name: "cap_#{i}")
+      end
+      result = runner.add_self_capability(name: 'overflow')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_reached)
+    end
+  end
+
+  describe '#add_self_knowledge' do
+    it 'adds a knowledge domain and returns success' do
+      result = runner.add_self_knowledge(name: 'topology', depth: 0.4, breadth: 0.3)
+      expect(result[:success]).to be true
+      expect(result[:domain_id]).to be_a(Symbol)
+    end
+
+    it 'returns failure when limit is reached' do
+      Legion::Extensions::Agentic::Self::SelfModel::Helpers::Constants::MAX_KNOWLEDGE_DOMAINS.times do |i|
+        runner.add_self_knowledge(name: "dom_#{i}")
+      end
+      result = runner.add_self_knowledge(name: 'overflow')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_reached)
+    end
+  end
+
+  describe '#predict_own_success' do
+    it 'returns prediction for known capability' do
+      added = runner.add_self_capability(name: 'analysis', competence: 0.75)
+      result = runner.predict_own_success(capability_id: added[:capability_id])
+      expect(result[:success]).to be true
+      expect(result[:predicted_probability]).to be_a(Float)
+    end
+
+    it 'returns failure for unknown capability' do
+      result = runner.predict_own_success(capability_id: :nonexistent)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#record_self_outcome' do
+    it 'records outcome and returns updated competence' do
+      added = runner.add_self_capability(name: 'writing', competence: 0.5)
+      result = runner.record_self_outcome(
+        capability_id: added[:capability_id], predicted: true, actual: true
+      )
+      expect(result[:success]).to be true
+      expect(result[:competence]).to be_a(Float)
+      expect(result[:calibration_error]).to be_a(Float)
+    end
+
+    it 'returns failure for unknown capability' do
+      result = runner.record_self_outcome(capability_id: :bogus, predicted: true, actual: false)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#self_introspection' do
+    it 'returns introspection hash' do
+      runner.add_self_capability(name: 'planning', competence: 0.8)
+      result = runner.self_introspection
+      expect(result[:success]).to be true
+      expect(result).to include(:overall_confidence, :strengths, :weaknesses, :blind_spots)
+    end
+  end
+
+  describe '#self_strengths' do
+    it 'returns strengths list' do
+      runner.add_self_capability(name: 'strong', competence: 0.9)
+      result = runner.self_strengths
+      expect(result[:success]).to be true
+      expect(result[:strengths]).to be_an(Array)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns empty list when no strengths' do
+      runner.add_self_capability(name: 'weak', competence: 0.2)
+      result = runner.self_strengths
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#self_weaknesses' do
+    it 'returns weaknesses list' do
+      runner.add_self_capability(name: 'weak', competence: 0.1)
+      result = runner.self_weaknesses
+      expect(result[:success]).to be true
+      expect(result[:weaknesses]).to be_an(Array)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#self_blind_spots' do
+    it 'returns empty list initially' do
+      runner.add_self_capability(name: 'x', competence: 0.7)
+      result = runner.self_blind_spots
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#self_calibration_report' do
+    it 'returns calibration report' do
+      result = runner.self_calibration_report
+      expect(result[:success]).to be true
+      expect(result).to include(:label, :mean_error)
+    end
+  end
+
+  describe '#self_model_stats' do
+    it 'returns stats hash' do
+      result = runner.self_model_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:capability_count, :knowledge_domain_count)
+    end
+
+    it 'reflects added capabilities' do
+      runner.add_self_capability(name: 'x')
+      result = runner.self_model_stats
+      expect(result[:capability_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/actors/volume_decay_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/self/self_talk/actors/volume_decay'
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Actor::VolumeDecay do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'decay_voices' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 300 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/self_talk/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:register_voice)
+    expect(client).to respond_to(:start_dialogue)
+    expect(client).to respond_to(:add_turn)
+    expect(client).to respond_to(:conclude_dialogue)
+    expect(client).to respond_to(:deadlock_dialogue)
+    expect(client).to respond_to(:amplify_voice)
+    expect(client).to respond_to(:dampen_voice)
+    expect(client).to respond_to(:dialogue_report)
+    expect(client).to respond_to(:self_talk_status)
+  end
+
+  it 'each instance has independent state' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.register_voice(name: 'Lone Voice', voice_type: :critic)
+    expect(c2.self_talk_status[:voice_count]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/helpers/constants_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::Constants do
+  describe 'MAX_VOICES' do
+    it 'is 10' do
+      expect(described_class::MAX_VOICES).to eq(10)
+    end
+  end
+
+  describe 'MAX_DIALOGUES' do
+    it 'is 200' do
+      expect(described_class::MAX_DIALOGUES).to eq(200)
+    end
+  end
+
+  describe 'MAX_TURNS_PER_DIALOGUE' do
+    it 'is 50' do
+      expect(described_class::MAX_TURNS_PER_DIALOGUE).to eq(50)
+    end
+  end
+
+  describe 'DEFAULT_VOLUME' do
+    it 'is 0.5' do
+      expect(described_class::DEFAULT_VOLUME).to eq(0.5)
+    end
+  end
+
+  describe 'VOLUME_BOOST' do
+    it 'is 0.1' do
+      expect(described_class::VOLUME_BOOST).to eq(0.1)
+    end
+  end
+
+  describe 'VOLUME_DECAY' do
+    it 'is 0.05' do
+      expect(described_class::VOLUME_DECAY).to eq(0.05)
+    end
+  end
+
+  describe 'VOICE_TYPES' do
+    it 'includes all eight voice types' do
+      expect(described_class::VOICE_TYPES).to include(
+        :critic, :encourager, :analyst, :devils_advocate,
+        :pragmatist, :visionary, :caretaker, :rebel
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::VOICE_TYPES).to be_frozen
+    end
+  end
+
+  describe 'DIALOGUE_STATUSES' do
+    it 'includes open, concluded, deadlocked, abandoned' do
+      expect(described_class::DIALOGUE_STATUSES).to include(:open, :concluded, :deadlocked, :abandoned)
+    end
+
+    it 'is frozen' do
+      expect(described_class::DIALOGUE_STATUSES).to be_frozen
+    end
+  end
+
+  describe '.dominance_label' do
+    it 'returns :commanding for volume >= 0.8' do
+      expect(described_class.dominance_label(1.0)).to eq(:commanding)
+      expect(described_class.dominance_label(0.8)).to eq(:commanding)
+    end
+
+    it 'returns :assertive for volume in 0.6..0.8' do
+      expect(described_class.dominance_label(0.7)).to eq(:assertive)
+    end
+
+    it 'returns :balanced for volume in 0.4..0.6' do
+      expect(described_class.dominance_label(0.5)).to eq(:balanced)
+    end
+
+    it 'returns :quiet for volume in 0.2..0.4' do
+      expect(described_class.dominance_label(0.3)).to eq(:quiet)
+    end
+
+    it 'returns :silent for volume < 0.2' do
+      expect(described_class.dominance_label(0.1)).to eq(:silent)
+      expect(described_class.dominance_label(0.0)).to eq(:silent)
+    end
+  end
+
+  describe '.consensus_label' do
+    it 'returns :unanimous for score >= 0.8' do
+      expect(described_class.consensus_label(1.0)).to eq(:unanimous)
+      expect(described_class.consensus_label(0.8)).to eq(:unanimous)
+    end
+
+    it 'returns :agreement for score in 0.6..0.8' do
+      expect(described_class.consensus_label(0.7)).to eq(:agreement)
+    end
+
+    it 'returns :mixed for score in 0.4..0.6' do
+      expect(described_class.consensus_label(0.5)).to eq(:mixed)
+    end
+
+    it 'returns :disagreement for score in 0.2..0.4' do
+      expect(described_class.consensus_label(0.3)).to eq(:disagreement)
+    end
+
+    it 'returns :conflict for score < 0.2' do
+      expect(described_class.consensus_label(0.1)).to eq(:conflict)
+      expect(described_class.consensus_label(0.0)).to eq(:conflict)
+    end
+  end
+end