lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/anchor/helpers/chain_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Helpers::Chain do
+  subject(:chain) { described_class.new(anchor_id: 'a-123') }
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(chain.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores anchor_id' do
+      expect(chain.anchor_id).to eq('a-123')
+    end
+
+    it 'defaults material to :steel' do
+      expect(chain.material).to eq(:steel)
+    end
+
+    it 'defaults length to 0.5' do
+      expect(chain.length).to eq(0.5)
+    end
+
+    it 'sets flexibility based on material' do
+      steel = described_class.new(anchor_id: 'x', material: :steel)
+      thread = described_class.new(anchor_id: 'x', material: :thread)
+      expect(thread.flexibility).to be > steel.flexibility
+    end
+
+    it 'raises on unknown material' do
+      expect do
+        described_class.new(anchor_id: 'x', material: :diamond)
+      end.to raise_error(ArgumentError, /unknown material/)
+    end
+  end
+
+  describe '#extend!' do
+    it 'increases length' do
+      initial = chain.length
+      chain.extend!(amount: 0.1)
+      expect(chain.length).to eq((initial + 0.1).round(10))
+    end
+  end
+
+  describe '#shorten!' do
+    it 'decreases length' do
+      initial = chain.length
+      chain.shorten!(amount: 0.1)
+      expect(chain.length).to eq((initial - 0.1).round(10))
+    end
+  end
+
+  describe '#wear!' do
+    it 'decreases flexibility' do
+      initial = chain.flexibility
+      chain.wear!
+      expect(chain.flexibility).to be < initial
+    end
+  end
+
+  describe '#broken?' do
+    it 'returns false initially' do
+      expect(chain).not_to be_broken
+    end
+
+    it 'returns true when flexibility below threshold' do
+      chain.flexibility = 0.05
+      expect(chain).to be_broken
+    end
+  end
+
+  describe '#elastic?' do
+    it 'returns false for steel' do
+      expect(chain).not_to be_elastic
+    end
+
+    it 'returns true for cobweb' do
+      c = described_class.new(anchor_id: 'x', material: :cobweb)
+      expect(c).to be_elastic
+    end
+  end
+
+  describe '#short?' do
+    it 'returns false at default' do
+      expect(chain).not_to be_short
+    end
+
+    it 'returns true below 0.3' do
+      chain.length = 0.2
+      expect(chain).to be_short
+    end
+  end
+
+  describe '#flexibility_label' do
+    it 'returns a symbol' do
+      expect(chain.flexibility_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      expected = %i[id anchor_id material length flexibility
+                    flexibility_label broken elastic created_at]
+      expect(chain.to_h.keys).to match_array(expected)
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Helpers::Constants do
+  described_class = Legion::Extensions::Agentic::Self::Anchor::Helpers::Constants
+
+  describe 'ANCHOR_TYPES' do
+    it 'contains expected types' do
+      expect(described_class::ANCHOR_TYPES).to eq(%i[belief assumption experience authority number])
+    end
+
+    it 'is frozen' do
+      expect(described_class::ANCHOR_TYPES).to be_frozen
+    end
+  end
+
+  describe 'CHAIN_MATERIALS' do
+    it 'contains expected materials' do
+      expect(described_class::CHAIN_MATERIALS).to eq(%i[steel rope wire thread cobweb])
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'defines MAX_ANCHORS' do
+      expect(described_class::MAX_ANCHORS).to eq(200)
+    end
+
+    it 'defines DRAG_RATE' do
+      expect(described_class::DRAG_RATE).to eq(0.06)
+    end
+
+    it 'defines BREAK_THRESHOLD' do
+      expect(described_class::BREAK_THRESHOLD).to eq(0.1)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns :ironclad for high grip' do
+      expect(described_class.label_for(described_class::GRIP_LABELS, 0.9)).to eq(:ironclad)
+    end
+
+    it 'returns :drifting for low grip' do
+      expect(described_class.label_for(described_class::GRIP_LABELS, 0.1)).to eq(:drifting)
+    end
+
+    it 'returns :elastic for high flexibility' do
+      expect(described_class.label_for(described_class::FLEXIBILITY_LABELS, 0.9)).to eq(:elastic)
+    end
+
+    it 'returns :brittle for low flexibility' do
+      expect(described_class.label_for(described_class::FLEXIBILITY_LABELS, 0.1)).to eq(:brittle)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/anchor/runners/cognitive_anchor_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Runners::CognitiveAnchor do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:engine) { Legion::Extensions::Agentic::Self::Anchor::Helpers::AnchorEngine.new }
+
+  describe '#create_anchor' do
+    it 'returns success' do
+      result = runner.create_anchor(anchor_type: :belief, domain: :reasoning,
+                                    content: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:anchor][:anchor_type]).to eq(:belief)
+    end
+
+    it 'returns failure for invalid type' do
+      result = runner.create_anchor(anchor_type: :magic, domain: :t,
+                                    content: 'x', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_chain' do
+    it 'returns success' do
+      a = engine.create_anchor(anchor_type: :belief, domain: :t, content: 'x')
+      result = runner.create_chain(anchor_id: a.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:chain]).to be_a(Hash)
+    end
+  end
+
+  describe '#apply_bias' do
+    it 'returns bias result' do
+      a = engine.create_anchor(anchor_type: :number, domain: :t, content: 'x',
+                               reference_value: 0.3, grip: 0.8)
+      result = runner.apply_bias(anchor_id: a.id, new_value: 0.9, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:biased]).to be < 0.9
+    end
+  end
+
+  describe '#list_anchors' do
+    before do
+      engine.create_anchor(anchor_type: :belief, domain: :t, content: 'a')
+      engine.create_anchor(anchor_type: :number, domain: :t, content: 'b')
+    end
+
+    it 'returns all anchors' do
+      result = runner.list_anchors(engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by type' do
+      result = runner.list_anchors(anchor_type: :belief, engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#anchor_status' do
+    it 'returns report' do
+      result = runner.anchor_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_anchors)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Self::Anosognosia::VERSION).not_to be_nil
+  end
+
+  it 'has a version that is a string' do
+    expect(Legion::Extensions::Agentic::Self::Anosognosia::VERSION).to be_a(String)
+  end
+
+  it 'has the correct version' do
+    expect(Legion::Extensions::Agentic::Self::Anosognosia::VERSION).to eq('0.1.0')
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/anosognosia/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to register_deficit' do
+    expect(client).to respond_to(:register_deficit)
+  end
+
+  it 'responds to acknowledge_deficit' do
+    expect(client).to respond_to(:acknowledge_deficit)
+  end
+
+  it 'responds to reveal_blind_spot' do
+    expect(client).to respond_to(:reveal_blind_spot)
+  end
+
+  it 'responds to awareness_score' do
+    expect(client).to respond_to(:awareness_score)
+  end
+
+  it 'responds to awareness_gap' do
+    expect(client).to respond_to(:awareness_gap)
+  end
+
+  it 'responds to blind_spots' do
+    expect(client).to respond_to(:blind_spots)
+  end
+
+  it 'responds to calibration_report' do
+    expect(client).to respond_to(:calibration_report)
+  end
+
+  it 'responds to decay_awareness' do
+    expect(client).to respond_to(:decay_awareness)
+  end
+
+  it 'responds to anosognosia_status' do
+    expect(client).to respond_to(:anosognosia_status)
+  end
+
+  it 'maintains isolated state per instance' do
+    client_a = described_class.new
+    client_b = described_class.new
+    client_a.register_deficit(domain: :a, deficit_type: :knowledge, severity: 0.5)
+    expect(client_b.anosognosia_status[:total_deficits]).to eq(0)
+  end
+end

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

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anosognosia::Helpers::AnosognosiaEngine do
+  subject(:engine) { described_class.new }
+
+  def register_deficit(engine, domain: :language, deficit_type: :knowledge, severity: 0.6, acknowledged: false)
+    engine.register_deficit(domain: domain, deficit_type: deficit_type, severity: severity, acknowledged: acknowledged)
+  end
+
+  describe '#initialize' do
+    it 'starts with empty deficits' do
+      expect(engine.deficits).to be_empty
+    end
+
+    it 'starts with awareness_score of 1.0' do
+      expect(engine.awareness_score).to eq(1.0)
+    end
+  end
+
+  describe '#register_deficit' do
+    it 'adds a deficit to the store' do
+      register_deficit(engine)
+      expect(engine.deficits.size).to eq(1)
+    end
+
+    it 'returns a CognitiveDeficit instance' do
+      result = register_deficit(engine)
+      expect(result).to be_a(Legion::Extensions::Agentic::Self::Anosognosia::Helpers::CognitiveDeficit)
+    end
+
+    it 'stores deficit by id' do
+      deficit = register_deficit(engine)
+      expect(engine.deficits[deficit.id]).to eq(deficit)
+    end
+
+    it 'registers acknowledged deficit' do
+      deficit = register_deficit(engine, acknowledged: true)
+      expect(deficit.acknowledged).to be true
+    end
+
+    it 'registers multiple deficits' do
+      3.times { |i| register_deficit(engine, domain: :"domain_#{i}") }
+      expect(engine.deficits.size).to eq(3)
+    end
+  end
+
+  describe '#acknowledge_deficit' do
+    let(:deficit) { register_deficit(engine) }
+
+    it 'returns found: false for unknown deficit' do
+      result = engine.acknowledge_deficit(deficit_id: 'unknown-id')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true for known deficit' do
+      result = engine.acknowledge_deficit(deficit_id: deficit.id)
+      expect(result[:found]).to be true
+    end
+
+    it 'sets changed: true when first acknowledging' do
+      result = engine.acknowledge_deficit(deficit_id: deficit.id)
+      expect(result[:changed]).to be true
+    end
+
+    it 'sets changed: false when already acknowledged' do
+      engine.acknowledge_deficit(deficit_id: deficit.id)
+      result = engine.acknowledge_deficit(deficit_id: deficit.id)
+      expect(result[:changed]).to be false
+    end
+
+    it 'recalculates awareness_score after acknowledgement' do
+      register_deficit(engine, domain: :a)
+      d2 = register_deficit(engine, domain: :b)
+      engine.acknowledge_deficit(deficit_id: d2.id)
+      expect(engine.awareness_score).to be > 0.0
+    end
+
+    it 'includes updated awareness_score in result' do
+      result = engine.acknowledge_deficit(deficit_id: deficit.id)
+      expect(result).to have_key(:awareness_score)
+    end
+  end
+
+  describe '#reveal_blind_spot' do
+    let(:deficit) { register_deficit(engine) }
+
+    it 'returns found: false for unknown deficit' do
+      result = engine.reveal_blind_spot(deficit_id: 'unknown-id')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns already_known: true if already acknowledged' do
+      engine.acknowledge_deficit(deficit_id: deficit.id)
+      result = engine.reveal_blind_spot(deficit_id: deficit.id)
+      expect(result[:already_known]).to be true
+    end
+
+    it 'acknowledges the deficit' do
+      engine.reveal_blind_spot(deficit_id: deficit.id)
+      expect(engine.deficits[deficit.id].acknowledged).to be true
+    end
+
+    it 'boosts awareness_score above its pre-reveal value' do
+      register_deficit(engine, domain: :a)
+      register_deficit(engine, domain: :b)
+      blind = register_deficit(engine, domain: :c)
+      # decay so we have room to boost
+      engine.decay_awareness(amount: 0.5)
+      before = engine.awareness_score
+      engine.reveal_blind_spot(deficit_id: blind.id)
+      expect(engine.awareness_score).to be > before
+    end
+
+    it 'includes awareness_label in result' do
+      result = engine.reveal_blind_spot(deficit_id: deficit.id)
+      expect(result).to have_key(:awareness_label)
+    end
+
+    it 'returns found: true, already_known: false for blind spot' do
+      result = engine.reveal_blind_spot(deficit_id: deficit.id)
+      expect(result[:found]).to be true
+      expect(result[:already_known]).to be false
+    end
+  end
+
+  describe '#awareness_gap' do
+    it 'returns 0.0 when no deficits' do
+      expect(engine.awareness_gap).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all deficits are blind spots' do
+      register_deficit(engine)
+      # Single unacknowledged deficit: awareness_score recalc not called, stays 1.0
+      # but gap = 1 - score. After adding unacknowledged deficit and recalculating:
+      engine.send(:recalculate_awareness)
+      expect(engine.awareness_gap).to be > 0.0
+    end
+
+    it 'is complement of awareness_score' do
+      register_deficit(engine)
+      engine.send(:recalculate_awareness)
+      expect((engine.awareness_score + engine.awareness_gap).round(10)).to eq(1.0)
+    end
+  end
+
+  describe '#blind_spots' do
+    it 'returns empty array when no deficits' do
+      expect(engine.blind_spots).to be_empty
+    end
+
+    it 'returns unacknowledged deficits' do
+      d1 = register_deficit(engine, domain: :a)
+      d2 = register_deficit(engine, domain: :b)
+      engine.acknowledge_deficit(deficit_id: d1.id)
+      spots = engine.blind_spots
+      expect(spots.map(&:id)).to contain_exactly(d2.id)
+    end
+
+    it 'returns all deficits when none acknowledged' do
+      2.times { |i| register_deficit(engine, domain: :"d#{i}") }
+      expect(engine.blind_spots.size).to eq(2)
+    end
+  end
+
+  describe '#calibration_report' do
+    before do
+      d1 = register_deficit(engine, domain: :a)
+      register_deficit(engine, domain: :b)
+      engine.acknowledge_deficit(deficit_id: d1.id)
+    end
+
+    let(:report) { engine.calibration_report }
+
+    it 'includes total_deficits' do
+      expect(report[:total_deficits]).to eq(2)
+    end
+
+    it 'includes acknowledged_deficits count' do
+      expect(report[:acknowledged_deficits]).to eq(1)
+    end
+
+    it 'includes unacknowledged_deficits count' do
+      expect(report[:unacknowledged_deficits]).to eq(1)
+    end
+
+    it 'includes awareness_score' do
+      expect(report).to have_key(:awareness_score)
+    end
+
+    it 'includes awareness_gap' do
+      expect(report).to have_key(:awareness_gap)
+    end
+
+    it 'includes awareness_label' do
+      expect(report).to have_key(:awareness_label)
+    end
+
+    it 'includes blind_spots array' do
+      expect(report[:blind_spots]).to be_an(Array)
+      expect(report[:blind_spots].size).to eq(1)
+    end
+
+    it 'includes deficit_breakdown' do
+      expect(report[:deficit_breakdown]).to be_a(Hash)
+      expect(report[:deficit_breakdown]).to have_key(:knowledge)
+    end
+  end
+
+  describe '#decay_awareness' do
+    it 'decrements awareness_score by AWARENESS_DECAY by default' do
+      before = engine.awareness_score
+      engine.decay_awareness
+      expect(engine.awareness_score).to be < before
+    end
+
+    it 'decrements by custom amount' do
+      engine.decay_awareness(amount: 0.3)
+      expect(engine.awareness_score).to eq(0.7)
+    end
+
+    it 'clamps at 0.0' do
+      engine.decay_awareness(amount: 2.0)
+      expect(engine.awareness_score).to eq(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    before { register_deficit(engine) }
+
+    let(:h) { engine.to_h }
+
+    it 'includes deficits hash' do
+      expect(h[:deficits]).to be_a(Hash)
+    end
+
+    it 'includes awareness_score' do
+      expect(h).to have_key(:awareness_score)
+    end
+
+    it 'includes awareness_gap' do
+      expect(h).to have_key(:awareness_gap)
+    end
+
+    it 'includes awareness_label' do
+      expect(h).to have_key(:awareness_label)
+    end
+
+    it 'includes total_deficits' do
+      expect(h[:total_deficits]).to eq(1)
+    end
+
+    it 'includes blind_spot_count' do
+      expect(h).to have_key(:blind_spot_count)
+    end
+  end
+
+  describe 'capacity management' do
+    it 'prunes oldest unacknowledged when at MAX_DEFICITS' do
+      stub_const('Legion::Extensions::Agentic::Self::Anosognosia::Helpers::Constants::MAX_DEFICITS', 3)
+      3.times { |i| register_deficit(engine, domain: :"d#{i}") }
+      expect(engine.deficits.size).to eq(3)
+      register_deficit(engine, domain: :overflow)
+      expect(engine.deficits.size).to eq(3)
+    end
+  end
+end