lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/anosognosia/helpers/cognitive_deficit_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia::Helpers::CognitiveDeficit do
+  subject(:deficit) do
+    described_class.new(domain: :language, deficit_type: :knowledge, severity: 0.6)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(deficit.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns domain' do
+      expect(deficit.domain).to eq(:language)
+    end
+
+    it 'assigns deficit_type' do
+      expect(deficit.deficit_type).to eq(:knowledge)
+    end
+
+    it 'assigns severity' do
+      expect(deficit.severity).to eq(0.6)
+    end
+
+    it 'defaults acknowledged to false' do
+      expect(deficit.acknowledged).to be false
+    end
+
+    it 'assigns discovered_at' do
+      expect(deficit.discovered_at).to be_a(Time)
+    end
+
+    it 'leaves acknowledged_at nil' do
+      expect(deficit.acknowledged_at).to be_nil
+    end
+
+    it 'clamps severity above 1.0 to 1.0' do
+      d = described_class.new(domain: :test, deficit_type: :reasoning, severity: 1.5)
+      expect(d.severity).to eq(1.0)
+    end
+
+    it 'clamps severity below 0.0 to 0.0' do
+      d = described_class.new(domain: :test, deficit_type: :reasoning, severity: -0.5)
+      expect(d.severity).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for invalid deficit_type' do
+      expect do
+        described_class.new(domain: :test, deficit_type: :invalid_type, severity: 0.5)
+      end.to raise_error(ArgumentError, /Invalid deficit_type/)
+    end
+
+    it 'accepts acknowledged: true' do
+      d = described_class.new(domain: :test, deficit_type: :memory, severity: 0.3, acknowledged: true)
+      expect(d.acknowledged).to be true
+    end
+  end
+
+  describe '#acknowledge!' do
+    it 'sets acknowledged to true' do
+      deficit.acknowledge!
+      expect(deficit.acknowledged).to be true
+    end
+
+    it 'sets acknowledged_at timestamp' do
+      deficit.acknowledge!
+      expect(deficit.acknowledged_at).to be_a(Time)
+    end
+
+    it 'returns true when newly acknowledged' do
+      expect(deficit.acknowledge!).to be true
+    end
+
+    it 'returns false when already acknowledged' do
+      deficit.acknowledge!
+      expect(deficit.acknowledge!).to be false
+    end
+
+    it 'does not update acknowledged_at on second call' do
+      deficit.acknowledge!
+      first_time = deficit.acknowledged_at
+      sleep(0.001)
+      deficit.acknowledge!
+      expect(deficit.acknowledged_at).to eq(first_time)
+    end
+  end
+
+  describe '#severity_label' do
+    it 'returns :severe for severity >= 0.8' do
+      d = described_class.new(domain: :t, deficit_type: :attention, severity: 0.9)
+      expect(d.severity_label).to eq(:severe)
+    end
+
+    it 'returns :high for severity in 0.6..0.8' do
+      d = described_class.new(domain: :t, deficit_type: :attention, severity: 0.7)
+      expect(d.severity_label).to eq(:high)
+    end
+
+    it 'returns :moderate for severity in 0.4..0.6' do
+      d = described_class.new(domain: :t, deficit_type: :attention, severity: 0.5)
+      expect(d.severity_label).to eq(:moderate)
+    end
+
+    it 'returns :low for severity in 0.2..0.4' do
+      d = described_class.new(domain: :t, deficit_type: :attention, severity: 0.3)
+      expect(d.severity_label).to eq(:low)
+    end
+
+    it 'returns :minimal for severity < 0.2' do
+      d = described_class.new(domain: :t, deficit_type: :attention, severity: 0.1)
+      expect(d.severity_label).to eq(:minimal)
+    end
+  end
+
+  describe '#to_h' do
+    let(:h) { deficit.to_h }
+
+    it 'includes id' do
+      expect(h[:id]).to eq(deficit.id)
+    end
+
+    it 'includes domain' do
+      expect(h[:domain]).to eq(:language)
+    end
+
+    it 'includes deficit_type' do
+      expect(h[:deficit_type]).to eq(:knowledge)
+    end
+
+    it 'includes severity rounded to 10 places' do
+      expect(h[:severity]).to eq(0.6.round(10))
+    end
+
+    it 'includes severity_label' do
+      expect(h[:severity_label]).to eq(:high)
+    end
+
+    it 'includes acknowledged' do
+      expect(h[:acknowledged]).to be false
+    end
+
+    it 'includes discovered_at' do
+      expect(h[:discovered_at]).to be_a(Time)
+    end
+
+    it 'includes acknowledged_at' do
+      expect(h).to have_key(:acknowledged_at)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia::Helpers::Constants do
+  describe 'MAX_DEFICITS' do
+    it 'is 200' do
+      expect(described_class::MAX_DEFICITS).to eq(200)
+    end
+  end
+
+  describe 'AWARENESS_DECAY' do
+    it 'is 0.02' do
+      expect(described_class::AWARENESS_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'AWARENESS_BOOST' do
+    it 'is 0.1' do
+      expect(described_class::AWARENESS_BOOST).to eq(0.1)
+    end
+  end
+
+  describe 'AWARENESS_LABELS' do
+    it 'includes all expected labels' do
+      labels = described_class::AWARENESS_LABELS.values
+      expect(labels).to include(:calibrated, :mostly_aware, :partially_blind, :largely_blind, :anosognosic)
+    end
+
+    it 'has 5 labels' do
+      expect(described_class::AWARENESS_LABELS.size).to eq(5)
+    end
+
+    it 'maps 1.0 to calibrated' do
+      label = described_class::AWARENESS_LABELS.find { |range, _| range.include?(1.0) }&.last
+      expect(label).to eq(:calibrated)
+    end
+
+    it 'maps 0.0 to anosognosic' do
+      label = described_class::AWARENESS_LABELS.find { |range, _| range.include?(0.0) }&.last
+      expect(label).to eq(:anosognosic)
+    end
+  end
+
+  describe 'DEFICIT_TYPES' do
+    it 'includes all six deficit types' do
+      expect(described_class::DEFICIT_TYPES).to include(
+        :knowledge, :reasoning, :memory, :perception, :attention, :judgment
+      )
+    end
+
+    it 'has exactly six types' do
+      expect(described_class::DEFICIT_TYPES.size).to eq(6)
+    end
+
+    it 'is frozen' do
+      expect(described_class::DEFICIT_TYPES).to be_frozen
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/anosognosia/runners/anosognosia_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/anosognosia/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia::Runners::Anosognosia do
+  let(:client) { Legion::Extensions::Agentic::Self::Anosognosia::Client.new }
+
+  def register(client, domain: :language, deficit_type: :knowledge, severity: 0.5)
+    client.register_deficit(domain: domain, deficit_type: deficit_type, severity: severity)
+  end
+
+  describe '#register_deficit' do
+    it 'returns registered: true' do
+      result = register(client)
+      expect(result[:registered]).to be true
+    end
+
+    it 'returns a deficit_id' do
+      result = register(client)
+      expect(result[:deficit_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'includes severity in result' do
+      result = register(client, severity: 0.7)
+      expect(result[:severity]).to eq(0.7)
+    end
+
+    it 'includes severity_label' do
+      result = register(client, severity: 0.7)
+      expect(result[:severity_label]).to eq(:high)
+    end
+
+    it 'includes acknowledged: false by default' do
+      result = register(client)
+      expect(result[:acknowledged]).to be false
+    end
+
+    it 'includes awareness_score' do
+      result = register(client)
+      expect(result).to have_key(:awareness_score)
+    end
+  end
+
+  describe '#acknowledge_deficit' do
+    let(:deficit_id) { register(client)[:deficit_id] }
+
+    it 'acknowledges an existing deficit' do
+      result = client.acknowledge_deficit(deficit_id: deficit_id)
+      expect(result[:found]).to be true
+      expect(result[:changed]).to be true
+    end
+
+    it 'returns found: false for unknown id' do
+      result = client.acknowledge_deficit(deficit_id: 'no-such-id')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns changed: false when already acknowledged' do
+      client.acknowledge_deficit(deficit_id: deficit_id)
+      result = client.acknowledge_deficit(deficit_id: deficit_id)
+      expect(result[:changed]).to be false
+    end
+  end
+
+  describe '#reveal_blind_spot' do
+    let(:deficit_id) { register(client)[:deficit_id] }
+
+    it 'returns found: true and already_known: false for a blind spot' do
+      result = client.reveal_blind_spot(deficit_id: deficit_id)
+      expect(result[:found]).to be true
+      expect(result[:already_known]).to be false
+    end
+
+    it 'returns already_known: true if already acknowledged' do
+      client.acknowledge_deficit(deficit_id: deficit_id)
+      result = client.reveal_blind_spot(deficit_id: deficit_id)
+      expect(result[:already_known]).to be true
+    end
+
+    it 'returns found: false for unknown id' do
+      result = client.reveal_blind_spot(deficit_id: 'no-such-id')
+      expect(result[:found]).to be false
+    end
+
+    it 'includes awareness_score for newly revealed spot' do
+      result = client.reveal_blind_spot(deficit_id: deficit_id)
+      expect(result).to have_key(:awareness_score)
+    end
+
+    it 'includes awareness_label for newly revealed spot' do
+      result = client.reveal_blind_spot(deficit_id: deficit_id)
+      expect(result).to have_key(:awareness_label)
+    end
+  end
+
+  describe '#awareness_score' do
+    it 'returns awareness_score hash' do
+      result = client.awareness_score
+      expect(result).to have_key(:awareness_score)
+    end
+
+    it 'includes awareness_gap' do
+      result = client.awareness_score
+      expect(result).to have_key(:awareness_gap)
+    end
+
+    it 'includes awareness_label' do
+      result = client.awareness_score
+      expect(result).to have_key(:awareness_label)
+    end
+
+    it 'starts at 1.0 (fully calibrated) with no deficits' do
+      result = client.awareness_score
+      expect(result[:awareness_score]).to eq(1.0)
+    end
+  end
+
+  describe '#awareness_gap' do
+    it 'returns awareness_gap hash' do
+      result = client.awareness_gap
+      expect(result).to have_key(:awareness_gap)
+    end
+
+    it 'includes awareness_score' do
+      result = client.awareness_gap
+      expect(result).to have_key(:awareness_score)
+    end
+  end
+
+  describe '#blind_spots' do
+    it 'returns empty array when no deficits registered' do
+      result = client.blind_spots
+      expect(result[:blind_spots]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns unacknowledged deficits' do
+      id1 = register(client, domain: :a)[:deficit_id]
+      register(client, domain: :b)
+      client.acknowledge_deficit(deficit_id: id1)
+      result = client.blind_spots
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#calibration_report' do
+    before do
+      id1 = register(client, domain: :a)[:deficit_id]
+      register(client, domain: :b)
+      client.acknowledge_deficit(deficit_id: id1)
+    end
+
+    let(:report) { client.calibration_report }
+
+    it 'returns a calibration report hash' do
+      expect(report).to be_a(Hash)
+    end
+
+    it 'includes total_deficits' do
+      expect(report[:total_deficits]).to eq(2)
+    end
+
+    it 'includes acknowledged_deficits' do
+      expect(report[:acknowledged_deficits]).to eq(1)
+    end
+
+    it 'includes unacknowledged_deficits' do
+      expect(report[:unacknowledged_deficits]).to eq(1)
+    end
+
+    it 'includes awareness_label' do
+      expect(report).to have_key(:awareness_label)
+    end
+
+    it 'includes deficit_breakdown with all types' do
+      breakdown = report[:deficit_breakdown]
+      Legion::Extensions::Agentic::Self::Anosognosia::Helpers::Constants::DEFICIT_TYPES.each do |type|
+        expect(breakdown).to have_key(type)
+      end
+    end
+  end
+
+  describe '#decay_awareness' do
+    it 'reduces awareness_score' do
+      before = client.awareness_score[:awareness_score]
+      client.decay_awareness
+      after = client.awareness_score[:awareness_score]
+      expect(after).to be < before
+    end
+
+    it 'accepts custom amount' do
+      result = client.decay_awareness(amount: 0.5)
+      expect(result[:decayed_by]).to eq(0.5)
+    end
+
+    it 'includes awareness_score in result' do
+      result = client.decay_awareness
+      expect(result).to have_key(:awareness_score)
+    end
+
+    it 'includes awareness_gap in result' do
+      result = client.decay_awareness
+      expect(result).to have_key(:awareness_gap)
+    end
+  end
+
+  describe '#anosognosia_status' do
+    it 'returns total_deficits' do
+      register(client)
+      result = client.anosognosia_status
+      expect(result[:total_deficits]).to eq(1)
+    end
+
+    it 'returns awareness_score' do
+      result = client.anosognosia_status
+      expect(result).to have_key(:awareness_score)
+    end
+
+    it 'returns blind_spot_count' do
+      register(client)
+      result = client.anosognosia_status
+      expect(result[:blind_spot_count]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Architecture::Client do
+  subject(:client) { described_class.new }
+
+  it 'can register a subsystem' do
+    result = client.register_architecture_subsystem(name: :test_system, subsystem_type: :cognition)
+    expect(result[:status]).to eq(:registered)
+  end
+
+  it 'maintains isolated engine state per instance' do
+    client2 = described_class.new
+    client.register_architecture_subsystem(name: :isolated_a, subsystem_type: :cognition)
+    client2.register_architecture_subsystem(name: :isolated_b, subsystem_type: :memory)
+
+    stats_a = client.cognitive_architecture_stats
+    stats_b = client2.cognitive_architecture_stats
+
+    expect(stats_a[:subsystem_count]).to eq(1)
+    expect(stats_b[:subsystem_count]).to eq(1)
+  end
+
+  it 'supports full registration + connection + activation workflow' do
+    client.register_architecture_subsystem(name: :sensor, subsystem_type: :perception)
+    client.register_architecture_subsystem(name: :processor, subsystem_type: :cognition)
+    client.create_architecture_connection(
+      source_name: :sensor, target_name: :processor, connection_type: :excitatory
+    )
+    result = client.activate_architecture_subsystem(name: :sensor)
+    expect(result[:status]).to eq(:activated)
+
+    processor_status = client.subsystem_status_report(name: :processor)
+    expect(processor_status[:activation_count]).to eq(1)
+  end
+
+  it 'reports architecture health after degradation' do
+    client.register_architecture_subsystem(name: :health_sub, subsystem_type: :safety)
+    client.degrade_architecture_subsystem(name: :health_sub)
+    report = client.architecture_health_report
+    expect(report[:health]).to be < Legion::Extensions::Agentic::Self::Architecture::Helpers::Constants::DEFAULT_HEALTH
+  end
+
+  it 'detects bottlenecks' do
+    client.register_architecture_subsystem(name: :stressed, subsystem_type: :communication)
+    sub = client.architecture_graph_report[:nodes].find { |n| n[:name] == :stressed }
+    real_sub = Object.new
+    allow(real_sub).to receive_messages(name: :stressed, status: :active, bottlenecked?: true, to_h: sub)
+    report = client.bottleneck_report
+    expect(report).to include(:bottlenecked_count, :subsystems)
+  end
+end