lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/blindspot/helpers/blindspot_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blindspot::Helpers::Blindspot do
+  subject(:blindspot) do
+    described_class.new(
+      domain:        :epistemology,
+      discovered_by: :error_analysis,
+      description:   'Failed to account for selection bias in training data',
+      severity:      0.6
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(blindspot.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores domain as symbol' do
+      expect(blindspot.domain).to eq(:epistemology)
+    end
+
+    it 'stores discovered_by as symbol' do
+      expect(blindspot.discovered_by).to eq(:error_analysis)
+    end
+
+    it 'stores description' do
+      expect(blindspot.description).to eq('Failed to account for selection bias in training data')
+    end
+
+    it 'clamps severity to 0..1' do
+      spot = described_class.new(domain: :test, discovered_by: :unknown, description: 'x', severity: 2.0)
+      expect(spot.severity).to eq(1.0)
+    end
+
+    it 'starts with status :active' do
+      expect(blindspot.status).to eq(:active)
+    end
+
+    it 'starts with created_at set' do
+      expect(blindspot.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#severity_label' do
+    it 'returns :high for severity 0.6' do
+      expect(blindspot.severity_label).to eq(:high)
+    end
+
+    it 'returns :critical for severity 0.9' do
+      spot = described_class.new(domain: :x, discovered_by: :unknown, description: 'x', severity: 0.9)
+      expect(spot.severity_label).to eq(:critical)
+    end
+
+    it 'returns :negligible for severity 0.1' do
+      spot = described_class.new(domain: :x, discovered_by: :unknown, description: 'x', severity: 0.1)
+      expect(spot.severity_label).to eq(:negligible)
+    end
+  end
+
+  describe '#active?' do
+    it 'returns true when status is :active' do
+      expect(blindspot.active?).to be true
+    end
+
+    it 'returns false after acknowledging' do
+      blindspot.acknowledge!
+      expect(blindspot.active?).to be false
+    end
+  end
+
+  describe '#acknowledged?' do
+    it 'returns false initially' do
+      expect(blindspot.acknowledged?).to be false
+    end
+
+    it 'returns true after acknowledging' do
+      blindspot.acknowledge!
+      expect(blindspot.acknowledged?).to be true
+    end
+
+    it 'returns true after mitigating' do
+      blindspot.mitigate!
+      expect(blindspot.acknowledged?).to be true
+    end
+
+    it 'returns true after resolving' do
+      blindspot.resolve!
+      expect(blindspot.acknowledged?).to be true
+    end
+  end
+
+  describe '#resolved?' do
+    it 'returns false initially' do
+      expect(blindspot.resolved?).to be false
+    end
+
+    it 'returns true after resolving' do
+      blindspot.resolve!
+      expect(blindspot.resolved?).to be true
+    end
+  end
+
+  describe '#acknowledge!' do
+    it 'sets status to :acknowledged' do
+      blindspot.acknowledge!
+      expect(blindspot.status).to eq(:acknowledged)
+    end
+
+    it 'sets acknowledged_at' do
+      blindspot.acknowledge!
+      expect(blindspot.acknowledged_at).not_to be_nil
+    end
+
+    it 'is idempotent — does not re-set acknowledged_at on second call' do
+      blindspot.acknowledge!
+      first_time = blindspot.acknowledged_at
+      blindspot.acknowledge!
+      expect(blindspot.acknowledged_at).to eq(first_time)
+    end
+
+    it 'returns self' do
+      expect(blindspot.acknowledge!).to eq(blindspot)
+    end
+  end
+
+  describe '#mitigate!' do
+    it 'sets status to :mitigated' do
+      blindspot.mitigate!
+      expect(blindspot.status).to eq(:mitigated)
+    end
+
+    it 'reduces severity by SEVERITY_BOOST' do
+      before = blindspot.severity
+      blindspot.mitigate!
+      expect(blindspot.severity).to be < before
+    end
+
+    it 'sets mitigated_at' do
+      blindspot.mitigate!
+      expect(blindspot.mitigated_at).not_to be_nil
+    end
+
+    it 'auto-acknowledges an active blindspot' do
+      blindspot.mitigate!
+      expect(blindspot.acknowledged_at).not_to be_nil
+    end
+
+    it 'returns self' do
+      expect(blindspot.mitigate!).to eq(blindspot)
+    end
+  end
+
+  describe '#resolve!' do
+    it 'sets status to :resolved' do
+      blindspot.resolve!
+      expect(blindspot.status).to eq(:resolved)
+    end
+
+    it 'sets resolved_at' do
+      blindspot.resolve!
+      expect(blindspot.resolved_at).not_to be_nil
+    end
+
+    it 'returns self' do
+      expect(blindspot.resolve!).to eq(blindspot)
+    end
+  end
+
+  describe '#boost_severity!' do
+    it 'increases severity' do
+      before = blindspot.severity
+      blindspot.boost_severity!
+      expect(blindspot.severity).to be > before
+    end
+
+    it 'clamps to 1.0' do
+      spot = described_class.new(domain: :x, discovered_by: :unknown, description: 'x', severity: 0.95)
+      spot.boost_severity!(amount: 0.2)
+      expect(spot.severity).to eq(1.0)
+    end
+
+    it 'returns self' do
+      expect(blindspot.boost_severity!).to eq(blindspot)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all required keys' do
+      h = blindspot.to_h
+      expect(h).to include(:id, :domain, :discovered_by, :description,
+                           :severity, :severity_label, :status,
+                           :active, :acknowledged, :resolved, :created_at)
+    end
+
+    it 'includes nil acknowledged_at initially' do
+      expect(blindspot.to_h[:acknowledged_at]).to be_nil
+    end
+
+    it 'includes acknowledged_at after acknowledging' do
+      blindspot.acknowledge!
+      expect(blindspot.to_h[:acknowledged_at]).not_to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blindspot/helpers/constants_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blindspot::Helpers::Constants do
+  it 'defines MAX_BLINDSPOTS' do
+    expect(described_class::MAX_BLINDSPOTS).to eq(300)
+  end
+
+  it 'defines MAX_BOUNDARIES' do
+    expect(described_class::MAX_BOUNDARIES).to eq(50)
+  end
+
+  it 'defines DEFAULT_SEVERITY' do
+    expect(described_class::DEFAULT_SEVERITY).to eq(0.5)
+  end
+
+  it 'defines SEVERITY_BOOST' do
+    expect(described_class::SEVERITY_BOOST).to eq(0.1)
+  end
+
+  it 'defines AWARENESS_THRESHOLD' do
+    expect(described_class::AWARENESS_THRESHOLD).to eq(0.6)
+  end
+
+  it 'defines DISCOVERY_METHODS as a frozen array with 8 entries' do
+    expect(described_class::DISCOVERY_METHODS).to be_frozen
+    expect(described_class::DISCOVERY_METHODS.size).to eq(8)
+    expect(described_class::DISCOVERY_METHODS).to include(:error_analysis, :peer_feedback, :unknown)
+  end
+
+  it 'defines SEVERITY_LABELS for full range' do
+    expect(described_class::SEVERITY_LABELS.size).to eq(5)
+  end
+
+  it 'defines AWARENESS_LABELS for full range' do
+    expect(described_class::AWARENESS_LABELS.size).to eq(5)
+  end
+
+  it 'defines COVERAGE_LABELS for full range' do
+    expect(described_class::COVERAGE_LABELS.size).to eq(5)
+  end
+
+  it 'defines STATUS_LABELS for all statuses' do
+    expect(described_class::STATUS_LABELS).to include(:active, :acknowledged, :mitigated, :resolved)
+  end
+
+  describe '.label_for' do
+    it 'returns the correct label for a value in range' do
+      label = described_class.label_for(described_class::SEVERITY_LABELS, 0.9)
+      expect(label).to eq(:critical)
+    end
+
+    it 'returns :high for 0.7' do
+      label = described_class.label_for(described_class::SEVERITY_LABELS, 0.7)
+      expect(label).to eq(:high)
+    end
+
+    it 'returns :moderate for 0.5' do
+      label = described_class.label_for(described_class::SEVERITY_LABELS, 0.5)
+      expect(label).to eq(:moderate)
+    end
+
+    it 'returns :negligible for 0.1' do
+      label = described_class.label_for(described_class::SEVERITY_LABELS, 0.1)
+      expect(label).to eq(:negligible)
+    end
+
+    it 'returns nil for a value with no matching range' do
+      label = described_class.label_for({}, 0.5)
+      expect(label).to be_nil
+    end
+
+    it 'returns correct awareness label' do
+      label = described_class.label_for(described_class::AWARENESS_LABELS, 0.85)
+      expect(label).to eq(:highly_aware)
+    end
+
+    it 'returns correct coverage label' do
+      label = described_class.label_for(described_class::COVERAGE_LABELS, 0.3)
+      expect(label).to eq(:limited)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blindspot/helpers/knowledge_boundary_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blindspot::Helpers::KnowledgeBoundary do
+  subject(:boundary) do
+    described_class.new(domain: :physics, confidence: 0.7, coverage_estimate: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(boundary.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores domain as symbol' do
+      expect(boundary.domain).to eq(:physics)
+    end
+
+    it 'clamps confidence to 0..1' do
+      b = described_class.new(domain: :x, confidence: 1.5)
+      expect(b.confidence).to eq(1.0)
+    end
+
+    it 'clamps coverage_estimate to 0..1' do
+      b = described_class.new(domain: :x, coverage_estimate: -0.5)
+      expect(b.coverage_estimate).to eq(0.0)
+    end
+
+    it 'sets created_at' do
+      expect(boundary.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#coverage_label' do
+    it 'returns :partial for coverage 0.5' do
+      expect(boundary.coverage_label).to eq(:partial)
+    end
+
+    it 'returns :comprehensive for coverage 0.9' do
+      b = described_class.new(domain: :x, coverage_estimate: 0.9)
+      expect(b.coverage_label).to eq(:comprehensive)
+    end
+
+    it 'returns :minimal for coverage 0.1' do
+      b = described_class.new(domain: :x, coverage_estimate: 0.1)
+      expect(b.coverage_label).to eq(:minimal)
+    end
+  end
+
+  describe '#gap_detected?' do
+    it 'returns false when no error occurred' do
+      expect(boundary.gap_detected?(error_occurred: false)).to be false
+    end
+
+    it 'returns true when error occurred and confidence is above threshold' do
+      expect(boundary.gap_detected?(error_occurred: true)).to be true
+    end
+
+    it 'returns false when error occurred but confidence is below threshold' do
+      b = described_class.new(domain: :x, confidence: 0.4)
+      expect(b.gap_detected?(error_occurred: true)).to be false
+    end
+  end
+
+  describe '#update_confidence!' do
+    it 'updates confidence value' do
+      boundary.update_confidence!(0.3)
+      expect(boundary.confidence).to eq(0.3)
+    end
+
+    it 'updates updated_at' do
+      original = boundary.updated_at
+      sleep(0.001)
+      boundary.update_confidence!(0.9)
+      expect(boundary.updated_at).to be >= original
+    end
+
+    it 'returns self' do
+      expect(boundary.update_confidence!(0.5)).to eq(boundary)
+    end
+  end
+
+  describe '#update_coverage!' do
+    it 'updates coverage_estimate' do
+      boundary.update_coverage!(0.8)
+      expect(boundary.coverage_estimate).to eq(0.8)
+    end
+
+    it 'returns self' do
+      expect(boundary.update_coverage!(0.5)).to eq(boundary)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all required keys' do
+      h = boundary.to_h
+      expect(h).to include(:id, :domain, :confidence, :coverage_estimate,
+                           :coverage_label, :created_at, :updated_at)
+    end
+
+    it 'reflects current confidence' do
+      boundary.update_confidence!(0.2)
+      expect(boundary.to_h[:confidence]).to eq(0.2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blindspot/runners/cognitive_blindspot_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blindspot::Runners::CognitiveBlindspot do
+  subject(:runner) do
+    Class.new do
+      include Legion::Extensions::Agentic::Attention::Blindspot::Runners::CognitiveBlindspot
+
+      def engine
+        @engine ||= Legion::Extensions::Agentic::Attention::Blindspot::Helpers::BlindspotEngine.new
+      end
+    end.new
+  end
+
+  let(:created) do
+    runner.register_blindspot(
+      domain:        :reasoning,
+      discovered_by: :error_analysis,
+      description:   'Over-reliance on recent examples'
+    )
+  end
+
+  describe '#register_blindspot' do
+    it 'returns success: true' do
+      expect(created[:success]).to be true
+    end
+
+    it 'returns blindspot fields' do
+      expect(created).to include(:id, :domain, :severity, :status)
+    end
+
+    it 'uses DEFAULT_SEVERITY when severity not provided' do
+      expect(created[:severity]).to eq(0.5)
+    end
+
+    it 'accepts explicit severity' do
+      result = runner.register_blindspot(domain: :x, discovered_by: :unknown,
+                                         description: 'test', severity: 0.8)
+      expect(result[:severity]).to eq(0.8)
+    end
+  end
+
+  describe '#acknowledge_blindspot' do
+    it 'acknowledges a known blindspot' do
+      result = runner.acknowledge_blindspot(blindspot_id: created[:id])
+      expect(result[:success]).to be true
+      expect(result[:status]).to eq(:acknowledged)
+    end
+
+    it 'returns success: false for unknown id' do
+      result = runner.acknowledge_blindspot(blindspot_id: 'bad-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq('blindspot not found')
+    end
+  end
+
+  describe '#mitigate_blindspot' do
+    it 'mitigates a known blindspot' do
+      result = runner.mitigate_blindspot(blindspot_id: created[:id])
+      expect(result[:success]).to be true
+      expect(result[:status]).to eq(:mitigated)
+    end
+
+    it 'returns success: false for unknown id' do
+      result = runner.mitigate_blindspot(blindspot_id: 'bad-id')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#resolve_blindspot' do
+    it 'resolves a known blindspot' do
+      result = runner.resolve_blindspot(blindspot_id: created[:id])
+      expect(result[:success]).to be true
+      expect(result[:status]).to eq(:resolved)
+    end
+
+    it 'returns success: false for unknown id' do
+      result = runner.resolve_blindspot(blindspot_id: 'bad-id')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#set_knowledge_boundary' do
+    it 'returns success: true' do
+      result = runner.set_knowledge_boundary(domain: :math, confidence: 0.7, coverage_estimate: 0.5)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns boundary fields' do
+      result = runner.set_knowledge_boundary(domain: :science)
+      expect(result).to include(:id, :domain, :confidence, :coverage_estimate)
+    end
+  end
+
+  describe '#detect_boundary_gap' do
+    it 'returns success: true' do
+      result = runner.detect_boundary_gap(domain: :math)
+      expect(result[:success]).to be true
+    end
+
+    it 'detects gap when high confidence + error occurred' do
+      runner.set_knowledge_boundary(domain: :math, confidence: 0.8)
+      result = runner.detect_boundary_gap(domain: :math, error_occurred: true)
+      expect(result[:gap_detected]).to be true
+    end
+  end
+
+  describe '#active_blindspots_report' do
+    it 'returns count and list of active blindspots' do
+      created
+      result = runner.active_blindspots_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:blindspots]).to be_an(Array)
+    end
+  end
+
+  describe '#most_severe_report' do
+    it 'returns list sorted by severity' do
+      created
+      result = runner.most_severe_report(limit: 3)
+      expect(result[:success]).to be true
+      expect(result[:limit]).to eq(3)
+      expect(result[:blindspots]).to be_an(Array)
+    end
+  end
+
+  describe '#mitigation_strategies_report' do
+    it 'returns strategies' do
+      created
+      result = runner.mitigation_strategies_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'accepts domain filter' do
+      created
+      result = runner.mitigation_strategies_report(domain: :reasoning)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#coverage_report' do
+    it 'returns empty when no boundaries' do
+      result = runner.coverage_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns boundaries after setting one' do
+      runner.set_knowledge_boundary(domain: :logic)
+      result = runner.coverage_report
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#johari_report' do
+    it 'returns comprehensive johari window report' do
+      created
+      report = runner.johari_report
+      expect(report).to include(:total_blindspots, :active, :acknowledged,
+                                :resolved, :awareness_score, :awareness_label)
+    end
+  end
+
+  describe '#awareness_score_report' do
+    it 'returns awareness metrics' do
+      result = runner.awareness_score_report
+      expect(result[:success]).to be true
+      expect(result).to include(:awareness_score, :awareness_label, :awareness_gap)
+    end
+  end
+
+  describe '#blindspot_stats' do
+    it 'returns summary stats hash' do
+      result = runner.blindspot_stats
+      expect(result).to include(:total_blindspots, :awareness_score)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blink/client_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blink::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes the runner module' do
+    expect(client).to respond_to(:submit_stimulus)
+  end
+
+  it 'provides an engine' do
+    expect(client.engine).to be_a(Legion::Extensions::Agentic::Attention::Blink::Helpers::BlinkEngine)
+  end
+
+  it 'submits and processes stimuli' do
+    result = client.submit_stimulus(stimulus_type: :auditory, content: 'beep')
+    expect(result[:success]).to be true
+  end
+end