lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/abductive/runners/abductive_reasoning_spec.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/abductive/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Abductive::Runners::AbductiveReasoning do
+  let(:client) { Legion::Extensions::Agentic::Inference::Abductive::Client.new }
+
+  describe '#record_observation' do
+    it 'records an observation and returns success' do
+      result = client.record_observation(
+        content:        'CPU usage spiked to 100% unexpectedly',
+        domain:         :system_health,
+        surprise_level: :surprising
+      )
+      expect(result[:success]).to be true
+      expect(result[:observation][:id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:observation][:domain]).to eq(:system_health)
+      expect(result[:observation][:surprise_level]).to eq(:surprising)
+    end
+
+    it 'rejects invalid surprise level' do
+      result = client.record_observation(
+        content:        'some fact',
+        domain:         :test,
+        surprise_level: :unknown_level
+      )
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_surprise_level)
+      expect(result[:valid_levels]).to eq(Legion::Extensions::Agentic::Inference::Abductive::Helpers::Constants::SURPRISE_LEVELS)
+    end
+
+    it 'uses notable as default surprise level' do
+      result = client.record_observation(content: 'a fact', domain: :test)
+      expect(result[:observation][:surprise_level]).to eq(:notable)
+    end
+
+    it 'stores context hash' do
+      result = client.record_observation(
+        content: 'memory leak detected',
+        domain:  :system,
+        context: { pid: 1234, rss_mb: 4096 }
+      )
+      expect(result[:observation][:context]).to eq({ pid: 1234, rss_mb: 4096 })
+    end
+  end
+
+  describe '#generate_hypothesis' do
+    let(:obs_result) { client.record_observation(content: 'service crashed', domain: :ops) }
+    let(:obs_id)     { obs_result[:observation][:id] }
+
+    it 'generates a hypothesis and returns success' do
+      result = client.generate_hypothesis(
+        content:           'Memory leak caused service crash',
+        observation_ids:   [obs_id],
+        domain:            :ops,
+        simplicity:        0.7,
+        explanatory_power: 0.8
+      )
+      expect(result[:success]).to be true
+      expect(result[:hypothesis][:id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:hypothesis][:state]).to eq(:candidate)
+      expect(result[:hypothesis][:overall_score]).to be > 0
+    end
+
+    it 'uses default prior probability when not given' do
+      result = client.generate_hypothesis(
+        content:           'Network partition caused crash',
+        observation_ids:   [obs_id],
+        domain:            :ops,
+        simplicity:        0.5,
+        explanatory_power: 0.6
+      )
+      expect(result[:hypothesis][:prior_probability]).to eq(
+        Legion::Extensions::Agentic::Inference::Abductive::Helpers::Constants::DEFAULT_PLAUSIBILITY
+      )
+    end
+
+    it 'uses provided prior probability' do
+      result = client.generate_hypothesis(
+        content:           'Config error',
+        observation_ids:   [obs_id],
+        domain:            :ops,
+        simplicity:        0.9,
+        explanatory_power: 0.7,
+        prior_probability: 0.8
+      )
+      expect(result[:hypothesis][:prior_probability]).to eq(0.8)
+    end
+  end
+
+  describe '#evaluate_hypothesis' do
+    let(:obs_id) { client.record_observation(content: 'anomaly', domain: :test)[:observation][:id] }
+    let(:hyp_id) do
+      client.generate_hypothesis(
+        content:           'hypothesis A',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        0.8,
+        explanatory_power: 0.9
+      )[:hypothesis][:id]
+    end
+
+    it 'evaluates a known hypothesis' do
+      result = client.evaluate_hypothesis(hypothesis_id: hyp_id)
+      expect(result[:success]).to be true
+      expect(result[:score]).to be_a(Float)
+      expect(result[:rank]).to be >= 1
+      expect(result[:quality_label]).to be_a(Symbol)
+    end
+
+    it 'returns not_found for unknown hypothesis' do
+      result = client.evaluate_hypothesis(hypothesis_id: 'nonexistent-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#add_hypothesis_evidence' do
+    let(:obs_id) { client.record_observation(content: 'strange output', domain: :test)[:observation][:id] }
+    let(:hyp_id) do
+      client.generate_hypothesis(
+        content:           'bad config',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        0.6,
+        explanatory_power: 0.7
+      )[:hypothesis][:id]
+    end
+
+    it 'adds supporting evidence and boosts plausibility' do
+      before_plausibility = client.evaluate_hypothesis(hypothesis_id: hyp_id)[:score]
+      client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: true)
+      hyp_after = client.evaluate_hypothesis(hypothesis_id: hyp_id)
+      expect(hyp_after[:success]).to be true
+      expect(before_plausibility).to be_a(Float)
+    end
+
+    it 'transitions to supported after enough supporting evidence' do
+      3.times { client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: true) }
+      result = client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: true)
+      expect(result[:state]).to eq(:supported)
+    end
+
+    it 'adds contradicting evidence' do
+      result = client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: false)
+      expect(result[:success]).to be true
+      expect(result[:state]).to eq(:candidate)
+    end
+
+    it 'returns not_found for unknown hypothesis' do
+      result = client.add_hypothesis_evidence(hypothesis_id: 'missing', supporting: true)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#best_explanation' do
+    let(:obs_id) { client.record_observation(content: 'disk full warning', domain: :storage)[:observation][:id] }
+
+    it 'returns nil found when no hypotheses exist' do
+      result = client.best_explanation(observation_id: obs_id)
+      expect(result[:success]).to be true
+      expect(result[:found]).to be false
+    end
+
+    it 'returns best hypothesis by overall_score' do
+      client.generate_hypothesis(
+        content:           'log files grew unbounded',
+        observation_ids:   [obs_id],
+        domain:            :storage,
+        simplicity:        0.9,
+        explanatory_power: 0.9,
+        prior_probability: 0.8
+      )
+      client.generate_hypothesis(
+        content:           'backup job failed and left temp files',
+        observation_ids:   [obs_id],
+        domain:            :storage,
+        simplicity:        0.3,
+        explanatory_power: 0.4,
+        prior_probability: 0.2
+      )
+      result = client.best_explanation(observation_id: obs_id)
+      expect(result[:success]).to be true
+      expect(result[:found]).to be true
+      expect(result[:hypothesis][:content]).to eq('log files grew unbounded')
+    end
+  end
+
+  describe '#competing_hypotheses' do
+    let(:obs_id) { client.record_observation(content: 'latency spike', domain: :perf)[:observation][:id] }
+
+    it 'returns empty list when no hypotheses' do
+      result = client.competing_hypotheses(observation_id: obs_id)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+      expect(result[:hypotheses]).to eq([])
+    end
+
+    it 'returns hypotheses sorted by score descending' do
+      client.generate_hypothesis(
+        content:           'DB slow query',
+        observation_ids:   [obs_id],
+        domain:            :perf,
+        simplicity:        0.8,
+        explanatory_power: 0.8
+      )
+      client.generate_hypothesis(
+        content:           'Network congestion',
+        observation_ids:   [obs_id],
+        domain:            :perf,
+        simplicity:        0.2,
+        explanatory_power: 0.2
+      )
+      result = client.competing_hypotheses(observation_id: obs_id)
+      expect(result[:count]).to eq(2)
+      scores = result[:hypotheses].map { |h| h[:overall_score] }
+      expect(scores).to eq(scores.sort.reverse)
+    end
+  end
+
+  describe '#refute_hypothesis' do
+    let(:obs_id) { client.record_observation(content: 'error 500', domain: :web)[:observation][:id] }
+    let(:hyp_id) do
+      client.generate_hypothesis(
+        content:           'out of memory',
+        observation_ids:   [obs_id],
+        domain:            :web,
+        simplicity:        0.5,
+        explanatory_power: 0.5
+      )[:hypothesis][:id]
+    end
+
+    it 'refutes a hypothesis' do
+      result = client.refute_hypothesis(hypothesis_id: hyp_id)
+      expect(result[:success]).to be true
+      expect(result[:state]).to eq(:refuted)
+    end
+
+    it 'excludes refuted hypotheses from competing list' do
+      client.refute_hypothesis(hypothesis_id: hyp_id)
+      result = client.competing_hypotheses(observation_id: obs_id)
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns not_found for unknown hypothesis' do
+      result = client.refute_hypothesis(hypothesis_id: 'ghost')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#unexplained_observations' do
+    it 'returns observations with no supported hypothesis' do
+      client.record_observation(content: 'unexplained event', domain: :mystery)
+      result = client.unexplained_observations
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+
+    it 'excludes observations explained by a supported hypothesis' do
+      obs_id = client.record_observation(content: 'explained', domain: :test)[:observation][:id]
+      hyp_id = client.generate_hypothesis(
+        content:           'known cause',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        0.9,
+        explanatory_power: 0.9
+      )[:hypothesis][:id]
+      3.times { client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: true) }
+      client.add_hypothesis_evidence(hypothesis_id: hyp_id, supporting: true)
+
+      result = client.unexplained_observations
+      obs_ids = result[:observations].map { |o| o[:id] }
+      expect(obs_ids).not_to include(obs_id)
+    end
+  end
+
+  describe '#update_abductive_reasoning' do
+    it 'runs decay and prune cycle' do
+      result = client.update_abductive_reasoning
+      expect(result[:success]).to be true
+      expect(result[:decayed]).to be >= 0
+      expect(result[:pruned]).to be >= 0
+    end
+
+    it 'prunes refuted hypotheses' do
+      obs_id = client.record_observation(content: 'obs', domain: :test)[:observation][:id]
+      hyp_id = client.generate_hypothesis(
+        content:           'bad hyp',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        0.5,
+        explanatory_power: 0.5
+      )[:hypothesis][:id]
+      client.refute_hypothesis(hypothesis_id: hyp_id)
+
+      result = client.update_abductive_reasoning
+      expect(result[:pruned]).to eq(1)
+    end
+  end
+
+  describe '#abductive_reasoning_stats' do
+    it 'returns stats hash' do
+      result = client.abductive_reasoning_stats
+      expect(result[:success]).to be true
+      expect(result).to have_key(:observation_count)
+      expect(result).to have_key(:hypothesis_count)
+      expect(result).to have_key(:supported_count)
+      expect(result).to have_key(:refuted_count)
+      expect(result).to have_key(:candidate_count)
+      expect(result).to have_key(:unexplained_count)
+    end
+
+    it 'reflects accumulated state' do
+      client.record_observation(content: 'fact', domain: :test)
+      result = client.abductive_reasoning_stats
+      expect(result[:observation_count]).to be >= 1
+    end
+  end
+
+  describe 'quality labels' do
+    let(:obs_id) { client.record_observation(content: 'obs', domain: :test)[:observation][:id] }
+
+    it 'assigns compelling label for high-scoring hypothesis' do
+      result = client.generate_hypothesis(
+        content:           'strong hypothesis',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        1.0,
+        explanatory_power: 1.0,
+        prior_probability: 1.0
+      )
+      expect(result[:hypothesis][:quality_label]).to eq(:compelling)
+    end
+
+    it 'assigns implausible label for low-scoring hypothesis' do
+      result = client.generate_hypothesis(
+        content:           'weak hypothesis',
+        observation_ids:   [obs_id],
+        domain:            :test,
+        simplicity:        0.0,
+        explanatory_power: 0.0,
+        prior_probability: 0.0
+      )
+      expect(result[:hypothesis][:quality_label]).to eq(:implausible)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/affordance/client_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/affordance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Affordance::Client do
+  subject(:client) { described_class.new }
+
+  it 'detects and evaluates affordances' do
+    client.register_capability(name: :http_client)
+    client.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible,
+                             requires: [:http_client])
+    result = client.evaluate_action(action: :send, domain: :comm)
+    expect(result[:feasible]).to be true
+  end
+
+  it 'detects threats' do
+    client.detect_affordance(action: :intrusion, domain: :security, affordance_type: :threat, relevance: 0.9)
+    result = client.current_threats
+    expect(result[:count]).to eq(1)
+  end
+
+  it 'reports stats' do
+    result = client.affordance_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/inference/affordance/helpers/affordance_field_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Affordance::Helpers::AffordanceField do
+  subject(:field) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Inference::Affordance::Helpers::Constants }
+
+  describe '#register_capability' do
+    it 'adds a capability' do
+      result = field.register_capability(name: :http_client, domain: :network)
+      expect(result).to be_a(Hash)
+      expect(field.capabilities.size).to eq(1)
+    end
+
+    it 'enforces limit' do
+      constants::MAX_CAPABILITIES.times { |i| field.register_capability(name: :"cap_#{i}") }
+      expect(field.register_capability(name: :overflow)).to be_nil
+    end
+  end
+
+  describe '#set_environment' do
+    it 'sets a property' do
+      result = field.set_environment(property: :network_status, value: :online)
+      expect(result).to be_a(Hash)
+      expect(field.environment.size).to eq(1)
+    end
+
+    it 'updates existing property' do
+      field.set_environment(property: :status, value: :offline)
+      field.set_environment(property: :status, value: :online)
+      expect(field.environment[:status][:value]).to eq(:online)
+    end
+  end
+
+  describe '#detect_affordance' do
+    it 'creates an affordance' do
+      aff = field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible)
+      expect(aff).to be_a(Legion::Extensions::Agentic::Inference::Affordance::Helpers::AffordanceItem)
+      expect(field.affordances.size).to eq(1)
+    end
+
+    it 'rejects invalid types' do
+      expect(field.detect_affordance(action: :x, domain: :d, affordance_type: :bogus)).to be_nil
+    end
+
+    it 'enforces MAX_AFFORDANCES' do
+      constants::MAX_AFFORDANCES.times do |i|
+        field.detect_affordance(action: :"a_#{i}", domain: :d, affordance_type: :neutral)
+      end
+      expect(field.detect_affordance(action: :overflow, domain: :d, affordance_type: :neutral)).to be_nil
+    end
+  end
+
+  describe '#evaluate_action' do
+    it 'returns not feasible when no affordance exists' do
+      result = field.evaluate_action(action: :fly, domain: :motion)
+      expect(result[:feasible]).to be false
+      expect(result[:reason]).to eq(:no_affordance)
+    end
+
+    it 'returns blocked when blocker exists' do
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_blocked)
+      result = field.evaluate_action(action: :send, domain: :comm)
+      expect(result[:feasible]).to be false
+      expect(result[:reason]).to eq(:blocked)
+    end
+
+    it 'returns feasible when capable and not blocked' do
+      field.register_capability(name: :http_client)
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible,
+                              requires: [:http_client])
+      result = field.evaluate_action(action: :send, domain: :comm)
+      expect(result[:feasible]).to be true
+    end
+
+    it 'returns not feasible when capabilities missing' do
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible,
+                              requires: [:missing_cap])
+      result = field.evaluate_action(action: :send, domain: :comm)
+      expect(result[:feasible]).to be false
+      expect(result[:reason]).to eq(:missing_capabilities)
+    end
+
+    it 'includes risks' do
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_risky)
+      result = field.evaluate_action(action: :send, domain: :comm)
+      expect(result[:risks]).not_to be_empty
+    end
+  end
+
+  describe '#actionable_affordances' do
+    it 'returns only actionable items sorted by relevance' do
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible, relevance: 0.8)
+      field.detect_affordance(action: :block, domain: :comm, affordance_type: :action_blocked)
+      items = field.actionable_affordances
+      expect(items.size).to eq(1)
+      expect(items.first[:action]).to eq(:send)
+    end
+  end
+
+  describe '#threats' do
+    it 'returns threat affordances' do
+      field.detect_affordance(action: :attack, domain: :security, affordance_type: :threat)
+      expect(field.threats.size).to eq(1)
+    end
+  end
+
+  describe '#affordances_in' do
+    it 'filters by domain' do
+      field.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible)
+      field.detect_affordance(action: :read, domain: :data, affordance_type: :resource_available)
+      expect(field.affordances_in(domain: :comm).size).to eq(1)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays and removes faded affordances' do
+      field.detect_affordance(action: :faint, domain: :d, affordance_type: :neutral, relevance: 0.06)
+      10.times { field.decay_all }
+      expect(field.affordances).to be_empty
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      h = field.to_h
+      expect(h).to include(:affordance_count, :capability_count, :environment_props,
+                           :actionable_count, :blocked_count, :threat_count, :history_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/affordance/helpers/affordance_item_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Affordance::Helpers::AffordanceItem do
+  subject(:item) do
+    described_class.new(id: :aff_one, action: :send_message, domain: :communication,
+                        affordance_type: :action_possible)
+  end
+
+  let(:constants) { Legion::Extensions::Agentic::Inference::Affordance::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets id, action, domain, and type' do
+      expect(item.id).to eq(:aff_one)
+      expect(item.action).to eq(:send_message)
+      expect(item.domain).to eq(:communication)
+      expect(item.affordance_type).to eq(:action_possible)
+    end
+
+    it 'defaults relevance' do
+      expect(item.relevance).to eq(constants::DEFAULT_RELEVANCE)
+    end
+  end
+
+  describe '#actionable?' do
+    it 'returns true for possible action above threshold' do
+      expect(item.actionable?).to be true
+    end
+
+    it 'returns false for blocked actions' do
+      blocked = described_class.new(id: :x, action: :y, domain: :d, affordance_type: :action_blocked)
+      expect(blocked.actionable?).to be false
+    end
+
+    it 'returns false when below threshold' do
+      item.relevance = 0.2
+      expect(item.actionable?).to be false
+    end
+  end
+
+  describe '#blocked?' do
+    it 'returns true for blocked type' do
+      b = described_class.new(id: :x, action: :y, domain: :d, affordance_type: :action_blocked)
+      expect(b.blocked?).to be true
+    end
+
+    it 'returns false otherwise' do
+      expect(item.blocked?).to be false
+    end
+  end
+
+  describe '#risky?' do
+    it 'returns true for risky type' do
+      r = described_class.new(id: :x, action: :y, domain: :d, affordance_type: :action_risky)
+      expect(r.risky?).to be true
+    end
+  end
+
+  describe '#threatening?' do
+    it 'returns true for threat type' do
+      t = described_class.new(id: :x, action: :y, domain: :d, affordance_type: :threat)
+      expect(t.threatening?).to be true
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces relevance' do
+      before = item.relevance
+      item.decay
+      expect(item.relevance).to be < before
+    end
+
+    it 'does not go below zero' do
+      100.times { item.decay }
+      expect(item.relevance).to be >= 0.0
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns false initially' do
+      expect(item.faded?).to be false
+    end
+
+    it 'returns true at floor' do
+      item.relevance = constants::RELEVANCE_FLOOR
+      expect(item.faded?).to be true
+    end
+  end
+
+  describe '#relevance_label' do
+    it 'returns :moderate for default relevance' do
+      expect(item.relevance_label).to eq(:moderate)
+    end
+
+    it 'returns :critical for high relevance' do
+      item.relevance = 0.9
+      expect(item.relevance_label).to eq(:critical)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = item.to_h
+      expect(h).to include(:id, :action, :domain, :affordance_type, :requires,
+                           :relevance, :relevance_label, :actionable, :blocked, :risky)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/affordance/runners/affordance_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/affordance/runners/affordance'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Affordance::Runners::Affordance do
+  let(:aff_field) { Legion::Extensions::Agentic::Inference::Affordance::Helpers::AffordanceField.new }
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@field, aff_field)
+    obj
+  end
+
+  describe '#register_capability' do
+    it 'registers successfully' do
+      result = host.register_capability(name: :http_client)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#set_environment' do
+    it 'sets property' do
+      result = host.set_environment(property: :status, value: :online)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#detect_affordance' do
+    it 'detects an affordance' do
+      result = host.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible)
+      expect(result[:success]).to be true
+      expect(result[:affordance][:action]).to eq(:send)
+    end
+
+    it 'fails for invalid type' do
+      result = host.detect_affordance(action: :x, domain: :d, affordance_type: :bogus)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#evaluate_action' do
+    it 'evaluates feasibility' do
+      host.detect_affordance(action: :send, domain: :comm, affordance_type: :action_possible)
+      result = host.evaluate_action(action: :send, domain: :comm)
+      expect(result[:success]).to be true
+      expect(result[:feasible]).to be true
+    end
+  end
+
+  describe '#actionable_affordances' do
+    it 'returns actionable items' do
+      result = host.actionable_affordances
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#current_threats' do
+    it 'returns threats' do
+      result = host.current_threats
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#update_affordances' do
+    it 'decays' do
+      result = host.update_affordances
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#affordance_stats' do
+    it 'returns stats' do
+      result = host.affordance_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:affordance_count)
+    end
+  end
+end