lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/feature_binding/helpers/feature_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::FeatureBinding::Helpers::Feature do
+  subject(:feature) { described_class.new(id: 'f:red', dimension: :color, value: :red) }
+
+  let(:constants) { Legion::Extensions::Agentic::Attention::FeatureBinding::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets id, dimension, and value' do
+      expect(feature.id).to eq('f:red')
+      expect(feature.dimension).to eq(:color)
+      expect(feature.value).to eq(:red)
+    end
+
+    it 'defaults source to :perception' do
+      expect(feature.source).to eq(:perception)
+    end
+
+    it 'defaults salience to 0.5' do
+      expect(feature.salience).to eq(0.5)
+    end
+
+    it 'records detected_at' do
+      expect(feature.detected_at).to be_a(Time)
+    end
+
+    it 'clamps salience to [0, 1]' do
+      high = described_class.new(id: 'h', dimension: :color, value: :x, salience: 5.0)
+      low  = described_class.new(id: 'l', dimension: :color, value: :x, salience: -1.0)
+      expect(high.salience).to eq(1.0)
+      expect(low.salience).to eq(0.0)
+    end
+
+    it 'accepts custom source' do
+      f = described_class.new(id: 'x', dimension: :shape, value: :circle, source: :memory)
+      expect(f.source).to eq(:memory)
+    end
+  end
+
+  describe '#salient?' do
+    it 'returns true when above floor' do
+      expect(feature.salient?).to be true
+    end
+
+    it 'returns false at zero salience' do
+      feature.salience = 0.0
+      expect(feature.salient?).to be false
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces salience' do
+      before = feature.salience
+      feature.decay
+      expect(feature.salience).to be < before
+    end
+
+    it 'does not go below zero' do
+      100.times { feature.decay }
+      expect(feature.salience).to be >= 0.0
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns false for a new feature' do
+      expect(feature.faded?).to be false
+    end
+
+    it 'returns true when salience at floor' do
+      feature.salience = constants::FEATURE_SALIENCE_FLOOR
+      expect(feature.faded?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = feature.to_h
+      expect(h).to include(:id, :dimension, :value, :source, :salience, :detected_at)
+    end
+
+    it 'rounds salience' do
+      feature.salience = 0.12345
+      expect(feature.to_h[:salience]).to eq(0.1235)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/feature_binding/runners/feature_binding_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/feature_binding/runners/feature_binding'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::FeatureBinding::Runners::FeatureBinding do
+  let(:field) { Legion::Extensions::Agentic::Attention::FeatureBinding::Helpers::BindingField.new }
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@field, field)
+    obj
+  end
+
+  describe '#register_feature' do
+    it 'registers successfully' do
+      result = host.register_feature(id: 'f:red', dimension: :color, value: :red)
+      expect(result[:success]).to be true
+      expect(result[:feature][:id]).to eq('f:red')
+    end
+
+    it 'returns failure at limit' do
+      Legion::Extensions::Agentic::Attention::FeatureBinding::Helpers::Constants::MAX_FEATURES.times do |i|
+        host.register_feature(id: "f:#{i}", dimension: :color, value: i)
+      end
+      result = host.register_feature(id: 'f:overflow', dimension: :color, value: :x)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#bind_features' do
+    before do
+      host.register_feature(id: 'f:red', dimension: :color, value: :red)
+      host.register_feature(id: 'f:circle', dimension: :shape, value: :circle)
+    end
+
+    it 'binds features into an object' do
+      result = host.bind_features(feature_ids: %w[f:red f:circle])
+      expect(result[:success]).to be true
+      expect(result[:object][:features]).to eq(%w[f:red f:circle])
+    end
+
+    it 'fails with insufficient features' do
+      result = host.bind_features(feature_ids: %w[f:red])
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#attend_object' do
+    it 'strengthens and confirms' do
+      host.register_feature(id: 'a', dimension: :color, value: :x)
+      host.register_feature(id: 'b', dimension: :shape, value: :y)
+      bind_result = host.bind_features(feature_ids: %w[a b])
+      obj_id = bind_result[:object][:id]
+      result = host.attend_object(object_id: obj_id)
+      expect(result[:success]).to be true
+      expect(result[:object][:confirmed]).to be true
+    end
+
+    it 'returns failure for unknown object' do
+      result = host.attend_object(object_id: :nope)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#unbind_object' do
+    it 'removes the object' do
+      host.register_feature(id: 'a', dimension: :color, value: :x)
+      host.register_feature(id: 'b', dimension: :shape, value: :y)
+      bind_result = host.bind_features(feature_ids: %w[a b])
+      obj_id = bind_result[:object][:id]
+      result = host.unbind_object(object_id: obj_id)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#illusory_conjunctions' do
+    it 'returns illusory bindings' do
+      result = host.illusory_conjunctions
+      expect(result[:success]).to be true
+      expect(result[:illusory]).to be_an(Array)
+    end
+  end
+
+  describe '#search_features' do
+    it 'searches by dimension' do
+      host.register_feature(id: 'f:red', dimension: :color, value: :red)
+      result = host.search_features(dimension: :color)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#update_feature_binding' do
+    it 'decays and returns counts' do
+      result = host.update_feature_binding
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#feature_binding_stats' do
+    it 'returns stats hash' do
+      result = host.feature_binding_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:features, :objects)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Focus::Client do
+  subject(:client) { described_class.new }
+
+  it 'initializes with default focus manager and habituation model' do
+    status = client.attention_status
+    expect(status[:manual_focus]).to eq({})
+    expect(status[:capacity]).to eq(Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::ATTENTIONAL_CAPACITY)
+  end
+
+  it 'includes the Attention runner' do
+    expect(client).to respond_to(:filter_signals)
+    expect(client).to respond_to(:attention_status)
+    expect(client).to respond_to(:focus_on)
+    expect(client).to respond_to(:release_focus)
+    expect(client).to respond_to(:habituation_stats)
+  end
+end

data/spec/legion/extensions/agentic/attention/focus/helpers/focus_manager_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Focus::Helpers::FocusManager do
+  subject(:manager) { described_class.new }
+
+  describe '#focus_on' do
+    it 'focuses on a domain' do
+      expect(manager.focus_on(:terraform)).to eq(:focused)
+      expect(manager.focused?(:terraform)).to be true
+    end
+
+    it 'converts string domains to symbols' do
+      manager.focus_on('vault')
+      expect(manager.focused?(:vault)).to be true
+    end
+
+    it 'returns :already_focused for duplicate focus' do
+      manager.focus_on(:terraform)
+      expect(manager.focus_on(:terraform)).to eq(:already_focused)
+    end
+
+    it 'returns :capacity_full when max is reached' do
+      Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::MAX_MANUAL_FOCUS.times do |i|
+        manager.focus_on(:"domain_#{i}")
+      end
+      expect(manager.focus_on(:overflow)).to eq(:capacity_full)
+    end
+
+    it 'stores reason with the focus' do
+      manager.focus_on(:security, reason: 'incident response')
+      expect(manager.manual_focus[:security][:reason]).to eq('incident response')
+    end
+  end
+
+  describe '#release' do
+    it 'releases a focused domain' do
+      manager.focus_on(:terraform)
+      expect(manager.release(:terraform)).to eq(:released)
+      expect(manager.focused?(:terraform)).to be false
+    end
+
+    it 'returns :not_focused for unfocused domains' do
+      expect(manager.release(:nonexistent)).to eq(:not_focused)
+    end
+  end
+
+  describe '#focused?' do
+    it 'returns true for focused domains' do
+      manager.focus_on(:vault)
+      expect(manager.focused?(:vault)).to be true
+    end
+
+    it 'returns false for unfocused domains' do
+      expect(manager.focused?(:vault)).to be false
+    end
+  end
+
+  describe '#focus_boost' do
+    it 'returns FOCUS_BOOST for focused domains' do
+      manager.focus_on(:terraform)
+      expect(manager.focus_boost(:terraform)).to eq(
+        Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::FOCUS_BOOST
+      )
+    end
+
+    it 'returns 0.0 for unfocused domains' do
+      expect(manager.focus_boost(:terraform)).to eq(0.0)
+    end
+  end
+
+  describe '#goal_relevance' do
+    it 'returns 0.0 with no focus or wonders' do
+      signal = { domain: :terraform, salience: 0.5 }
+      expect(manager.goal_relevance(signal)).to eq(0.0)
+    end
+
+    it 'returns boost for manually focused domain' do
+      manager.focus_on(:terraform)
+      signal = { domain: :terraform, salience: 0.5 }
+      expect(manager.goal_relevance(signal)).to be > 0.0
+    end
+
+    it 'returns relevance for domain matching an active wonder' do
+      signal = { domain: :terraform, salience: 0.5 }
+      wonders = [{ domain: :terraform, salience: 0.8 }]
+      relevance = manager.goal_relevance(signal, active_wonders: wonders)
+      expect(relevance).to be > 0.0
+    end
+
+    it 'returns 0.0 for non-matching wonder domains' do
+      signal = { domain: :terraform, salience: 0.5 }
+      wonders = [{ domain: :vault, salience: 0.8 }]
+      relevance = manager.goal_relevance(signal, active_wonders: wonders)
+      expect(relevance).to eq(0.0)
+    end
+
+    it 'caps at 1.0 even with focus and wonders combined' do
+      manager.focus_on(:terraform)
+      signal = { domain: :terraform, salience: 0.5 }
+      wonders = [{ domain: :terraform, salience: 1.0 }]
+      relevance = manager.goal_relevance(signal, active_wonders: wonders)
+      expect(relevance).to be <= 1.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/focus/helpers/focus_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Focus::Helpers::Focus do
+  let(:focus) { described_class }
+
+  describe '.score_signal' do
+    it 'returns a float between 0 and 1' do
+      score = focus.score_signal({ salience: 0.5, novelty: 0.5 })
+      expect(score).to be_between(0.0, 1.0)
+    end
+
+    it 'returns higher scores for high salience signals' do
+      high = focus.score_signal({ salience: 0.9, novelty: 0.5 })
+      low = focus.score_signal({ salience: 0.1, novelty: 0.5 })
+      expect(high).to be > low
+    end
+
+    it 'reduces score with high habituation' do
+      fresh = focus.score_signal({ salience: 0.5 }, habituation_level: 0.0)
+      habituated = focus.score_signal({ salience: 0.5 }, habituation_level: 0.9)
+      expect(fresh).to be > habituated
+    end
+
+    it 'increases score with goal relevance' do
+      no_goal = focus.score_signal({ salience: 0.5 }, goal_relevance: 0.0)
+      with_goal = focus.score_signal({ salience: 0.5 }, goal_relevance: 1.0)
+      expect(with_goal).to be > no_goal
+    end
+
+    it 'clamps result to 1.0 max' do
+      score = focus.score_signal({ salience: 1.0, novelty: 1.0 },
+                                 habituation_level: 0.0, goal_relevance: 1.0)
+      expect(score).to eq(1.0)
+    end
+  end
+
+  describe '.extract_salience' do
+    it 'returns salience from signal hash' do
+      expect(focus.extract_salience({ salience: 0.7 })).to eq(0.7)
+    end
+
+    it 'falls back to attention_score' do
+      expect(focus.extract_salience({ attention_score: 0.4 })).to eq(0.4)
+    end
+
+    it 'defaults to 0.0 for non-hash' do
+      expect(focus.extract_salience('not a hash')).to eq(0.0)
+    end
+
+    it 'defaults to 0.0 for missing key' do
+      expect(focus.extract_salience({})).to eq(0.0)
+    end
+  end
+
+  describe '.extract_novelty' do
+    it 'returns novelty from signal hash' do
+      expect(focus.extract_novelty({ novelty: 0.8 })).to eq(0.8)
+    end
+
+    it 'defaults to 0.5' do
+      expect(focus.extract_novelty({})).to eq(0.5)
+    end
+
+    it 'defaults to 0.5 for non-hash' do
+      expect(focus.extract_novelty(42)).to eq(0.5)
+    end
+  end
+
+  describe '.extract_domain' do
+    it 'returns domain from signal hash' do
+      expect(focus.extract_domain({ domain: :terraform })).to eq(:terraform)
+    end
+
+    it 'falls back to source_type' do
+      expect(focus.extract_domain({ source_type: :consul })).to eq(:consul)
+    end
+
+    it 'defaults to :general' do
+      expect(focus.extract_domain({})).to eq(:general)
+    end
+
+    it 'defaults to :general for non-hash' do
+      expect(focus.extract_domain(nil)).to eq(:general)
+    end
+  end
+
+  describe '.tag_signal' do
+    it 'merges attention metadata into the signal' do
+      signal = { salience: 0.8, domain: :terraform }
+      tagged = focus.tag_signal(signal, attention_score: 0.75, attention_tier: :spotlight)
+      expect(tagged[:attention_score]).to eq(0.75)
+      expect(tagged[:attention_tier]).to eq(:spotlight)
+      expect(tagged[:salience]).to eq(0.8)
+    end
+
+    it 'returns non-hash signals unchanged' do
+      result = focus.tag_signal('string', attention_score: 0.5, attention_tier: :peripheral)
+      expect(result).to eq('string')
+    end
+  end
+
+  describe '.attention_tier' do
+    it 'returns :spotlight for >= 0.7' do
+      expect(focus.attention_tier(0.7)).to eq(:spotlight)
+      expect(focus.attention_tier(0.95)).to eq(:spotlight)
+    end
+
+    it 'returns :peripheral for >= 0.4' do
+      expect(focus.attention_tier(0.4)).to eq(:peripheral)
+      expect(focus.attention_tier(0.69)).to eq(:peripheral)
+    end
+
+    it 'returns :background for >= BACKGROUND_THRESHOLD' do
+      expect(focus.attention_tier(0.2)).to eq(:background)
+      expect(focus.attention_tier(0.39)).to eq(:background)
+    end
+
+    it 'returns :filtered for below BACKGROUND_THRESHOLD' do
+      expect(focus.attention_tier(0.19)).to eq(:filtered)
+      expect(focus.attention_tier(0.0)).to eq(:filtered)
+    end
+  end
+
+  describe '.deduplicate' do
+    it 'removes duplicate signals by identity' do
+      signals = [
+        { domain: :terraform, source_type: :event, value: 'deploy' },
+        { domain: :terraform, source_type: :event, value: 'deploy' },
+        { domain: :vault, source_type: :event, value: 'rotate' }
+      ]
+      result = focus.deduplicate(signals)
+      expect(result.size).to eq(2)
+    end
+
+    it 'preserves unique signals' do
+      signals = [
+        { domain: :a, value: 1 },
+        { domain: :b, value: 2 },
+        { domain: :c, value: 3 }
+      ]
+      expect(focus.deduplicate(signals).size).to eq(3)
+    end
+
+    it 'returns empty array for empty input' do
+      expect(focus.deduplicate([])).to eq([])
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/focus/helpers/habituation_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Focus::Helpers::Habituation do
+  subject(:model) { described_class.new }
+
+  describe '#record' do
+    it 'increases habituation level for a domain' do
+      model.record(:terraform)
+      expect(model.level(:terraform)).to be > 0.0
+    end
+
+    it 'accumulates with repeated recordings' do
+      3.times { model.record(:terraform) }
+      expect(model.level(:terraform)).to be > model.level(:vault).to_f
+    end
+
+    it 'caps at HABITUATION_CEILING' do
+      ceiling = Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::HABITUATION_CEILING
+      20.times { model.record(:terraform) }
+      expect(model.level(:terraform)).to be <= ceiling
+    end
+
+    it 'converts string domains to symbols' do
+      model.record('terraform')
+      expect(model.level(:terraform)).to be > 0.0
+    end
+  end
+
+  describe '#level' do
+    it 'returns 0.0 for unknown domains' do
+      expect(model.level(:unknown)).to eq(0.0)
+    end
+  end
+
+  describe '#apply_novelty_reset' do
+    it 'does nothing when novelty <= 0.5' do
+      model.record(:terraform)
+      level_before = model.level(:terraform)
+      model.apply_novelty_reset(:terraform, novelty: 0.3)
+      expect(model.level(:terraform)).to eq(level_before)
+    end
+
+    it 'reduces habituation when novelty > 0.5' do
+      5.times { model.record(:terraform) }
+      level_before = model.level(:terraform)
+      model.apply_novelty_reset(:terraform, novelty: 0.9)
+      expect(model.level(:terraform)).to be < level_before
+    end
+
+    it 'never reduces below 0.0' do
+      model.record(:terraform)
+      model.apply_novelty_reset(:terraform, novelty: 1.0)
+      expect(model.level(:terraform)).to be >= 0.0
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces habituation for all recorded domains' do
+      3.times { model.record(:terraform) }
+      3.times { model.record(:vault) }
+      tf_before = model.level(:terraform)
+      v_before = model.level(:vault)
+
+      model.decay_all
+      expect(model.level(:terraform)).to be < tf_before
+      expect(model.level(:vault)).to be < v_before
+    end
+
+    it 'removes domains that decay to zero' do
+      model.record(:terraform)
+      model.apply_novelty_reset(:terraform, novelty: 1.0)
+      model.decay_all
+      expect(model.stats).not_to have_key(:terraform)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns rounded exposure levels' do
+      model.record(:terraform)
+      stats = model.stats
+      expect(stats[:terraform]).to be_a(Float)
+      expect(stats[:terraform].to_s.split('.').last.length).to be <= 3
+    end
+  end
+
+  describe '#habituated_domains' do
+    it 'returns domains above threshold' do
+      10.times { model.record(:terraform) }
+      expect(model.habituated_domains).to include(:terraform)
+    end
+
+    it 'excludes domains below threshold' do
+      model.record(:terraform)
+      expect(model.habituated_domains(threshold: 0.5)).not_to include(:terraform)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/focus/runners/attention_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Focus::Runners::Attention do
+  let(:client) { Legion::Extensions::Agentic::Attention::Focus::Client.new }
+
+  describe '#filter_signals' do
+    it 'returns empty result for empty input' do
+      result = client.filter_signals(signals: [])
+      expect(result[:filtered]).to eq([])
+      expect(result[:spotlight]).to eq(0)
+      expect(result[:peripheral]).to eq(0)
+      expect(result[:background]).to eq(0)
+      expect(result[:dropped]).to eq(0)
+    end
+
+    it 'categorizes high-salience signals as spotlight with goal boost' do
+      signals = [{ salience: 0.9, domain: :terraform, novelty: 0.8 }]
+      wonders = [{ domain: :terraform, salience: 0.9 }]
+      result = client.filter_signals(signals: signals, active_wonders: wonders)
+      expect(result[:spotlight]).to be >= 1
+    end
+
+    it 'categorizes high-salience signals into filtered output' do
+      signals = [{ salience: 0.9, domain: :terraform, novelty: 0.8 }]
+      result = client.filter_signals(signals: signals)
+      expect(result[:filtered].size).to be >= 1
+    end
+
+    it 'drops low-salience signals' do
+      signals = [{ salience: 0.01, domain: :heartbeat, novelty: 0.0 }]
+      result = client.filter_signals(signals: signals)
+      expect(result[:dropped]).to be >= 0
+      expect(result[:filtered].size).to be <= 1
+    end
+
+    it 'boosts signals matching active wonders' do
+      signals = [{ salience: 0.3, domain: :terraform, novelty: 0.3 }]
+      wonders = [{ domain: :terraform, salience: 0.9 }]
+
+      without = client.filter_signals(signals: signals)
+      # New client to avoid habituation carryover
+      fresh = Legion::Extensions::Agentic::Attention::Focus::Client.new
+      with_wonders = fresh.filter_signals(signals: signals, active_wonders: wonders)
+
+      # With wonder boost, the signal should score higher
+      with_total = with_wonders[:spotlight] + with_wonders[:peripheral]
+      without_total = without[:spotlight] + without[:peripheral]
+      expect(with_total).to be >= without_total
+    end
+
+    it 'deduplicates identical signals' do
+      signals = [
+        { salience: 0.8, domain: :terraform, source_type: :event, value: 'deploy' },
+        { salience: 0.8, domain: :terraform, source_type: :event, value: 'deploy' }
+      ]
+      result = client.filter_signals(signals: signals)
+      expect(result[:spotlight] + result[:peripheral] + result[:background]).to be <= 1
+    end
+
+    it 'enforces attentional capacity' do
+      signals = 10.times.map { |i| { salience: 0.9, domain: :"domain_#{i}", novelty: 0.9 } }
+      result = client.filter_signals(signals: signals)
+      expect(result[:spotlight]).to be <= Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::ATTENTIONAL_CAPACITY
+    end
+
+    it 'habituates repeated domain signals' do
+      first_client = Legion::Extensions::Agentic::Attention::Focus::Client.new
+      signals = [{ salience: 0.6, domain: :terraform, novelty: 0.3 }]
+
+      first_result = first_client.filter_signals(signals: signals)
+      # Record same domain multiple times to build habituation
+      10.times { first_client.filter_signals(signals: signals) }
+      later_result = first_client.filter_signals(signals: signals)
+
+      first_scores = first_result[:filtered].map { |s| s[:attention_score] || 0 }
+      later_scores = later_result[:filtered].map { |s| s[:attention_score] || 0 }
+
+      # Later scores should be lower due to habituation (if signal still passes)
+      expect(later_scores.max).to be <= first_scores.max if first_scores.any? && later_scores.any?
+    end
+  end
+
+  describe '#attention_status' do
+    it 'returns status hash' do
+      status = client.attention_status
+      expect(status[:manual_focus]).to eq({})
+      expect(status[:habituated_domains]).to eq([])
+      expect(status[:capacity]).to eq(Legion::Extensions::Agentic::Attention::Focus::Helpers::Constants::ATTENTIONAL_CAPACITY)
+      expect(status[:focus_count]).to eq(0)
+    end
+  end
+
+  describe '#focus_on' do
+    it 'focuses on a domain' do
+      result = client.focus_on(domain: :terraform, reason: 'deployment')
+      expect(result[:status]).to eq(:focused)
+      expect(result[:domain]).to eq(:terraform)
+    end
+
+    it 'updates attention status' do
+      client.focus_on(domain: :security, reason: 'incident')
+      status = client.attention_status
+      expect(status[:focus_count]).to eq(1)
+    end
+  end
+
+  describe '#release_focus' do
+    it 'releases a focused domain' do
+      client.focus_on(domain: :terraform)
+      result = client.release_focus(domain: :terraform)
+      expect(result[:status]).to eq(:released)
+    end
+
+    it 'returns :not_focused for unknown domain' do
+      result = client.release_focus(domain: :unknown)
+      expect(result[:status]).to eq(:not_focused)
+    end
+  end
+
+  describe '#habituation_stats' do
+    it 'returns stats hash' do
+      stats = client.habituation_stats
+      expect(stats[:domains]).to be_a(Hash)
+      expect(stats[:habituated]).to be_an(Array)
+    end
+
+    it 'reflects domain exposure after filtering' do
+      signals = [{ salience: 0.8, domain: :terraform, novelty: 0.3 }]
+      5.times { client.filter_signals(signals: signals) }
+      stats = client.habituation_stats
+      expect(stats[:domains]).to have_key(:terraform)
+    end
+  end
+end