lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/motivation/runners/motivation_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Motivation::Runners::Motivation do
+  let(:client) { Legion::Extensions::Agentic::Affect::Motivation::Client.new }
+
+  let(:normal_tick) do
+    {
+      consent:           { tier: :collaborate },
+      prediction_engine: { accuracy: 0.8 },
+      trust:             { overall_level: 0.7 },
+      memory_retrieval:  { novel_traces: 3 },
+      scheduler:         { pending_tasks: 5 },
+      extinction:        { level: 0 }
+    }
+  end
+
+  let(:adverse_tick) do
+    {
+      consent:           { tier: :supervised },
+      prediction_engine: { accuracy: 0.2 },
+      trust:             { overall_level: 0.1 },
+      memory_retrieval:  { novel_traces: 0 },
+      scheduler:         { pending_tasks: 0 },
+      extinction:        { level: 3 }
+    }
+  end
+
+  describe '#update_motivation' do
+    it 'returns a hash with expected keys' do
+      result = client.update_motivation(tick_results: normal_tick)
+      expect(result).to include(:mode, :overall_level, :intrinsic_average,
+                                :extrinsic_average, :amotivated, :burnout)
+    end
+
+    it 'returns a valid mode symbol' do
+      result = client.update_motivation(tick_results: normal_tick)
+      expect(Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::MOTIVATION_MODES).to include(result[:mode])
+    end
+
+    it 'handles empty tick results' do
+      result = client.update_motivation(tick_results: {})
+      expect(result[:overall_level]).to be_a(Float)
+    end
+
+    it 'handles missing tick keys gracefully' do
+      result = client.update_motivation(tick_results: { trust: {} })
+      expect(result).to include(:mode)
+    end
+
+    it 'returns amotivated as false initially' do
+      result = client.update_motivation(tick_results: {})
+      expect(result[:amotivated]).to be false
+    end
+
+    it 'decays drives on each tick' do
+      initial = client.motivation_store.drive_state.overall_level
+      client.update_motivation(tick_results: {})
+      after = client.motivation_store.drive_state.overall_level
+      expect(after).to be < initial
+    end
+  end
+
+  describe '#signal_drive' do
+    it 'updates a valid drive' do
+      result = client.signal_drive(drive: :autonomy, signal: 0.9)
+      expect(result[:success]).to be true
+      expect(result[:drive]).to eq(:autonomy)
+      expect(result[:level]).to be_a(Float)
+    end
+
+    it 'accepts string drive names' do
+      result = client.signal_drive(drive: 'competence', signal: 0.7)
+      expect(result[:success]).to be true
+    end
+
+    it 'rejects unknown drive' do
+      result = client.signal_drive(drive: :nonexistent, signal: 0.5)
+      expect(result[:success]).to be false
+      expect(result[:error]).to include('unknown drive')
+    end
+
+    it 'reflects updated level in drive_status' do
+      client.signal_drive(drive: :novelty, signal: 1.0)
+      status = client.drive_status
+      expect(status[:drives][:novelty][:level]).to be > 0.5
+    end
+  end
+
+  describe '#commit_to_goal' do
+    it 'commits a goal with valid drives' do
+      result = client.commit_to_goal(goal_id: 'goal_a', drives: %i[autonomy competence])
+      expect(result[:success]).to be true
+      expect(result[:goal_id]).to eq('goal_a')
+      expect(result[:energy]).to be_a(Float)
+    end
+
+    it 'returns failure for entirely invalid drives' do
+      result = client.commit_to_goal(goal_id: 'bad', drives: [:nonexistent])
+      expect(result[:success]).to be false
+      expect(result[:error]).to be_a(String)
+    end
+  end
+
+  describe '#release_goal' do
+    it 'releases a committed goal' do
+      client.commit_to_goal(goal_id: 'temp_goal', drives: [:autonomy])
+      result = client.release_goal(goal_id: 'temp_goal')
+      expect(result[:success]).to be true
+      expect(client.motivation_store.goal_motivations).not_to have_key('temp_goal')
+    end
+
+    it 'succeeds for unknown goal id' do
+      result = client.release_goal(goal_id: 'no_such_goal')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#motivation_for' do
+    it 'returns 0.0 energy for uncommitted goal' do
+      result = client.motivation_for(goal_id: 'unknown_goal')
+      expect(result[:energy]).to eq(0.0)
+    end
+
+    it 'returns positive energy for committed goal' do
+      client.commit_to_goal(goal_id: 'tracked', drives: %i[autonomy competence])
+      result = client.motivation_for(goal_id: 'tracked')
+      expect(result[:energy]).to be >= 0.0
+    end
+
+    it 'includes goal_id in result' do
+      result = client.motivation_for(goal_id: 'some_goal')
+      expect(result[:goal_id]).to eq('some_goal')
+    end
+  end
+
+  describe '#most_motivated_goal' do
+    it 'returns nil goal_id when no goals committed' do
+      result = client.most_motivated_goal
+      expect(result[:goal_id]).to be_nil
+    end
+
+    it 'returns the most energized goal' do
+      client.commit_to_goal(goal_id: 'low', drives: [:obligation])
+      client.commit_to_goal(goal_id: 'high', drives: %i[autonomy competence relatedness novelty])
+      %i[autonomy competence relatedness novelty].each do |d|
+        5.times { client.signal_drive(drive: d, signal: 1.0) }
+      end
+      result = client.most_motivated_goal
+      expect(result[:goal_id]).to eq('high')
+    end
+
+    it 'includes energy and drives in result' do
+      client.commit_to_goal(goal_id: 'g1', drives: [:autonomy])
+      result = client.most_motivated_goal
+      expect(result).to include(:goal_id, :energy, :drives)
+    end
+  end
+
+  describe '#drive_status' do
+    it 'returns drives hash' do
+      status = client.drive_status
+      expect(status).to have_key(:drives)
+    end
+
+    it 'returns mode' do
+      status = client.drive_status
+      expect(status).to have_key(:mode)
+    end
+
+    it 'returns overall level' do
+      status = client.drive_status
+      expect(status).to have_key(:overall)
+    end
+
+    it 'includes level and satisfied for each drive type' do
+      status = client.drive_status
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |type|
+        expect(status[:drives][type]).to include(:level, :satisfied)
+      end
+    end
+  end
+
+  describe '#motivation_stats' do
+    it 'returns overall_level' do
+      expect(client.motivation_stats).to have_key(:overall_level)
+    end
+
+    it 'returns current_mode' do
+      expect(client.motivation_stats).to have_key(:current_mode)
+    end
+
+    it 'returns intrinsic_average' do
+      expect(client.motivation_stats).to have_key(:intrinsic_average)
+    end
+
+    it 'returns extrinsic_average' do
+      expect(client.motivation_stats).to have_key(:extrinsic_average)
+    end
+
+    it 'returns amotivated flag' do
+      expect(client.motivation_stats).to have_key(:amotivated)
+    end
+
+    it 'returns goal_count' do
+      expect(client.motivation_stats).to have_key(:goal_count)
+    end
+  end
+
+  describe 'drive signal extraction from tick results' do
+    it 'extracts autonomy from consent tier :autonomous' do
+      client.update_motivation(tick_results: { consent: { tier: :autonomous } })
+      expect(client.motivation_store.drive_state.drive_level(:autonomy)).to be > 0.5
+    end
+
+    it 'extracts competence from prediction accuracy' do
+      client.update_motivation(tick_results: { prediction_engine: { accuracy: 0.95 } })
+      expect(client.motivation_store.drive_state.drive_level(:competence)).to be > 0.5
+    end
+
+    it 'extracts relatedness from trust level' do
+      client.update_motivation(tick_results: { trust: { overall_level: 0.9 } })
+      expect(client.motivation_store.drive_state.drive_level(:relatedness)).to be > 0.5
+    end
+
+    it 'extracts novelty from novel traces count' do
+      client.update_motivation(tick_results: { memory_retrieval: { novel_traces: 8 } })
+      expect(client.motivation_store.drive_state.drive_level(:novelty)).to be >= 0.0
+    end
+
+    it 'extracts obligation from pending tasks' do
+      client.update_motivation(tick_results: { scheduler: { pending_tasks: 10 } })
+      expect(client.motivation_store.drive_state.drive_level(:obligation)).to be > 0.0
+    end
+
+    it 'extracts survival from extinction level' do
+      client.update_motivation(tick_results: { extinction: { level: 4 } })
+      expect(client.motivation_store.drive_state.drive_level(:survival)).to be > 0.5
+    end
+
+    it 'lowers autonomy from constrained consent tier' do
+      initial = client.motivation_store.drive_state.drive_level(:autonomy)
+      client.update_motivation(tick_results: { consent: { tier: :supervised } })
+      expect(client.motivation_store.drive_state.drive_level(:autonomy)).to be < initial
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reappraisal/actors/auto_regulate_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/affect/reappraisal/actors/auto_regulate'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Actor::AutoRegulate do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Affect::Reappraisal::Runners::CognitiveReappraisal }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'regulate_pending_events' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 300 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/reappraisal/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:register_event)
+    expect(client).to respond_to(:reappraise_event)
+    expect(client).to respond_to(:auto_reappraise_event)
+    expect(client).to respond_to(:negative_events)
+    expect(client).to respond_to(:intense_events)
+    expect(client).to respond_to(:most_regulated_events)
+    expect(client).to respond_to(:reappraisal_status)
+    expect(client).to respond_to(:reappraisal_report)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::ReappraisalEngine.new
+    client = described_class.new(engine: engine)
+    result = client.register_event(
+      content:   'injected test',
+      valence:   -0.5,
+      intensity: 0.4,
+      appraisal: 'difficult',
+      engine:    engine
+    )
+    expect(result[:success]).to be true
+    expect(engine.events.size).to eq(1)
+  end
+
+  it 'creates its own engine when none injected' do
+    client = described_class.new
+    result = client.register_event(
+      content:   'standalone test',
+      valence:   0.3,
+      intensity: 0.2,
+      appraisal: 'fine'
+    )
+    expect(result[:success]).to be true
+  end
+
+  it 'executes a full register -> reappraise -> report cycle' do
+    client = described_class.new
+    reg    = client.register_event(
+      content:   'system alert',
+      valence:   -0.6,
+      intensity: 0.6,
+      appraisal: 'unrecoverable failure'
+    )
+    expect(reg[:success]).to be true
+
+    reap = client.reappraise_event(
+      event_id:      reg[:event_id],
+      strategy:      :temporal_distancing,
+      new_appraisal: 'this will be a minor footnote in six months'
+    )
+    expect(reap[:success]).to be true
+
+    report = client.reappraisal_report
+    expect(report[:report][:total_events]).to eq(1)
+    expect(report[:report][:total_reappraisals]).to eq(1)
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::Constants do
+  describe 'STRATEGIES' do
+    it 'includes all six strategies' do
+      expect(described_class::STRATEGIES).to include(
+        :reinterpretation, :distancing, :benefit_finding,
+        :normalizing, :perspective_taking, :temporal_distancing
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::STRATEGIES).to be_frozen
+    end
+  end
+
+  describe 'STRATEGY_EFFECTIVENESS' do
+    it 'has an entry for every strategy' do
+      described_class::STRATEGIES.each do |s|
+        expect(described_class::STRATEGY_EFFECTIVENESS).to have_key(s)
+      end
+    end
+
+    it 'rates reinterpretation highest' do
+      expect(described_class::STRATEGY_EFFECTIVENESS[:reinterpretation]).to be >
+                                                                            described_class::STRATEGY_EFFECTIVENESS[:temporal_distancing]
+    end
+
+    it 'all effectiveness values are between 0 and 1' do
+      described_class::STRATEGY_EFFECTIVENESS.each_value do |v|
+        expect(v).to be_between(0.0, 1.0)
+      end
+    end
+  end
+
+  describe '.valid_strategy?' do
+    it 'returns true for valid strategies' do
+      expect(described_class.valid_strategy?(:reinterpretation)).to be true
+      expect(described_class.valid_strategy?(:distancing)).to be true
+    end
+
+    it 'returns false for unknown strategy' do
+      expect(described_class.valid_strategy?(:nonexistent)).to be false
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns :positive for valence 0.8' do
+      expect(described_class.label_for(0.8, described_class::VALENCE_LABELS)).to eq(:positive)
+    end
+
+    it 'returns :negative for valence -0.8' do
+      expect(described_class.label_for(-0.8, described_class::VALENCE_LABELS)).to eq(:negative)
+    end
+
+    it 'returns :neutral for valence 0.0' do
+      expect(described_class.label_for(0.0, described_class::VALENCE_LABELS)).to eq(:neutral)
+    end
+
+    it 'returns :overwhelming for intensity 0.9' do
+      expect(described_class.label_for(0.9, described_class::INTENSITY_LABELS)).to eq(:overwhelming)
+    end
+
+    it 'returns :faint for intensity 0.1' do
+      expect(described_class.label_for(0.1, described_class::INTENSITY_LABELS)).to eq(:faint)
+    end
+
+    it 'returns :excellent for regulation 0.9' do
+      expect(described_class.label_for(0.9, described_class::REGULATION_LABELS)).to eq(:excellent)
+    end
+  end
+
+  describe '.clamp' do
+    it 'clamps to -1..1 by default' do
+      expect(described_class.clamp(2.0)).to eq(1.0)
+      expect(described_class.clamp(-2.0)).to eq(-1.0)
+      expect(described_class.clamp(0.5)).to eq(0.5)
+    end
+  end
+
+  describe '.clamp_intensity' do
+    it 'clamps to 0..1' do
+      expect(described_class.clamp_intensity(1.5)).to eq(1.0)
+      expect(described_class.clamp_intensity(-0.1)).to eq(0.0)
+      expect(described_class.clamp_intensity(0.7)).to eq(0.7)
+    end
+  end
+
+  describe 'thresholds' do
+    it 'defines NEGATIVE_VALENCE_THRESHOLD' do
+      expect(described_class::NEGATIVE_VALENCE_THRESHOLD).to eq(-0.3)
+    end
+
+    it 'defines HIGH_INTENSITY_THRESHOLD' do
+      expect(described_class::HIGH_INTENSITY_THRESHOLD).to eq(0.7)
+    end
+
+    it 'defines REAPPRAISAL_DIFFICULTY_MULTIPLIER' do
+      expect(described_class::REAPPRAISAL_DIFFICULTY_MULTIPLIER).to eq(0.5)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reappraisal/helpers/emotional_event_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::EmotionalEvent do
+  subject(:event) do
+    described_class.new(
+      content:   'test event',
+      valence:   -0.6,
+      intensity: 0.5,
+      appraisal: 'threatening situation'
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(event.content).to eq('test event')
+    end
+
+    it 'stores initial_valence clamped to -1..1' do
+      e = described_class.new(content: 'x', valence: -2.0, intensity: 0.5, appraisal: 'a')
+      expect(e.initial_valence).to eq(-1.0)
+    end
+
+    it 'stores initial_intensity clamped to 0..1' do
+      e = described_class.new(content: 'x', valence: 0.0, intensity: 1.5, appraisal: 'a')
+      expect(e.initial_intensity).to eq(1.0)
+    end
+
+    it 'sets current_valence equal to initial_valence' do
+      expect(event.current_valence).to eq(event.initial_valence)
+    end
+
+    it 'sets current_intensity equal to initial_intensity' do
+      expect(event.current_intensity).to eq(event.initial_intensity)
+    end
+
+    it 'starts with reappraisal_count 0' do
+      expect(event.reappraisal_count).to eq(0)
+    end
+
+    it 'sets created_at to a Time' do
+      expect(event.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#reappraise!' do
+    it 'increases valence toward positive' do
+      before = event.current_valence
+      event.reappraise!(strategy: :reinterpretation, new_appraisal: 'challenge')
+      expect(event.current_valence).to be > before
+    end
+
+    it 'reduces intensity' do
+      before = event.current_intensity
+      event.reappraise!(strategy: :reinterpretation, new_appraisal: 'challenge')
+      expect(event.current_intensity).to be < before
+    end
+
+    it 'increments reappraisal_count' do
+      expect { event.reappraise!(strategy: :distancing, new_appraisal: 'distant') }
+        .to change(event, :reappraisal_count).by(1)
+    end
+
+    it 'updates appraisal text' do
+      event.reappraise!(strategy: :benefit_finding, new_appraisal: 'growth opportunity')
+      expect(event.appraisal).to eq('growth opportunity')
+    end
+
+    it 'returns amount of change as a Float' do
+      change = event.reappraise!(strategy: :reinterpretation, new_appraisal: 'new view')
+      expect(change).to be_a(Float)
+      expect(change).to be >= 0.0
+    end
+
+    it 'returns 0.0 for invalid strategy' do
+      change = event.reappraise!(strategy: :nonexistent, new_appraisal: 'irrelevant')
+      expect(change).to eq(0.0)
+    end
+
+    it 'applies difficulty multiplier for high-intensity events' do
+      high = described_class.new(content: 'x', valence: -0.8, intensity: 0.9, appraisal: 'bad')
+      low  = described_class.new(content: 'x', valence: -0.8, intensity: 0.3, appraisal: 'bad')
+
+      high_change = high.reappraise!(strategy: :reinterpretation, new_appraisal: 'reframed')
+      low_change  = low.reappraise!(strategy: :reinterpretation, new_appraisal: 'reframed')
+
+      expect(high_change).to be < low_change
+    end
+
+    it 'does not allow valence to exceed 1.0' do
+      e = described_class.new(content: 'x', valence: 0.95, intensity: 0.1, appraisal: 'ok')
+      10.times { e.reappraise!(strategy: :reinterpretation, new_appraisal: 'great') }
+      expect(e.current_valence).to be <= 1.0
+    end
+
+    it 'does not allow intensity to go below 0.0' do
+      e = described_class.new(content: 'x', valence: -0.5, intensity: 0.05, appraisal: 'bad')
+      10.times { e.reappraise!(strategy: :reinterpretation, new_appraisal: 'better') }
+      expect(e.current_intensity).to be >= 0.0
+    end
+  end
+
+  describe '#negative?' do
+    it 'returns true when current_valence is below threshold' do
+      expect(event.negative?).to be true
+    end
+
+    it 'returns false for positive valence' do
+      e = described_class.new(content: 'x', valence: 0.5, intensity: 0.3, appraisal: 'good')
+      expect(e.negative?).to be false
+    end
+  end
+
+  describe '#intense?' do
+    it 'returns false for moderate intensity' do
+      expect(event.intense?).to be false
+    end
+
+    it 'returns true for high intensity' do
+      e = described_class.new(content: 'x', valence: -0.5, intensity: 0.8, appraisal: 'bad')
+      expect(e.intense?).to be true
+    end
+  end
+
+  describe '#regulation_amount' do
+    it 'returns 0.0 for unmodified event' do
+      expect(event.regulation_amount).to eq(0.0)
+    end
+
+    it 'returns positive value after reappraisal' do
+      event.reappraise!(strategy: :reinterpretation, new_appraisal: 'changed')
+      expect(event.regulation_amount).to be > 0.0
+    end
+
+    it 'returns value between 0 and 1' do
+      event.reappraise!(strategy: :reinterpretation, new_appraisal: 'changed')
+      expect(event.regulation_amount).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#valence_label' do
+    it 'returns :negative for valence -0.6' do
+      expect(event.valence_label).to eq(:negative)
+    end
+
+    it 'returns :positive after positive reappraisals' do
+      e = described_class.new(content: 'x', valence: 0.7, intensity: 0.3, appraisal: 'good')
+      expect(e.valence_label).to eq(:positive)
+    end
+  end
+
+  describe '#intensity_label' do
+    it 'returns :moderate for intensity 0.5' do
+      expect(event.intensity_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = event.to_h
+      expect(h).to include(:id, :content, :initial_valence, :current_valence,
+                           :initial_intensity, :current_intensity, :appraisal,
+                           :reappraisal_count, :negative, :intense,
+                           :regulation_amount, :valence_label, :intensity_label, :created_at)
+    end
+
+    it 'reflects updated state after reappraisal' do
+      event.reappraise!(strategy: :benefit_finding, new_appraisal: 'growth')
+      h = event.to_h
+      expect(h[:reappraisal_count]).to eq(1)
+      expect(h[:appraisal]).to eq('growth')
+    end
+  end
+end