lex-agentic-affect 0.1.0

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Flow::Helpers::Constants do
+  describe 'FLOW_STATES' do
+    it 'contains all eight Csikszentmihalyi states' do
+      expect(described_class::FLOW_STATES).to contain_exactly(
+        :flow, :arousal, :control, :relaxation, :boredom, :apathy, :worry, :anxiety
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::FLOW_STATES).to be_frozen
+    end
+  end
+
+  describe 'FLOW_ZONE' do
+    it 'defines challenge and skill boundaries' do
+      zone = described_class::FLOW_ZONE
+      expect(zone[:challenge_min]).to eq(0.4)
+      expect(zone[:challenge_max]).to eq(0.8)
+      expect(zone[:skill_min]).to eq(0.4)
+      expect(zone[:skill_max]).to eq(0.8)
+    end
+
+    it 'defines balance tolerance' do
+      expect(described_class::FLOW_ZONE[:balance_tolerance]).to eq(0.15)
+    end
+
+    it 'is frozen' do
+      expect(described_class::FLOW_ZONE).to be_frozen
+    end
+  end
+
+  describe 'FLOW_ALPHA' do
+    it 'is 0.15' do
+      expect(described_class::FLOW_ALPHA).to eq(0.15)
+    end
+  end
+
+  describe 'DEEP_FLOW_THRESHOLD' do
+    it 'is 20 consecutive ticks' do
+      expect(described_class::DEEP_FLOW_THRESHOLD).to eq(20)
+    end
+  end
+
+  describe 'FLOW_EFFECTS' do
+    it 'defines performance and creativity boosts' do
+      effects = described_class::FLOW_EFFECTS
+      expect(effects[:performance_boost]).to eq(1.15)
+      expect(effects[:creativity_boost]).to eq(1.2)
+    end
+
+    it 'defines fatigue reduction' do
+      expect(described_class::FLOW_EFFECTS[:fatigue_reduction]).to eq(0.5)
+    end
+
+    it 'is frozen' do
+      expect(described_class::FLOW_EFFECTS).to be_frozen
+    end
+  end
+
+  describe 'FLOW_BREAKERS' do
+    it 'contains five breaker types' do
+      expect(described_class::FLOW_BREAKERS.size).to eq(5)
+      expect(described_class::FLOW_BREAKERS).to include(:high_anxiety, :burnout, :trust_violation)
+    end
+
+    it 'is frozen' do
+      expect(described_class::FLOW_BREAKERS).to be_frozen
+    end
+  end
+
+  describe 'STATE_REGIONS' do
+    it 'defines eight regions' do
+      expect(described_class::STATE_REGIONS.size).to eq(8)
+    end
+
+    it 'marks only flow as balanced' do
+      balanced = described_class::STATE_REGIONS.select { |_, v| v[:balanced] }.keys
+      expect(balanced).to eq([:flow])
+    end
+
+    it 'uses Range objects for challenge and skill' do
+      described_class::STATE_REGIONS.each_value do |region|
+        expect(region[:challenge]).to be_a(Range)
+        expect(region[:skill]).to be_a(Range)
+      end
+    end
+  end
+
+  describe 'score bonuses' do
+    it 'defines deep flow bonus' do
+      expect(described_class::DEEP_FLOW_BONUS).to eq(0.1)
+    end
+
+    it 'defines curiosity bonus' do
+      expect(described_class::CURIOSITY_BONUS).to eq(0.05)
+    end
+
+    it 'defines low error bonus' do
+      expect(described_class::LOW_ERROR_BONUS).to eq(0.05)
+    end
+  end
+
+  describe 'MAX_FLOW_HISTORY' do
+    it 'caps at 100' do
+      expect(described_class::MAX_FLOW_HISTORY).to eq(100)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/flow/helpers/flow_detector_spec.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Flow::Helpers::FlowDetector do
+  subject(:detector) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with neutral challenge and skill' do
+      expect(detector.challenge).to eq(0.5)
+      expect(detector.skill).to eq(0.5)
+    end
+
+    it 'starts in relaxation state' do
+      expect(detector.flow_state).to eq(:relaxation)
+    end
+
+    it 'starts with zero flow score' do
+      expect(detector.flow_score).to eq(0.0)
+    end
+
+    it 'starts with zero consecutive and total flow ticks' do
+      expect(detector.consecutive_flow_ticks).to eq(0)
+      expect(detector.total_flow_ticks).to eq(0)
+    end
+
+    it 'starts with empty history' do
+      expect(detector.history).to be_empty
+    end
+  end
+
+  describe '#update' do
+    it 'applies EMA to challenge and skill' do
+      detector.update(challenge_input: 0.8, skill_input: 0.8)
+      expect(detector.challenge).to be > 0.5
+      expect(detector.skill).to be > 0.5
+    end
+
+    it 'clamps inputs to 0.0..1.0' do
+      detector.update(challenge_input: 2.0, skill_input: -1.0)
+      expect(detector.challenge).to be_between(0.0, 1.0)
+      expect(detector.skill).to be_between(0.0, 1.0)
+    end
+
+    it 'records a snapshot in history' do
+      detector.update(challenge_input: 0.6, skill_input: 0.6)
+      expect(detector.history.size).to eq(1)
+      expect(detector.history.last).to include(:state, :flow_score, :challenge, :skill, :at)
+    end
+
+    it 'caps history at MAX_FLOW_HISTORY' do
+      max = Legion::Extensions::Agentic::Affect::Flow::Helpers::Constants::MAX_FLOW_HISTORY
+      (max + 10).times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.history.size).to eq(max)
+    end
+
+    it 'accepts modifiers' do
+      detector.update(challenge_input: 0.6, skill_input: 0.6, modifiers: { curiosity_active: true })
+      expect(detector.flow_score).to be >= 0.0
+    end
+  end
+
+  describe 'flow state detection' do
+    def push_to_flow(count = 30)
+      count.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+    end
+
+    it 'enters flow when challenge and skill are balanced and moderate' do
+      push_to_flow
+      expect(detector.flow_state).to eq(:flow)
+    end
+
+    it 'detects arousal when challenge is high and skill is moderate-low' do
+      30.times { detector.update(challenge_input: 0.9, skill_input: 0.4) }
+      expect(detector.flow_state).to eq(:arousal)
+    end
+
+    it 'detects boredom when challenge is low and skill is high' do
+      30.times { detector.update(challenge_input: 0.1, skill_input: 0.8) }
+      expect(detector.flow_state).to eq(:boredom)
+    end
+
+    it 'detects anxiety when challenge is very high and skill is very low' do
+      30.times { detector.update(challenge_input: 0.95, skill_input: 0.1) }
+      expect(detector.flow_state).to eq(:anxiety)
+    end
+
+    it 'detects apathy when both are very low' do
+      30.times { detector.update(challenge_input: 0.1, skill_input: 0.1) }
+      expect(detector.flow_state).to eq(:apathy)
+    end
+  end
+
+  describe '#in_flow?' do
+    it 'returns true when in flow state' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.in_flow?).to be true
+    end
+
+    it 'returns false when not in flow' do
+      expect(detector.in_flow?).to be false
+    end
+  end
+
+  describe '#deep_flow?' do
+    it 'returns false before threshold' do
+      19.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.deep_flow?).to be false
+    end
+
+    it 'returns true after consecutive flow ticks reach threshold' do
+      # Push challenge/skill into flow range quickly first
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      # Now the detector should be in flow, keep it there past threshold
+      expect(detector.consecutive_flow_ticks).to be >= 20
+      expect(detector.deep_flow?).to be true
+    end
+  end
+
+  describe '#flow_effects' do
+    it 'returns neutral effects when not in flow' do
+      effects = detector.flow_effects
+      expect(effects[:performance_boost]).to eq(1.0)
+      expect(effects[:creativity_boost]).to eq(1.0)
+      expect(effects[:fatigue_reduction]).to eq(1.0)
+    end
+
+    it 'returns enhanced effects when in flow' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      effects = detector.flow_effects
+      expect(effects[:performance_boost]).to be > 1.0
+      expect(effects[:creativity_boost]).to be > 1.0
+      expect(effects[:fatigue_reduction]).to be < 1.0
+    end
+
+    it 'provides extra boosts in deep flow' do
+      40.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      effects = detector.flow_effects
+      base_perf = Legion::Extensions::Agentic::Affect::Flow::Helpers::Constants::FLOW_EFFECTS[:performance_boost]
+      expect(effects[:performance_boost]).to be > base_perf
+    end
+  end
+
+  describe '#challenge_skill_balance' do
+    it 'returns 0 when challenge equals skill' do
+      expect(detector.challenge_skill_balance).to eq(0.0)
+    end
+
+    it 'returns positive value when unbalanced' do
+      30.times { detector.update(challenge_input: 0.9, skill_input: 0.1) }
+      expect(detector.challenge_skill_balance).to be > 0.0
+    end
+  end
+
+  describe '#flow_trend' do
+    it 'returns insufficient_data with fewer than 5 entries' do
+      3.times { detector.update(challenge_input: 0.5, skill_input: 0.5) }
+      expect(detector.flow_trend).to eq(:insufficient_data)
+    end
+
+    it 'detects entering_flow when scores are increasing' do
+      5.times { detector.update(challenge_input: 0.2, skill_input: 0.2) }
+      10.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      trend = detector.flow_trend
+      expect(trend).to eq(:entering_flow).or eq(:stable)
+    end
+
+    it 'detects leaving_flow when scores are decreasing' do
+      20.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      10.times { detector.update(challenge_input: 0.1, skill_input: 0.9) }
+      trend = detector.flow_trend
+      expect(trend).to eq(:leaving_flow).or eq(:stable)
+    end
+
+    it 'returns stable when scores are consistent' do
+      20.times { detector.update(challenge_input: 0.5, skill_input: 0.5) }
+      expect(detector.flow_trend).to eq(:stable)
+    end
+  end
+
+  describe '#flow_percentage' do
+    it 'returns 0.0 with empty history' do
+      expect(detector.flow_percentage).to eq(0.0)
+    end
+
+    it 'returns percentage of flow ticks' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.flow_percentage).to be > 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete hash' do
+      detector.update(challenge_input: 0.6, skill_input: 0.6)
+      h = detector.to_h
+      expect(h).to include(
+        :state, :score, :challenge, :skill, :balance,
+        :in_flow, :deep_flow, :consecutive_flow_ticks,
+        :total_flow_ticks, :flow_percentage, :trend, :effects
+      )
+    end
+
+    it 'rounds numeric values' do
+      detector.update(challenge_input: 0.6, skill_input: 0.6)
+      h = detector.to_h
+      expect(h[:score].to_s.split('.').last.length).to be <= 3
+      expect(h[:challenge].to_s.split('.').last.length).to be <= 3
+    end
+  end
+
+  describe 'flow score computation' do
+    it 'gives higher scores when in flow with good balance' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.flow_score).to be > 0.7
+    end
+
+    it 'gives lower scores when not in flow' do
+      30.times { detector.update(challenge_input: 0.1, skill_input: 0.9) }
+      expect(detector.flow_score).to be < 0.5
+    end
+
+    it 'adds curiosity bonus' do
+      20.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      score_without = detector.flow_score
+      detector2 = described_class.new
+      20.times { detector2.update(challenge_input: 0.6, skill_input: 0.6, modifiers: { curiosity_active: true }) }
+      expect(detector2.flow_score).to be >= score_without
+    end
+
+    it 'adds low error bonus' do
+      20.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      score_without = detector.flow_score
+      detector2 = described_class.new
+      20.times { detector2.update(challenge_input: 0.6, skill_input: 0.6, modifiers: { low_errors: true }) }
+      expect(detector2.flow_score).to be >= score_without
+    end
+
+    it 'clamps score to 0.0..1.0' do
+      50.times do
+        detector.update(challenge_input: 0.6, skill_input: 0.6,
+                        modifiers: { curiosity_active: true, low_errors: true })
+      end
+      expect(detector.flow_score).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe 'consecutive flow tick tracking' do
+    it 'increments when in flow' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.consecutive_flow_ticks).to be > 0
+    end
+
+    it 'resets when leaving flow' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.consecutive_flow_ticks).to be > 0
+      30.times { detector.update(challenge_input: 0.1, skill_input: 0.9) }
+      expect(detector.consecutive_flow_ticks).to eq(0)
+    end
+
+    it 'accumulates total flow ticks across sessions' do
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      first_total = detector.total_flow_ticks
+      30.times { detector.update(challenge_input: 0.1, skill_input: 0.9) }
+      30.times { detector.update(challenge_input: 0.6, skill_input: 0.6) }
+      expect(detector.total_flow_ticks).to be > first_total
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/flow/runners/flow_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Flow::Runners::Flow do
+  let(:client) { Legion::Extensions::Agentic::Affect::Flow::Client.new }
+
+  describe '#update_flow' do
+    let(:tick_results) do
+      {
+        prediction_engine:    { rolling_accuracy: 0.6, error_rate: 0.3 },
+        action_selection:     { complexity: 0.5 },
+        memory_retrieval:     { avg_strength: 0.6 },
+        habit:                { automation_level: 0.5 },
+        curiosity:            { intensity: 0.3 },
+        emotional_evaluation: { anxiety: 0.2 }
+      }
+    end
+
+    it 'returns flow state hash' do
+      result = client.update_flow(tick_results: tick_results)
+      expect(result).to include(:state, :score, :in_flow, :deep_flow, :effects, :breakers, :challenge, :skill)
+    end
+
+    it 'returns numeric score' do
+      result = client.update_flow(tick_results: tick_results)
+      expect(result[:score]).to be_a(Float)
+      expect(result[:score]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns challenge and skill values' do
+      result = client.update_flow(tick_results: tick_results)
+      expect(result[:challenge]).to be_between(0.0, 1.0)
+      expect(result[:skill]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns empty breakers for normal tick' do
+      result = client.update_flow(tick_results: tick_results)
+      expect(result[:breakers]).to be_empty
+    end
+
+    it 'returns effects hash' do
+      result = client.update_flow(tick_results: tick_results)
+      expect(result[:effects]).to be_a(Hash)
+    end
+
+    context 'with flow breakers' do
+      it 'detects high anxiety' do
+        tick_results[:emotional_evaluation][:anxiety] = 0.9
+        # Push into flow first
+        20.times { client.update_flow(tick_results: tick_results.merge(emotional_evaluation: { anxiety: 0.1 })) }
+        result = client.update_flow(tick_results: tick_results)
+        expect(result[:breakers]).to include(:high_anxiety)
+      end
+
+      it 'detects trust violation' do
+        tick_results[:trust] = { violation: true }
+        result = client.update_flow(tick_results: tick_results)
+        expect(result[:breakers]).to include(:trust_violation)
+      end
+
+      it 'detects critical error' do
+        tick_results[:error] = { critical: true }
+        result = client.update_flow(tick_results: tick_results)
+        expect(result[:breakers]).to include(:critical_error)
+      end
+
+      it 'detects burnout' do
+        tick_results[:fatigue] = { burnout: true }
+        result = client.update_flow(tick_results: tick_results)
+        expect(result[:breakers]).to include(:burnout)
+      end
+
+      it 'detects conflict escalation' do
+        tick_results[:conflict] = { severity: 4 }
+        result = client.update_flow(tick_results: tick_results)
+        expect(result[:breakers]).to include(:conflict_escalation)
+      end
+    end
+
+    context 'with default tick_results' do
+      it 'handles empty tick_results' do
+        result = client.update_flow(tick_results: {})
+        expect(result[:state]).to be_a(Symbol)
+        expect(result[:score]).to be_a(Float)
+      end
+    end
+  end
+
+  describe '#flow_status' do
+    it 'returns full status hash' do
+      status = client.flow_status
+      expect(status).to include(
+        :state, :score, :challenge, :skill, :balance,
+        :in_flow, :deep_flow, :consecutive_flow_ticks,
+        :total_flow_ticks, :flow_percentage, :trend, :effects
+      )
+    end
+  end
+
+  describe '#flow_effects' do
+    it 'returns effects with flow info' do
+      result = client.flow_effects
+      expect(result).to include(:effects, :in_flow, :deep_flow)
+      expect(result[:effects]).to be_a(Hash)
+    end
+
+    it 'returns neutral effects initially' do
+      result = client.flow_effects
+      expect(result[:effects][:performance_boost]).to eq(1.0)
+    end
+  end
+
+  describe '#flow_history' do
+    it 'returns empty history initially' do
+      result = client.flow_history
+      expect(result[:history]).to be_empty
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'returns history after updates' do
+      5.times { client.update_flow(tick_results: {}) }
+      result = client.flow_history
+      expect(result[:history].size).to eq(5)
+      expect(result[:total]).to eq(5)
+    end
+
+    it 'respects limit parameter' do
+      10.times { client.update_flow(tick_results: {}) }
+      result = client.flow_history(limit: 3)
+      expect(result[:history].size).to eq(3)
+      expect(result[:total]).to eq(10)
+    end
+  end
+
+  describe '#flow_stats' do
+    it 'returns stats hash' do
+      stats = client.flow_stats
+      expect(stats).to include(:state, :score, :consecutive_flow_ticks, :total_flow_ticks,
+                               :flow_percentage, :trend, :balance)
+    end
+
+    it 'returns numeric values' do
+      stats = client.flow_stats
+      expect(stats[:score]).to be_a(Float)
+      expect(stats[:flow_percentage]).to be_a(Float)
+      expect(stats[:balance]).to be_a(Float)
+    end
+  end
+
+  describe 'challenge/skill extraction' do
+    it 'derives challenge from prediction accuracy, error rate, and complexity' do
+      high_challenge = {
+        prediction_engine: { rolling_accuracy: 0.2, error_rate: 0.8 },
+        action_selection:  { complexity: 0.9 }
+      }
+      low_challenge = {
+        prediction_engine: { rolling_accuracy: 0.9, error_rate: 0.1 },
+        action_selection:  { complexity: 0.1 }
+      }
+
+      client_high = Legion::Extensions::Agentic::Affect::Flow::Client.new
+      client_low = Legion::Extensions::Agentic::Affect::Flow::Client.new
+      20.times do
+        client_high.update_flow(tick_results: high_challenge)
+        client_low.update_flow(tick_results: low_challenge)
+      end
+
+      high_result = client_high.flow_status
+      low_result = client_low.flow_status
+      expect(high_result[:challenge]).to be > low_result[:challenge]
+    end
+
+    it 'derives skill from prediction accuracy, memory strength, and habit' do
+      high_skill = {
+        prediction_engine: { rolling_accuracy: 0.9 },
+        memory_retrieval:  { avg_strength: 0.9 },
+        habit:             { automation_level: 0.9 }
+      }
+      low_skill = {
+        prediction_engine: { rolling_accuracy: 0.1 },
+        memory_retrieval:  { avg_strength: 0.1 },
+        habit:             { automation_level: 0.1 }
+      }
+
+      client_high = Legion::Extensions::Agentic::Affect::Flow::Client.new
+      client_low = Legion::Extensions::Agentic::Affect::Flow::Client.new
+      20.times do
+        client_high.update_flow(tick_results: high_skill)
+        client_low.update_flow(tick_results: low_skill)
+      end
+
+      high_result = client_high.flow_status
+      low_result = client_low.flow_status
+      expect(high_result[:skill]).to be > low_result[:skill]
+    end
+  end
+
+  describe 'flow progression over time' do
+    let(:balanced_tick) do
+      {
+        prediction_engine: { rolling_accuracy: 0.5, error_rate: 0.5 },
+        action_selection:  { complexity: 0.7 },
+        memory_retrieval:  { avg_strength: 0.7 },
+        habit:             { automation_level: 0.7 },
+        curiosity:         { intensity: 0.6 }
+      }
+    end
+
+    it 'reaches flow state with sustained balanced input' do
+      40.times { client.update_flow(tick_results: balanced_tick) }
+      expect(client.flow_status[:in_flow]).to be true
+    end
+
+    it 'reaches deep flow after threshold' do
+      50.times { client.update_flow(tick_results: balanced_tick) }
+      status = client.flow_status
+      # May or may not reach deep flow depending on exact EMA convergence
+      expect(status[:consecutive_flow_ticks]).to be >= 0
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Interoception::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::Interoception' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Affect::Interoception::Runners::Interoception)
+  end
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:report_vital)
+    expect(client).to respond_to(:create_somatic_marker)
+    expect(client).to respond_to(:query_bias)
+    expect(client).to respond_to(:reinforce_somatic)
+    expect(client).to respond_to(:deviating_vitals)
+    expect(client).to respond_to(:body_status)
+    expect(client).to respond_to(:update_interoception)
+    expect(client).to respond_to(:interoception_stats)
+  end
+
+  it 'supports full somatic marker lifecycle' do
+    # Report some vitals
+    client.report_vital(channel: :cpu_load, value: 0.3)
+    client.report_vital(channel: :connection_health, value: 0.9)
+
+    # Create markers based on outcomes
+    client.create_somatic_marker(action: :deploy, domain: :prod, valence: 0.8)
+    client.create_somatic_marker(action: :risky_change, domain: :prod, valence: -0.6)
+
+    # Query bias should reflect markers
+    approach = client.query_bias(action: :deploy)
+    expect(approach[:bias]).to be > 0
+
+    avoid = client.query_bias(action: :risky_change)
+    expect(avoid[:bias]).to be < 0
+
+    # Reinforce good outcome
+    client.reinforce_somatic(action: :deploy)
+
+    # Tick decay
+    client.update_interoception
+
+    # Check overall status
+    status = client.body_status
+    expect(status[:success]).to be true
+    expect(status[:health]).to be > 0
+
+    stats = client.interoception_stats
+    expect(stats[:stats][:channels]).to eq(2)
+    expect(stats[:stats][:markers]).to be >= 1
+  end
+end