lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/appraisal/helpers/appraisal_engine_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Appraisal::Helpers::AppraisalEngine do
+  let(:engine) { described_class.new }
+
+  let(:primary_joy)    { { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 } }
+  let(:primary_threat) { { relevance: 0.9, goal_congruence: 0.3, goal_importance: 0.8 } }
+  let(:secondary_low)  { { coping_potential: 0.2, control_expectation: 0.3, future_expectancy: 0.4 } }
+  let(:secondary_high) { { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 } }
+
+  describe '#appraise' do
+    it 'creates and returns an appraisal' do
+      record = engine.appraise(event: 'test', primary: primary_joy, secondary: secondary_high)
+      expect(record).to be_a(Legion::Extensions::Agentic::Affect::Appraisal::Helpers::Appraisal)
+      expect(record.event).to eq('test')
+    end
+
+    it 'stores appraisals by id' do
+      record = engine.appraise(event: 'test', primary: primary_joy, secondary: secondary_high)
+      expect(engine.to_h[:appraisals]).to have_key(record.id)
+    end
+
+    it 'computes emotional_outcome' do
+      record = engine.appraise(event: 'test', primary: primary_joy, secondary: secondary_high)
+      expect(record.emotional_outcome).to eq(:joy)
+    end
+  end
+
+  describe '#reappraise' do
+    it 'updates an existing appraisal' do
+      record = engine.appraise(event: 'test', primary: primary_threat, secondary: secondary_low)
+      expect(record.emotional_outcome).to eq(:anxiety)
+      updated = engine.reappraise(appraisal_id: record.id, new_primary: primary_joy, new_secondary: secondary_high)
+      expect(updated.emotional_outcome).to eq(:joy)
+      expect(updated.reappraised).to be(true)
+    end
+
+    it 'returns nil for unknown id' do
+      result = engine.reappraise(appraisal_id: 'unknown', new_primary: primary_joy, new_secondary: secondary_high)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#select_coping' do
+    it 'assigns coping to appraisal' do
+      record = engine.appraise(event: 'test', primary: primary_threat, secondary: secondary_low)
+      updated = engine.select_coping(appraisal_id: record.id, coping_type: :problem_focused)
+      expect(updated.coping_strategy).not_to be_nil
+    end
+
+    it 'prefers registered strategies for the coping type' do
+      engine.add_coping_strategy(name: 'action_plan', coping_type: :problem_focused, effectiveness: 0.9)
+      record = engine.appraise(event: 'test', primary: primary_threat, secondary: secondary_low)
+      updated = engine.select_coping(appraisal_id: record.id, coping_type: :problem_focused)
+      expect(updated.coping_strategy).to eq('action_plan')
+    end
+
+    it 'returns nil for unknown appraisal' do
+      result = engine.select_coping(appraisal_id: 'unknown', coping_type: :problem_focused)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#add_coping_strategy' do
+    it 'registers a strategy and returns true' do
+      result = engine.add_coping_strategy(name: 'reframing', coping_type: :emotion_focused, effectiveness: 0.7)
+      expect(result).to be(true)
+    end
+
+    it 'clamps effectiveness to [0, 1]' do
+      engine.add_coping_strategy(name: 'over', coping_type: :problem_focused, effectiveness: 1.5)
+      data = engine.to_h
+      # Strategy stored (engine is internal, test via evaluate_coping behavior)
+      expect(data).to be_a(Hash)
+    end
+  end
+
+  describe '#evaluate_coping' do
+    it 'returns effectiveness 0.0 when no coping assigned' do
+      record = engine.appraise(event: 'test', primary: primary_threat, secondary: secondary_low)
+      result = engine.evaluate_coping(appraisal_id: record.id)
+      expect(result[:effectiveness]).to eq(0.0)
+      expect(result[:resolved]).to be(false)
+    end
+
+    it 'uses registered strategy effectiveness' do
+      engine.add_coping_strategy(name: 'mindfulness', coping_type: :emotion_focused, effectiveness: 0.85)
+      record = engine.appraise(event: 'test', primary: primary_threat, secondary: secondary_low)
+      engine.select_coping(appraisal_id: record.id, coping_type: :emotion_focused)
+      result = engine.evaluate_coping(appraisal_id: record.id)
+      expect(result[:effectiveness]).to be_within(0.01).of(0.85)
+    end
+
+    it 'returns defaults for unknown appraisal' do
+      result = engine.evaluate_coping(appraisal_id: 'unknown')
+      expect(result[:effectiveness]).to eq(0.0)
+    end
+  end
+
+  describe '#by_emotion' do
+    it 'filters appraisals by emotional outcome' do
+      engine.appraise(event: 'a', primary: primary_joy,    secondary: secondary_high)
+      engine.appraise(event: 'b', primary: primary_threat, secondary: secondary_low)
+      joy_list = engine.by_emotion(emotion: :joy)
+      expect(joy_list.size).to eq(1)
+      expect(joy_list.first.event).to eq('a')
+    end
+  end
+
+  describe '#by_domain' do
+    it 'filters appraisals by domain' do
+      engine.appraise(event: 'a', primary: primary_joy, secondary: secondary_high, domain: 'work')
+      engine.appraise(event: 'b', primary: primary_joy, secondary: secondary_high, domain: 'personal')
+      work_list = engine.by_domain(domain: 'work')
+      expect(work_list.size).to eq(1)
+      expect(work_list.first.event).to eq('a')
+    end
+  end
+
+  describe '#unresolved' do
+    it 'returns appraisals without coping strategy' do
+      rec1 = engine.appraise(event: 'a', primary: primary_joy, secondary: secondary_high)
+      rec2 = engine.appraise(event: 'b', primary: primary_joy, secondary: secondary_high)
+      engine.select_coping(appraisal_id: rec1.id, coping_type: :problem_focused)
+      unresolved = engine.unresolved
+      expect(unresolved.map(&:id)).to include(rec2.id)
+      expect(unresolved.map(&:id)).not_to include(rec1.id)
+    end
+  end
+
+  describe '#emotional_pattern' do
+    it 'returns emotion counts sorted by frequency' do
+      3.times { engine.appraise(event: 'a', primary: primary_joy, secondary: secondary_high) }
+      engine.appraise(event: 'b', primary: primary_threat, secondary: secondary_low)
+      pattern = engine.emotional_pattern
+      expect(pattern.first.first).to eq(:joy)
+    end
+
+    it 'returns empty hash when no appraisals' do
+      expect(engine.emotional_pattern).to eq({})
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces intensity for all appraisals' do
+      rec = engine.appraise(event: 'test', primary: primary_joy, secondary: secondary_high)
+      engine.decay_all
+      expect(rec.intensity).to be < 0.5
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with appraisals, coping_strategies, history_size' do
+      engine.appraise(event: 'test', primary: primary_joy, secondary: secondary_high)
+      result = engine.to_h
+      expect(result).to have_key(:appraisals)
+      expect(result).to have_key(:coping_strategies)
+      expect(result).to have_key(:history_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/appraisal/helpers/appraisal_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Appraisal::Helpers::Appraisal do
+  let(:primary_low)  { { relevance: 0.2, goal_congruence: 0.2, goal_importance: 0.5 } }
+  let(:primary_high) { { relevance: 0.8, goal_congruence: 0.8, goal_importance: 0.9 } }
+  let(:secondary_low)  { { coping_potential: 0.2, control_expectation: 0.3, future_expectancy: 0.4 } }
+  let(:secondary_high) { { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 } }
+
+  def build(primary: primary_high, secondary: secondary_high, domain: 'work')
+    described_class.new(event: 'test event', primary: primary, secondary: secondary, domain: domain)
+  end
+
+  describe '#initialize' do
+    it 'sets id, event, domain' do
+      appraisal = build
+      expect(appraisal.id).to be_a(String)
+      expect(appraisal.event).to eq('test event')
+      expect(appraisal.domain).to eq('work')
+    end
+
+    it 'normalizes primary dimensions' do
+      appraisal = build
+      expect(appraisal.primary.keys).to contain_exactly(:relevance, :goal_congruence, :goal_importance)
+    end
+
+    it 'normalizes secondary dimensions' do
+      appraisal = build
+      expect(appraisal.secondary.keys).to contain_exactly(:coping_potential, :control_expectation, :future_expectancy)
+    end
+
+    it 'clamps out-of-range values' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 2.0, goal_congruence: -0.5, goal_importance: 0.5 },
+        secondary: secondary_high
+      )
+      expect(appraisal.primary[:relevance]).to eq(1.0)
+      expect(appraisal.primary[:goal_congruence]).to eq(0.0)
+    end
+
+    it 'sets default intensity' do
+      expect(build.intensity).to eq(0.5)
+    end
+
+    it 'sets reappraised to false' do
+      expect(build.reappraised).to be(false)
+    end
+  end
+
+  describe '#compute_emotion' do
+    it 'returns :indifference when relevance is low' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.2, goal_congruence: 0.5, goal_importance: 0.5 },
+        secondary: secondary_high
+      )
+      expect(appraisal.emotional_outcome).to eq(:indifference)
+    end
+
+    it 'returns :anxiety for threat with low coping' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.3, goal_importance: 0.8 },
+        secondary: { coping_potential: 0.2, control_expectation: 0.3, future_expectancy: 0.4 }
+      )
+      expect(appraisal.emotional_outcome).to eq(:anxiety)
+    end
+
+    it 'returns :challenge for threat with high coping' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.3, goal_importance: 0.8 },
+        secondary: { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 }
+      )
+      expect(appraisal.emotional_outcome).to eq(:challenge)
+    end
+
+    it 'returns :anger for very low goal_congruence' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.2, goal_importance: 0.8 },
+        secondary: { coping_potential: 0.5, control_expectation: 0.5, future_expectancy: 0.5 }
+      )
+      expect(appraisal.emotional_outcome).to eq(:anger)
+    end
+
+    it 'returns :joy for high goal_congruence' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 },
+        secondary: secondary_high
+      )
+      expect(appraisal.emotional_outcome).to eq(:joy)
+    end
+
+    it 'returns :sadness as fallback' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.5, goal_importance: 0.5 },
+        secondary: { coping_potential: 0.5, control_expectation: 0.5, future_expectancy: 0.5 }
+      )
+      expect(appraisal.emotional_outcome).to eq(:sadness)
+    end
+  end
+
+  describe '#reappraise' do
+    it 'updates emotion and reduces intensity' do
+      appraisal = described_class.new(
+        event: 'e', primary: primary_low, secondary: secondary_low
+      )
+      original_intensity = appraisal.intensity
+      appraisal.reappraise(new_primary: primary_high, new_secondary: secondary_high)
+      expect(appraisal.reappraised).to be(true)
+      expect(appraisal.intensity).to be < original_intensity
+      expect(appraisal.reappraised_at).not_to be_nil
+    end
+
+    it 'recomputes emotional_outcome' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.2, goal_congruence: 0.5, goal_importance: 0.5 },
+        secondary: secondary_high
+      )
+      expect(appraisal.emotional_outcome).to eq(:indifference)
+      appraisal.reappraise(
+        new_primary:   { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 },
+        new_secondary: secondary_high
+      )
+      expect(appraisal.emotional_outcome).to eq(:joy)
+    end
+
+    it 'applies REAPPRAISAL_DISCOUNT to intensity' do
+      appraisal = build
+      appraisal.reappraise(new_primary: primary_high, new_secondary: secondary_high)
+      expected = 0.5 * (1 - Legion::Extensions::Agentic::Affect::Appraisal::Helpers::Constants::REAPPRAISAL_DISCOUNT)
+      expect(appraisal.intensity).to be_within(0.001).of(expected)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces intensity by DECAY_RATE' do
+      appraisal = build
+      appraisal.decay!
+      expected = 0.5 - Legion::Extensions::Agentic::Affect::Appraisal::Helpers::Constants::DECAY_RATE
+      expect(appraisal.intensity).to be_within(0.001).of(expected)
+    end
+
+    it 'does not go below INTENSITY_FLOOR' do
+      appraisal = described_class.new(
+        event:     'e',
+        primary:   { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.9 },
+        secondary: secondary_high
+      )
+      60.times { appraisal.decay! }
+      expect(appraisal.intensity).to eq(0.0)
+    end
+  end
+
+  describe '#assign_coping' do
+    it 'sets coping_strategy' do
+      appraisal = build
+      appraisal.assign_coping('reframing')
+      expect(appraisal.coping_strategy).to eq('reframing')
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      appraisal = build
+      keys = appraisal.to_h.keys
+      expect(keys).to include(:id, :event, :domain, :primary, :secondary, :emotional_outcome,
+                              :intensity, :coping_strategy, :reappraised, :created_at, :reappraised_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/appraisal/helpers/constants_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Appraisal::Helpers::Constants do
+  let(:mod) { described_class }
+
+  it 'defines MAX_APPRAISALS' do
+    expect(mod::MAX_APPRAISALS).to eq(200)
+  end
+
+  it 'defines MAX_COPING_STRATEGIES' do
+    expect(mod::MAX_COPING_STRATEGIES).to eq(50)
+  end
+
+  it 'defines MAX_HISTORY' do
+    expect(mod::MAX_HISTORY).to eq(300)
+  end
+
+  it 'defines intensity bounds' do
+    expect(mod::INTENSITY_FLOOR).to eq(0.0)
+    expect(mod::INTENSITY_CEILING).to eq(1.0)
+    expect(mod::DEFAULT_INTENSITY).to eq(0.5)
+  end
+
+  it 'defines DECAY_RATE' do
+    expect(mod::DECAY_RATE).to eq(0.02)
+  end
+
+  it 'defines REAPPRAISAL_DISCOUNT' do
+    expect(mod::REAPPRAISAL_DISCOUNT).to eq(0.3)
+  end
+
+  it 'defines PRIMARY_DIMENSIONS' do
+    expect(mod::PRIMARY_DIMENSIONS).to contain_exactly(:relevance, :goal_congruence, :goal_importance)
+  end
+
+  it 'defines SECONDARY_DIMENSIONS' do
+    expect(mod::SECONDARY_DIMENSIONS).to contain_exactly(:coping_potential, :control_expectation, :future_expectancy)
+  end
+
+  it 'maps APPRAISAL_EMOTIONS' do
+    expect(mod::APPRAISAL_EMOTIONS[:threat_low_coping]).to eq(:anxiety)
+    expect(mod::APPRAISAL_EMOTIONS[:goal_congruent]).to eq(:joy)
+    expect(mod::APPRAISAL_EMOTIONS[:irrelevant]).to eq(:indifference)
+  end
+
+  it 'defines COPING_TYPES' do
+    expect(mod::COPING_TYPES).to include(:problem_focused, :emotion_focused, :meaning_focused)
+  end
+end

data/spec/legion/extensions/agentic/affect/appraisal/runners/appraisal_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/appraisal/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Appraisal::Runners::Appraisal do
+  let(:client) { Legion::Extensions::Agentic::Affect::Appraisal::Client.new }
+
+  let(:primary_joy)    { { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 } }
+  let(:primary_threat) { { relevance: 0.9, goal_congruence: 0.3, goal_importance: 0.8 } }
+  let(:secondary_low)  { { coping_potential: 0.2, control_expectation: 0.3, future_expectancy: 0.4 } }
+  let(:secondary_high) { { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 } }
+
+  describe '#appraise_event' do
+    it 'returns success: true with an appraisal' do
+      result = client.appraise_event(event: 'deadline', primary: primary_joy, secondary: secondary_high)
+      expect(result[:success]).to be(true)
+      expect(result[:appraisal]).to include(:id, :emotional_outcome)
+    end
+
+    it 'assigns emotional_outcome based on appraisal pattern' do
+      result = client.appraise_event(event: 'win', primary: primary_joy, secondary: secondary_high)
+      expect(result[:appraisal][:emotional_outcome]).to eq(:joy)
+    end
+
+    it 'accepts optional domain' do
+      result = client.appraise_event(event: 'test', primary: primary_joy, secondary: secondary_high,
+                                     domain: 'work')
+      expect(result[:appraisal][:domain]).to eq('work')
+    end
+  end
+
+  describe '#reappraise_event' do
+    it 'updates existing appraisal' do
+      appraisal_id = client.appraise_event(event: 'e', primary: primary_threat,
+                                           secondary: secondary_low)[:appraisal][:id]
+      result = client.reappraise_event(appraisal_id: appraisal_id, new_primary: primary_joy,
+                                       new_secondary: secondary_high)
+      expect(result[:success]).to be(true)
+      expect(result[:appraisal][:reappraised]).to be(true)
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.reappraise_event(appraisal_id: 'unknown', new_primary: primary_joy,
+                                       new_secondary: secondary_high)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to include('not found')
+    end
+  end
+
+  describe '#select_coping_strategy' do
+    it 'assigns a coping strategy to the appraisal' do
+      appraisal_id = client.appraise_event(event: 'e', primary: primary_threat,
+                                           secondary: secondary_low)[:appraisal][:id]
+      result = client.select_coping_strategy(appraisal_id: appraisal_id, coping_type: :problem_focused)
+      expect(result[:success]).to be(true)
+      expect(result[:appraisal][:coping_strategy]).not_to be_nil
+    end
+
+    it 'returns failure for unknown appraisal' do
+      result = client.select_coping_strategy(appraisal_id: 'unknown', coping_type: :problem_focused)
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '#add_coping_strategy' do
+    it 'registers a strategy' do
+      result = client.add_coping_strategy(name: 'journaling', coping_type: :emotion_focused,
+                                          effectiveness: 0.75)
+      expect(result[:success]).to be(true)
+      expect(result[:name]).to eq('journaling')
+    end
+  end
+
+  describe '#evaluate_coping' do
+    it 'returns effectiveness for an appraisal with coping' do
+      client.add_coping_strategy(name: 'breathing', coping_type: :emotion_focused, effectiveness: 0.8)
+      appraisal_id = client.appraise_event(event: 'e', primary: primary_threat,
+                                           secondary: secondary_low)[:appraisal][:id]
+      client.select_coping_strategy(appraisal_id: appraisal_id, coping_type: :emotion_focused)
+      result = client.evaluate_coping(appraisal_id: appraisal_id)
+      expect(result[:success]).to be(true)
+      expect(result[:effectiveness]).to be_a(Float)
+    end
+  end
+
+  describe '#emotional_pattern' do
+    it 'returns success with pattern hash' do
+      client.appraise_event(event: 'a', primary: primary_joy, secondary: secondary_high)
+      client.appraise_event(event: 'b', primary: primary_joy, secondary: secondary_high)
+      result = client.emotional_pattern
+      expect(result[:success]).to be(true)
+      expect(result[:pattern]).to be_a(Hash)
+      expect(result[:pattern][:joy]).to eq(2)
+    end
+  end
+
+  describe '#update_appraisal' do
+    it 'runs decay and returns success' do
+      client.appraise_event(event: 'e', primary: primary_joy, secondary: secondary_high)
+      result = client.update_appraisal
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '#appraisal_stats' do
+    it 'returns stats hash with totals' do
+      client.appraise_event(event: 'a', primary: primary_joy,    secondary: secondary_high)
+      client.appraise_event(event: 'b', primary: primary_threat, secondary: secondary_low)
+      result = client.appraisal_stats
+      expect(result[:success]).to be(true)
+      expect(result[:total]).to eq(2)
+      expect(result[:unresolved]).to eq(2)
+      expect(result[:history_size]).to be >= 2
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/cognitive_empathy/client_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Client do
+  subject(:client) { described_class.new }
+
+  it 'full lifecycle: take perspective, record outcome, check accuracy, stats' do
+    p1 = client.take_empathic_perspective(
+      agent_id:         :person_a,
+      perspective_type: :cognitive,
+      predicted_state:  { valence: 0.7, arousal: 0.4 },
+      confidence:       0.8
+    )
+    expect(p1[:success]).to be true
+    perspective_id = p1[:perspective_id]
+
+    outcome = client.record_empathic_outcome(
+      perspective_id: perspective_id,
+      actual_state:   { valence: 0.7, arousal: 0.4 }
+    )
+    expect(outcome[:success]).to be true
+
+    acc = client.empathic_accuracy_for(agent_id: :person_a)
+    expect(acc[:accuracy]).to be_a(Float)
+
+    client.apply_emotional_contagion(emotion_valence: 0.8, intensity: 0.6)
+    state = client.current_empathic_state
+    expect(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::EMPATHIC_STATES)
+      .to include(state[:empathic_state])
+
+    stats = client.cognitive_empathy_stats
+    expect(stats[:perspective_count]).to eq(1)
+    expect(stats[:resolved_count]).to eq(1)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::EmpathyEngine.new
+    c = described_class.new(engine: engine)
+    c.take_empathic_perspective(
+      agent_id:         :bob,
+      perspective_type: :affective,
+      predicted_state:  {},
+      confidence:       0.5
+    )
+    expect(engine.perspectives.size).to eq(1)
+  end
+
+  it 'blind spots returns nil agents on fresh client' do
+    result = client.empathic_blind_spots
+    expect(result[:success]).to be true
+    expect(result[:least_accurate_agent]).to be_nil
+  end
+
+  it 'overall accuracy is at default on fresh client' do
+    result = client.overall_empathic_accuracy
+    expect(result[:accuracy]).to eq(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::DEFAULT_ACCURACY)
+  end
+
+  it 'perspectives_for_agent returns empty list for unknown agent' do
+    result = client.perspectives_for_agent(agent_id: :ghost)
+    expect(result[:count]).to eq(0)
+  end
+end