lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/resilience/helpers/adversity_tracker_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resilience::Helpers::AdversityTracker do
+  subject(:tracker) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with no active adversities' do
+      expect(tracker.active_adversities).to be_empty
+    end
+
+    it 'starts with no resolved adversities' do
+      expect(tracker.resolved_adversities).to be_empty
+    end
+
+    it 'starts with zero consecutive recoveries' do
+      expect(tracker.consecutive_recoveries).to eq(0)
+    end
+  end
+
+  describe '#register' do
+    it 'registers a valid adversity' do
+      adversity = tracker.register(type: :prediction_failure, severity: :moderate)
+      expect(adversity).to include(:id, :type, :severity, :impact, :phase, :current_health)
+    end
+
+    it 'adds to active adversities' do
+      tracker.register(type: :trust_violation, severity: :major)
+      expect(tracker.active_adversities.size).to eq(1)
+    end
+
+    it 'rejects unknown adversity type' do
+      result = tracker.register(type: :unknown, severity: :minor)
+      expect(result).to be_nil
+    end
+
+    it 'rejects unknown severity' do
+      result = tracker.register(type: :prediction_failure, severity: :unknown)
+      expect(result).to be_nil
+    end
+
+    it 'sets initial health based on impact' do
+      adversity = tracker.register(type: :prediction_failure, severity: :major)
+      expect(adversity[:current_health]).to eq(0.5)
+    end
+
+    it 'starts in absorbing phase' do
+      adversity = tracker.register(type: :prediction_failure, severity: :minor)
+      expect(adversity[:phase]).to eq(:absorbing)
+    end
+
+    it 'assigns sequential IDs' do
+      a1 = tracker.register(type: :prediction_failure, severity: :minor)
+      a2 = tracker.register(type: :trust_violation, severity: :moderate)
+      expect(a2[:id]).to eq(a1[:id] + 1)
+    end
+
+    it 'accepts optional context' do
+      adversity = tracker.register(type: :system_error, severity: :minor, context: { detail: 'timeout' })
+      expect(adversity[:context][:detail]).to eq('timeout')
+    end
+
+    it 'caps active adversities' do
+      max = Legion::Extensions::Agentic::Affect::Resilience::Helpers::Constants::MAX_ACTIVE_ADVERSITIES
+      (max + 5).times { tracker.register(type: :prediction_failure, severity: :minor) }
+      expect(tracker.active_adversities.size).to eq(max)
+    end
+  end
+
+  describe '#tick_recovery' do
+    before do
+      tracker.register(type: :prediction_failure, severity: :moderate)
+    end
+
+    it 'returns recovery status' do
+      result = tracker.tick_recovery
+      expect(result).to include(:active_count, :resolved_count, :worst_health)
+    end
+
+    it 'increments ticks elapsed' do
+      tracker.tick_recovery
+      expect(tracker.active_adversities.first[:ticks_elapsed]).to eq(1)
+    end
+
+    it 'improves health over time' do
+      initial = tracker.active_adversities.first[:current_health]
+      tracker.tick_recovery
+      expect(tracker.active_adversities.first[:current_health]).to be > initial
+    end
+
+    it 'resolves adversity when health reaches threshold' do
+      recovery_ticks = Legion::Extensions::Agentic::Affect::Resilience::Helpers::Constants::SEVERITY_LEVELS[:moderate][:recovery_ticks]
+      (recovery_ticks + 5).times { tracker.tick_recovery }
+      expect(tracker.active_adversities).to be_empty
+      expect(tracker.resolved_adversities.size).to eq(1)
+    end
+
+    it 'increments consecutive recoveries on resolution' do
+      30.times { tracker.tick_recovery }
+      expect(tracker.consecutive_recoveries).to be >= 1
+    end
+
+    it 'advances phases during recovery' do
+      3.times { tracker.tick_recovery }
+      phase = tracker.active_adversities.first&.fetch(:phase, nil)
+      expect(phase).not_to be_nil
+    end
+  end
+
+  describe '#worst_health' do
+    it 'returns 1.0 with no adversities' do
+      expect(tracker.worst_health).to eq(1.0)
+    end
+
+    it 'returns lowest health among active' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      tracker.register(type: :trust_violation, severity: :critical)
+      expect(tracker.worst_health).to be < 0.1
+    end
+  end
+
+  describe '#active_by_type' do
+    it 'groups active adversities by type' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      tracker.register(type: :prediction_failure, severity: :moderate)
+      tracker.register(type: :trust_violation, severity: :minor)
+      result = tracker.active_by_type
+      expect(result[:prediction_failure]).to eq(2)
+      expect(result[:trust_violation]).to eq(1)
+    end
+  end
+
+  describe '#recovery_rate' do
+    it 'returns 0.0 with no resolved adversities' do
+      expect(tracker.recovery_rate).to eq(0.0)
+    end
+
+    it 'returns rate of on-time recoveries' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      20.times { tracker.tick_recovery }
+      expect(tracker.recovery_rate).to be > 0.0
+    end
+  end
+
+  describe '#average_recovery_speed' do
+    it 'returns 0.0 with no resolved adversities' do
+      expect(tracker.average_recovery_speed).to eq(0.0)
+    end
+
+    it 'returns ratio of actual to expected ticks' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      20.times { tracker.tick_recovery }
+      expect(tracker.average_recovery_speed).to be > 0.0
+    end
+  end
+
+  describe '#total_adversities' do
+    it 'counts active plus resolved' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      expect(tracker.total_adversities).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resilience::Helpers::Constants do
+  describe 'ADVERSITY_TYPES' do
+    it 'defines 8 types' do
+      expect(described_class::ADVERSITY_TYPES.size).to eq(8)
+    end
+
+    it 'includes prediction failure' do
+      expect(described_class::ADVERSITY_TYPES).to include(:prediction_failure)
+    end
+
+    it 'includes trust violation' do
+      expect(described_class::ADVERSITY_TYPES).to include(:trust_violation)
+    end
+
+    it 'is frozen' do
+      expect(described_class::ADVERSITY_TYPES).to be_frozen
+    end
+  end
+
+  describe 'RECOVERY_PHASES' do
+    it 'defines 4 phases' do
+      expect(described_class::RECOVERY_PHASES).to eq(%i[absorbing adapting recovering thriving])
+    end
+  end
+
+  describe 'DIMENSIONS' do
+    it 'defines 4 dimensions' do
+      expect(described_class::DIMENSIONS.size).to eq(4)
+    end
+
+    it 'has weights summing to 1.0' do
+      total = described_class::DIMENSIONS.values.sum { |v| v[:weight] }
+      expect(total).to be_within(0.001).of(1.0)
+    end
+
+    it 'includes elasticity, robustness, adaptability, growth' do
+      expect(described_class::DIMENSIONS.keys).to contain_exactly(:elasticity, :robustness, :adaptability, :growth)
+    end
+  end
+
+  describe 'SEVERITY_LEVELS' do
+    it 'defines 5 levels' do
+      expect(described_class::SEVERITY_LEVELS.size).to eq(5)
+    end
+
+    it 'has increasing impact' do
+      impacts = described_class::SEVERITY_LEVELS.values.map { |v| v[:impact] }
+      expect(impacts).to eq(impacts.sort)
+    end
+
+    it 'has increasing recovery ticks' do
+      ticks = described_class::SEVERITY_LEVELS.values.map { |v| v[:recovery_ticks] }
+      expect(ticks).to eq(ticks.sort)
+    end
+  end
+
+  describe 'thresholds' do
+    it 'defines fragility threshold' do
+      expect(described_class::FRAGILITY_THRESHOLD).to eq(0.3)
+    end
+
+    it 'defines antifragility threshold' do
+      expect(described_class::ANTIFRAGILITY_THRESHOLD).to eq(0.7)
+    end
+
+    it 'defines recovery threshold' do
+      expect(described_class::RECOVERY_THRESHOLD).to eq(0.9)
+    end
+
+    it 'defines growth trigger' do
+      expect(described_class::GROWTH_TRIGGER).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/resilience/helpers/resilience_model_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resilience::Helpers::ResilienceModel do
+  subject(:model) { described_class.new }
+
+  let(:tracker) { Legion::Extensions::Agentic::Affect::Resilience::Helpers::AdversityTracker.new }
+
+  describe '#initialize' do
+    it 'starts all dimensions at 0.5' do
+      model.dimensions.each_value do |val|
+        expect(val).to eq(0.5)
+      end
+    end
+
+    it 'starts with zero growth bonus' do
+      expect(model.growth_bonus).to eq(0.0)
+    end
+
+    it 'starts with empty history' do
+      expect(model.history).to be_empty
+    end
+  end
+
+  describe '#update_from_tracker' do
+    it 'records a snapshot' do
+      model.update_from_tracker(tracker)
+      expect(model.history.size).to eq(1)
+    end
+
+    it 'updates dimensions' do
+      tracker.register(type: :prediction_failure, severity: :moderate)
+      5.times { tracker.tick_recovery }
+      model.update_from_tracker(tracker)
+      changed = model.dimensions.values.any? { |v| (v - 0.5).abs > 0.001 }
+      expect(changed).to be true
+    end
+  end
+
+  describe '#composite_score' do
+    it 'starts at approximately 0.5' do
+      expect(model.composite_score).to be_within(0.01).of(0.5)
+    end
+
+    it 'is between 0.0 and 1.0' do
+      expect(model.composite_score).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#classification' do
+    it 'starts as resilient (score ~0.5)' do
+      expect(model.classification).to eq(:resilient)
+    end
+
+    it 'classifies antifragile for high scores' do
+      model.dimensions.each_key { |k| model.dimensions[k] = 0.85 }
+      expect(model.classification).to eq(:antifragile)
+    end
+
+    it 'classifies fragile for low scores' do
+      model.dimensions.each_key { |k| model.dimensions[k] = 0.35 }
+      expect(model.classification).to eq(:fragile)
+    end
+
+    it 'classifies brittle for very low scores' do
+      model.dimensions.each_key { |k| model.dimensions[k] = 0.1 }
+      expect(model.classification).to eq(:brittle)
+    end
+  end
+
+  describe '#dimension_detail' do
+    it 'returns detail for valid dimension' do
+      detail = model.dimension_detail(:elasticity)
+      expect(detail).to include(:name, :value, :config, :trend, :healthy)
+    end
+
+    it 'returns nil for unknown dimension' do
+      expect(model.dimension_detail(:unknown)).to be_nil
+    end
+  end
+
+  describe '#trend' do
+    it 'returns insufficient_data with few entries' do
+      expect(model.trend).to eq(:insufficient_data)
+    end
+
+    it 'returns a trend with enough data' do
+      10.times { model.update_from_tracker(tracker) }
+      expect(%i[strengthening weakening stable]).to include(model.trend)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete state hash' do
+      h = model.to_h
+      expect(h).to include(:dimensions, :growth_bonus, :composite, :class, :trend)
+    end
+  end
+
+  describe 'growth bonus' do
+    it 'increases after consecutive recoveries' do
+      tracker.register(type: :prediction_failure, severity: :minor)
+      20.times { tracker.tick_recovery }
+      tracker.register(type: :trust_violation, severity: :minor)
+      20.times { tracker.tick_recovery }
+      tracker.register(type: :system_error, severity: :minor)
+      20.times { tracker.tick_recovery }
+
+      model.update_from_tracker(tracker)
+      expect(model.growth_bonus).to be > 0.0
+    end
+
+    it 'caps at MAX_GROWTH_BONUS' do
+      max = Legion::Extensions::Agentic::Affect::Resilience::Helpers::Constants::MAX_GROWTH_BONUS
+      # Force many consecutive recoveries
+      20.times do
+        tracker.register(type: :prediction_failure, severity: :minor)
+        20.times { tracker.tick_recovery }
+        model.update_from_tracker(tracker)
+      end
+      expect(model.growth_bonus).to be <= max
+    end
+  end
+
+  describe 'history cap' do
+    it 'caps at MAX_RESILIENCE_HISTORY' do
+      max = Legion::Extensions::Agentic::Affect::Resilience::Helpers::Constants::MAX_RESILIENCE_HISTORY
+      (max + 10).times { model.update_from_tracker(tracker) }
+      expect(model.history.size).to eq(max)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/resilience/runners/resilience_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resilience::Runners::Resilience do
+  let(:client) { Legion::Extensions::Agentic::Affect::Resilience::Client.new }
+
+  let(:normal_tick) do
+    {
+      prediction_engine:    { error_rate: 0.2 },
+      trust:                {},
+      conflict:             {},
+      fatigue:              { energy: 0.7 },
+      emotional_evaluation: { arousal: 0.5 }
+    }
+  end
+
+  let(:adverse_tick) do
+    {
+      prediction_engine:    { error_rate: 0.8 },
+      trust:                { violation: true },
+      conflict:             { severity: 4 },
+      fatigue:              { energy: 0.1 },
+      emotional_evaluation: { arousal: 0.95 }
+    }
+  end
+
+  describe '#update_resilience' do
+    it 'returns resilience status' do
+      result = client.update_resilience(tick_results: normal_tick)
+      expect(result).to include(:active_adversities, :resolved_this_tick, :worst_health,
+                                :composite_score, :classification, :growth_bonus)
+    end
+
+    it 'detects no adversities in normal conditions' do
+      result = client.update_resilience(tick_results: normal_tick)
+      expect(result[:active_adversities]).to eq(0)
+    end
+
+    it 'detects multiple adversities in adverse conditions' do
+      result = client.update_resilience(tick_results: adverse_tick)
+      expect(result[:active_adversities]).to be > 0
+    end
+
+    it 'handles empty tick results' do
+      result = client.update_resilience(tick_results: {})
+      expect(result[:composite_score]).to be_a(Float)
+    end
+  end
+
+  describe '#register_adversity' do
+    it 'registers valid adversity' do
+      result = client.register_adversity(type: :prediction_failure, severity: :moderate)
+      expect(result[:success]).to be true
+      expect(result[:adversity]).to include(:id, :type, :severity)
+    end
+
+    it 'rejects invalid adversity' do
+      result = client.register_adversity(type: :unknown, severity: :minor)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#resilience_status' do
+    it 'returns full status' do
+      status = client.resilience_status
+      expect(status).to include(:dimensions, :composite, :class, :trend,
+                                :active_adversities, :total_adversities,
+                                :consecutive_recoveries, :recovery_rate)
+    end
+  end
+
+  describe '#adversity_report' do
+    it 'returns adversity details' do
+      report = client.adversity_report
+      expect(report).to include(:active, :by_type, :total, :worst, :avg_speed)
+    end
+
+    it 'reports active adversities' do
+      client.register_adversity(type: :prediction_failure, severity: :minor)
+      report = client.adversity_report
+      expect(report[:active].size).to eq(1)
+    end
+  end
+
+  describe '#dimension_detail' do
+    it 'returns detail for known dimension' do
+      detail = client.dimension_detail(dimension: :elasticity)
+      expect(detail).to include(:name, :value, :config, :trend, :healthy)
+    end
+
+    it 'returns error for unknown dimension' do
+      detail = client.dimension_detail(dimension: :unknown)
+      expect(detail).to have_key(:error)
+    end
+  end
+
+  describe '#resilience_stats' do
+    it 'returns comprehensive stats' do
+      stats = client.resilience_stats
+      expect(stats).to include(:composite, :classification, :dimensions,
+                               :growth_bonus, :trend, :total_adversities,
+                               :active_adversities, :recovery_rate,
+                               :consecutive_recoveries, :history_size)
+    end
+  end
+
+  describe 'adversity detection from tick results' do
+    it 'detects high prediction error' do
+      client.update_resilience(tick_results: { prediction_engine: { error_rate: 0.8 } })
+      expect(client.adversity_tracker.active_adversities.size).to eq(1)
+    end
+
+    it 'detects trust violation' do
+      client.update_resilience(tick_results: { trust: { violation: true } })
+      expect(client.adversity_tracker.active_adversities.any? { |a| a[:type] == :trust_violation }).to be true
+    end
+
+    it 'detects conflict escalation' do
+      client.update_resilience(tick_results: { conflict: { severity: 4 } })
+      expect(client.adversity_tracker.active_adversities.any? { |a| a[:type] == :conflict_escalation }).to be true
+    end
+
+    it 'detects resource depletion' do
+      client.update_resilience(tick_results: { fatigue: { energy: 0.05 } })
+      expect(client.adversity_tracker.active_adversities.any? { |a| a[:type] == :resource_depletion }).to be true
+    end
+
+    it 'detects emotional shock' do
+      client.update_resilience(tick_results: { emotional_evaluation: { arousal: 0.95 } })
+      expect(client.adversity_tracker.active_adversities.any? { |a| a[:type] == :emotional_shock }).to be true
+    end
+  end
+
+  describe 'recovery over time' do
+    it 'resolves adversities after enough ticks' do
+      client.register_adversity(type: :prediction_failure, severity: :minor)
+      20.times { client.update_resilience(tick_results: normal_tick) }
+      expect(client.adversity_tracker.active_adversities).to be_empty
+    end
+
+    it 'builds growth bonus from consecutive recoveries' do
+      3.times do
+        client.register_adversity(type: :prediction_failure, severity: :minor)
+        20.times { client.update_resilience(tick_results: normal_tick) }
+      end
+      expect(client.resilience_model.growth_bonus).to be > 0.0
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to present_input' do
+    expect(client).to respond_to(:present_input)
+  end
+
+  it 'responds to classify' do
+    expect(client).to respond_to(:classify)
+  end
+
+  it 'responds to adjust_vigilance' do
+    expect(client).to respond_to(:adjust_vigilance)
+  end
+
+  it 'responds to resonance_report' do
+    expect(client).to respond_to(:resonance_report)
+  end
+
+  it 'responds to category_count' do
+    expect(client).to respond_to(:category_count)
+  end
+
+  it 'responds to reset_engine' do
+    expect(client).to respond_to(:reset_engine)
+  end
+
+  it 'round-trips a full resonance cycle' do
+    # Present a pattern and create a category
+    r1 = client.present_input(input: [0.9, 0.8, 0.7])
+    expect(r1[:outcome]).to eq(:new_category)
+
+    # Present same pattern — should resonate
+    r2 = client.present_input(input: [0.9, 0.8, 0.7])
+    expect(r2[:outcome]).to eq(:resonance)
+
+    # Classify the same pattern
+    c = client.classify(input: [0.9, 0.8, 0.7])
+    expect(c[:found]).to be(true)
+    expect(c[:quality]).to be > 0.9
+
+    # Get a report
+    report = client.resonance_report
+    expect(report[:category_count]).to be >= 1
+
+    # Adjust vigilance
+    v = client.adjust_vigilance(amount: 0.05)
+    expect(v[:success]).to be(true)
+  end
+
+  it 'each client instance has its own engine' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.present_input(input: [0.5, 0.5])
+    expect(c1.category_count[:count]).to eq(1)
+    expect(c2.category_count[:count]).to eq(0)
+  end
+
+  it 'reset_engine clears categories' do
+    client.present_input(input: [0.5, 0.5])
+    client.reset_engine
+    expect(client.category_count[:count]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/affect/resonance/cognitive_resonance_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance do
+  it 'defines VERSION' do
+    expect(described_class::VERSION).to eq('0.1.0')
+  end
+
+  it 'provides the Client class' do
+    expect(described_class::Client).to be_a(Class)
+  end
+
+  it 'provides Helpers::Constants module' do
+    expect(described_class::Helpers::Constants).to be_a(Module)
+  end
+
+  it 'provides Helpers::Category class' do
+    expect(described_class::Helpers::Category).to be_a(Class)
+  end
+
+  it 'provides Helpers::ResonanceEngine class' do
+    expect(described_class::Helpers::ResonanceEngine).to be_a(Class)
+  end
+
+  it 'provides Runners::CognitiveResonance module' do
+    expect(described_class::Runners::CognitiveResonance).to be_a(Module)
+  end
+end