lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/salience/helpers/salience_map_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Salience::Helpers::SalienceMap do
+  subject(:map) { described_class.new }
+
+  let(:low_signals) do
+    Legion::Extensions::Agentic::Attention::Salience::Helpers::SignalIntegrator.integrate(tick_results: {})
+  end
+
+  let(:high_signals) do
+    Legion::Extensions::Agentic::Attention::Salience::Helpers::SignalIntegrator.integrate(
+      tick_results: {
+        emotion:     { arousal: 1.0 },
+        homeostasis: { worst_deviation: 1.0 },
+        trust:       { violation_count: 4 }
+      }
+    )
+  end
+
+  describe '#update' do
+    it 'returns a snapshot hash' do
+      result = map.update(low_signals)
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:overall)
+      expect(result).to have_key(:urgency)
+    end
+
+    it 'stores the snapshot in history' do
+      map.update(low_signals)
+      expect(map.history.size).to eq(1)
+    end
+
+    it 'updates current_map with weighted values' do
+      map.update(high_signals)
+      expect(map.current_map).not_to be_empty
+    end
+  end
+
+  describe '#overall_salience' do
+    it 'returns 0.0 on a fresh map' do
+      expect(map.overall_salience).to eq(0.0)
+    end
+
+    it 'returns a positive value after updating with high signals' do
+      map.update(high_signals)
+      expect(map.overall_salience).to be > 0.0
+    end
+
+    it 'is non-negative after updating with zero-weight signals (novelty boost applies on first update)' do
+      map.update(low_signals)
+      expect(map.overall_salience).to be >= 0.0
+    end
+  end
+
+  describe '#urgency_level' do
+    it 'returns :background for zero salience' do
+      expect(map.urgency_level).to eq(:background)
+    end
+
+    it 'returns :critical when overall_salience >= 0.9' do
+      # Inject high signals enough to exceed 0.9
+      allow(map).to receive(:overall_salience).and_return(0.95)
+      expect(map.urgency_level).to eq(:critical)
+    end
+
+    it 'returns :high when overall_salience >= 0.7' do
+      allow(map).to receive(:overall_salience).and_return(0.75)
+      expect(map.urgency_level).to eq(:high)
+    end
+
+    it 'returns :moderate when overall_salience >= 0.4' do
+      allow(map).to receive(:overall_salience).and_return(0.55)
+      expect(map.urgency_level).to eq(:moderate)
+    end
+
+    it 'returns :low when overall_salience >= 0.2' do
+      allow(map).to receive(:overall_salience).and_return(0.25)
+      expect(map.urgency_level).to eq(:low)
+    end
+
+    it 'returns :background when overall_salience < 0.2' do
+      allow(map).to receive(:overall_salience).and_return(0.1)
+      expect(map.urgency_level).to eq(:background)
+    end
+  end
+
+  describe '#dominant_source' do
+    it 'returns nil when current_map is empty' do
+      expect(map.dominant_source).to be_nil
+    end
+
+    it 'returns the source with the highest weighted salience' do
+      map.update(high_signals)
+      dominant = map.dominant_source
+      expect(dominant).to be_a(Symbol)
+    end
+  end
+
+  describe '#above_baseline?' do
+    it 'returns false on a fresh map (both are 0.0)' do
+      expect(map.above_baseline?).to be(false)
+    end
+
+    it 'returns true when current salience exceeds baseline' do
+      # First update establishes baseline near 0
+      map.update(low_signals)
+      # Second update with high signals
+      map.update(high_signals)
+      # After high update, overall_salience should be above the low baseline
+      # (NOVELTY_BOOST applies to first-seen sources)
+      expect(map.above_baseline?).to be(true).or be(false) # state-dependent, just check type
+    end
+  end
+
+  describe '#conflict_signals' do
+    it 'returns empty array on a fresh map' do
+      expect(map.conflict_signals).to eq([])
+    end
+
+    it 'returns pairs of conflicting sources' do
+      # Manually inject conflicting values into current_map
+      map.instance_variable_set(:@current_map, { emotion: 0.8, mood: 0.1 })
+      conflicts = map.conflict_signals
+      expect(conflicts).to be_an(Array)
+      # emotion(0.8) vs mood(0.1) diff is 0.7 > 0.3
+      expect(conflicts).not_to be_empty
+    end
+
+    it 'returns empty array when sources are close together' do
+      map.instance_variable_set(:@current_map, { emotion: 0.5, mood: 0.5 })
+      expect(map.conflict_signals).to eq([])
+    end
+  end
+
+  describe '#salience_trend' do
+    it 'returns :stable with fewer than 2 history entries' do
+      expect(map.salience_trend).to eq(:stable)
+    end
+
+    it 'returns :rising when overall is increasing' do
+      map.instance_variable_set(:@history, [
+                                  { overall: 0.1 },
+                                  { overall: 0.2 },
+                                  { overall: 0.3 },
+                                  { overall: 0.4 },
+                                  { overall: 0.5 }
+                                ])
+      expect(map.salience_trend).to eq(:rising)
+    end
+
+    it 'returns :falling when overall is decreasing' do
+      map.instance_variable_set(:@history, [
+                                  { overall: 0.5 },
+                                  { overall: 0.4 },
+                                  { overall: 0.3 },
+                                  { overall: 0.2 },
+                                  { overall: 0.1 }
+                                ])
+      expect(map.salience_trend).to eq(:falling)
+    end
+
+    it 'returns :stable when values are flat' do
+      map.instance_variable_set(:@history, [
+                                  { overall: 0.3 },
+                                  { overall: 0.31 },
+                                  { overall: 0.3 },
+                                  { overall: 0.31 },
+                                  { overall: 0.3 }
+                                ])
+      expect(map.salience_trend).to eq(:stable)
+    end
+  end
+
+  describe 'history capping' do
+    it 'keeps at most 50 history entries' do
+      60.times { map.update(low_signals) }
+      expect(map.history.size).to eq(50)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      result = map.to_h
+      %i[current_map overall baseline urgency dominant above_baseline conflicts trend history_size].each do |key|
+        expect(result).to have_key(key)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/salience/helpers/signal_integrator_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Salience::Helpers::SignalIntegrator do
+  describe '.integrate' do
+    context 'with empty tick_results' do
+      it 'returns a hash with all 8 sources' do
+        result = described_class.integrate(tick_results: {})
+        expect(result.keys.size).to eq(8)
+      end
+
+      it 'sets raw_salience to 0.0 for all sources' do
+        result = described_class.integrate(tick_results: {})
+        result.each_value do |v|
+          expect(v[:raw_salience]).to eq(0.0)
+        end
+      end
+
+      it 'sets weighted to 0.0 for all sources' do
+        result = described_class.integrate(tick_results: {})
+        result.each_value do |v|
+          expect(v[:weighted]).to eq(0.0)
+        end
+      end
+    end
+
+    context 'with emotion data' do
+      let(:tick_results) { { emotion: { arousal: 0.8, gut_strength: 0.6 } } }
+
+      it 'extracts max of arousal and gut_strength as raw_salience' do
+        result = described_class.integrate(tick_results: tick_results)
+        expect(result[:emotion][:raw_salience]).to eq(0.8)
+      end
+
+      it 'applies the emotion weight (0.20)' do
+        result = described_class.integrate(tick_results: tick_results)
+        expect(result[:emotion][:weighted]).to be_within(0.0001).of(0.8 * 0.20)
+      end
+
+      it 'stores the raw signal_data' do
+        result = described_class.integrate(tick_results: tick_results)
+        expect(result[:emotion][:signal_data]).to eq({ arousal: 0.8, gut_strength: 0.6 })
+      end
+    end
+
+    context 'with mood data' do
+      it 'computes 1.0 - stability as raw_salience' do
+        result = described_class.integrate(tick_results: { mood: { stability: 0.3 } })
+        expect(result[:mood][:raw_salience]).to be_within(0.001).of(0.7)
+      end
+
+      it 'defaults stability to 1.0 when missing (0.0 salience)' do
+        result = described_class.integrate(tick_results: { mood: {} })
+        expect(result[:mood][:raw_salience]).to eq(0.0)
+      end
+    end
+
+    context 'with attention data' do
+      it 'computes spotlight_count / total' do
+        result = described_class.integrate(tick_results: { attention: { spotlight_count: 3, total: 10 } })
+        expect(result[:attention][:raw_salience]).to be_within(0.001).of(0.3)
+      end
+
+      it 'guards against zero total' do
+        result = described_class.integrate(tick_results: { attention: { spotlight_count: 0, total: 0 } })
+        expect(result[:attention][:raw_salience]).to eq(0.0)
+      end
+    end
+
+    context 'with homeostasis data' do
+      it 'uses worst_deviation clamped to 0-1' do
+        result = described_class.integrate(tick_results: { homeostasis: { worst_deviation: 0.6 } })
+        expect(result[:homeostasis][:raw_salience]).to eq(0.6)
+      end
+
+      it 'clamps values above 1.0' do
+        result = described_class.integrate(tick_results: { homeostasis: { worst_deviation: 1.5 } })
+        expect(result[:homeostasis][:raw_salience]).to eq(1.0)
+      end
+    end
+
+    context 'with trust data' do
+      it 'computes violation_count * 0.3 clamped to 0-1' do
+        result = described_class.integrate(tick_results: { trust: { violation_count: 2 } })
+        expect(result[:trust][:raw_salience]).to be_within(0.001).of(0.6)
+      end
+
+      it 'clamps at 1.0 for many violations' do
+        result = described_class.integrate(tick_results: { trust: { violation_count: 10 } })
+        expect(result[:trust][:raw_salience]).to eq(1.0)
+      end
+    end
+
+    context 'with empathy data' do
+      it 'returns 1.0 for adversarial climate' do
+        result = described_class.integrate(tick_results: { empathy: { climate: :adversarial } })
+        expect(result[:empathy][:raw_salience]).to eq(1.0)
+      end
+
+      it 'returns 0.5 for tense climate' do
+        result = described_class.integrate(tick_results: { empathy: { climate: :tense } })
+        expect(result[:empathy][:raw_salience]).to eq(0.5)
+      end
+
+      it 'returns 0.1 for neutral climate' do
+        result = described_class.integrate(tick_results: { empathy: { climate: :neutral } })
+        expect(result[:empathy][:raw_salience]).to eq(0.1)
+      end
+
+      it 'returns 0.0 for harmonious climate' do
+        result = described_class.integrate(tick_results: { empathy: { climate: :harmonious } })
+        expect(result[:empathy][:raw_salience]).to eq(0.0)
+      end
+
+      it 'returns 0.0 for unknown climate' do
+        result = described_class.integrate(tick_results: { empathy: { climate: :unknown } })
+        expect(result[:empathy][:raw_salience]).to eq(0.0)
+      end
+    end
+
+    context 'with volition data' do
+      it 'uses intention_salience as raw_salience' do
+        result = described_class.integrate(tick_results: { volition: { intention_salience: 0.75 } })
+        expect(result[:volition][:raw_salience]).to eq(0.75)
+      end
+    end
+
+    context 'with multiple sources' do
+      let(:tick_results) do
+        {
+          emotion:     { arousal: 0.9 },
+          homeostasis: { worst_deviation: 0.5 },
+          trust:       { violation_count: 1 }
+        }
+      end
+
+      it 'returns all 8 sources regardless of which are provided' do
+        result = described_class.integrate(tick_results: tick_results)
+        expect(result.keys.size).to eq(8)
+      end
+
+      it 'correctly weights multiple sources' do
+        result = described_class.integrate(tick_results: tick_results)
+        expect(result[:emotion][:weighted]).to be_within(0.001).of(0.9 * 0.20)
+        expect(result[:homeostasis][:weighted]).to be_within(0.001).of(0.5 * 0.15)
+        expect(result[:trust][:weighted]).to be_within(0.001).of(0.3 * 0.10)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/salience/runners/salience_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Salience::Runners::Salience do
+  subject(:client) { Legion::Extensions::Agentic::Attention::Salience::Client.new }
+
+  describe '#compute_salience' do
+    context 'with empty tick_results' do
+      it 'returns a hash with required keys' do
+        result = client.compute_salience(tick_results: {})
+        %i[overall urgency dominant_source above_baseline conflicts sources trend].each do |key|
+          expect(result).to have_key(key)
+        end
+      end
+
+      it 'returns :background urgency for zero signals' do
+        result = client.compute_salience(tick_results: {})
+        # novelty boost will elevate the first call, but urgency should be a valid level
+        expect(Legion::Extensions::Agentic::Attention::Salience::Helpers::Constants::URGENCY_LEVELS).to include(result[:urgency])
+      end
+
+      it 'returns sources hash with all 8 sources' do
+        result = client.compute_salience(tick_results: {})
+        expect(result[:sources].keys.size).to eq(8)
+      end
+    end
+
+    context 'with emotion tick_results' do
+      let(:tick_results) { { emotion: { arousal: 0.9, gut_strength: 0.7 } } }
+
+      it 'returns elevated overall salience' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:overall]).to be > 0.0
+      end
+
+      it 'identifies emotion as having salience data' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:sources][:emotion][:raw_salience]).to eq(0.9)
+      end
+
+      it 'returns trend as a symbol' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:trend]).to be_a(Symbol)
+      end
+    end
+
+    context 'with multiple sources' do
+      let(:tick_results) do
+        {
+          emotion:     { arousal: 0.8 },
+          trust:       { violation_count: 2 },
+          homeostasis: { worst_deviation: 0.6 }
+        }
+      end
+
+      it 'accumulates signal from all provided sources' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:overall]).to be > 0.0
+      end
+
+      it 'returns an Array for conflicts' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:conflicts]).to be_an(Array)
+      end
+
+      it 'returns a boolean for above_baseline' do
+        result = client.compute_salience(tick_results: tick_results)
+        expect(result[:above_baseline]).to be(true).or be(false)
+      end
+    end
+  end
+
+  describe '#salience_status' do
+    it 'returns a hash with required keys' do
+      result = client.salience_status
+      %i[overall urgency dominant baseline trend above_baseline].each do |key|
+        expect(result).to have_key(key)
+      end
+    end
+
+    it 'reflects state after a compute_salience call' do
+      client.compute_salience(tick_results: { emotion: { arousal: 0.7 } })
+      status = client.salience_status
+      expect(status[:overall]).to be >= 0.0
+    end
+  end
+
+  describe '#salience_for' do
+    it 'returns salience for an existing source' do
+      client.compute_salience(tick_results: { emotion: { arousal: 0.5 } })
+      result = client.salience_for(source: :emotion)
+      expect(result[:source]).to eq(:emotion)
+      expect(result[:salience]).to be >= 0.0
+    end
+
+    it 'returns 0.0 salience for an unknown source' do
+      result = client.salience_for(source: :nonexistent)
+      expect(result[:salience]).to eq(0.0)
+    end
+
+    it 'includes urgency in the response' do
+      result = client.salience_for(source: :emotion)
+      expect(result).to have_key(:urgency)
+    end
+  end
+
+  describe '#salience_history' do
+    it 'returns an entries array' do
+      result = client.salience_history
+      expect(result).to have_key(:entries)
+      expect(result[:entries]).to be_an(Array)
+    end
+
+    it 'respects the limit parameter' do
+      5.times { client.compute_salience(tick_results: {}) }
+      result = client.salience_history(limit: 3)
+      expect(result[:entries].size).to be <= 3
+    end
+
+    it 'accumulates entries across compute calls' do
+      3.times { client.compute_salience(tick_results: {}) }
+      result = client.salience_history(limit: 10)
+      expect(result[:entries].size).to eq(3)
+    end
+  end
+
+  describe '#salience_stats' do
+    it 'returns a hash with all stat keys' do
+      result = client.salience_stats
+      %i[overall baseline urgency dominant history_size conflict_count trend].each do |key|
+        expect(result).to have_key(key)
+      end
+    end
+
+    it 'reports 0 history_size before any compute calls' do
+      expect(client.salience_stats[:history_size]).to eq(0)
+    end
+
+    it 'increments history_size after compute calls' do
+      client.compute_salience(tick_results: {})
+      expect(client.salience_stats[:history_size]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Schema::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::AttentionSchema' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Attention::Schema::Runners::AttentionSchema)
+  end
+
+  it 'supports full attention lifecycle' do
+    # Focus on items
+    client.focus_on(target: :code_review, domain: :work, reason: 'PR needs review', source: :external)
+    client.focus_on(target: :test_results, domain: :ci, reason: 'tests running', source: :internal)
+
+    # Query awareness
+    aware = client.am_i_aware_of(target: :code_review)
+    expect(aware[:aware]).to be true
+
+    # Report
+    report = client.report_awareness
+    expect(report[:items].size).to eq(2)
+
+    # Model another agent
+    client.model_other_attention(agent_id: :validator, target: :code_review, awareness: 0.9)
+    other = client.query_other_attention(agent_id: :validator)
+    expect(other[:model]).not_to be_nil
+
+    # Meta-check
+    meta = client.meta_check
+    expect(meta[:schema_size]).to eq(2)
+
+    # Meta-accuracy feedback
+    client.update_meta_accuracy(was_correct: true)
+
+    # Decay
+    client.decay_schema
+
+    # Stats
+    stats = client.schema_stats
+    expect(stats[:success]).to be true
+
+    # Defocus
+    client.defocus(target: :test_results)
+    final = client.am_i_aware_of(target: :test_results)
+    expect(final[:aware]).to be false
+  end
+end