lex-agentic-executive 0.1.0

data/spec/legion/extensions/agentic/executive/inertia/helpers/inertia_engine_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inertia::Helpers::InertiaEngine do
+  subject(:engine) { described_class.new }
+
+  let(:belief) { engine.form_belief(content: 'test') }
+
+  describe '#form_belief' do
+    it 'returns a Belief' do
+      expect(belief).to be_a(Legion::Extensions::Agentic::Executive::Inertia::Helpers::Belief)
+    end
+
+    it 'stores the belief' do
+      belief
+      expect(engine.to_h[:total_beliefs]).to eq(1)
+    end
+  end
+
+  describe '#challenge_belief' do
+    it 'returns outcome and belief' do
+      result = engine.challenge_belief(belief_id: belief.id, strength: 0.5)
+      expect(result[:outcome]).to be_a(Symbol)
+      expect(result[:belief]).to be_a(Legion::Extensions::Agentic::Executive::Inertia::Helpers::Belief)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.challenge_belief(belief_id: 'fake')).to be_nil
+    end
+  end
+
+  describe '#reinforce_belief' do
+    it 'increases conviction' do
+      original = belief.conviction
+      engine.reinforce_belief(belief_id: belief.id)
+      expect(belief.conviction).to be > original
+    end
+  end
+
+  describe '#entrenched_beliefs' do
+    it 'returns only entrenched beliefs' do
+      b = engine.form_belief(content: 'strong', conviction: 0.9)
+      10.times { engine.reinforce_belief(belief_id: b.id) }
+      expect(engine.entrenched_beliefs).to include(b)
+    end
+  end
+
+  describe '#beliefs_by_domain' do
+    it 'filters by domain' do
+      engine.form_belief(content: 'causal', domain: :causal)
+      engine.form_belief(content: 'factual', domain: :factual)
+      result = engine.beliefs_by_domain(domain: :causal)
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#average_inertia' do
+    it 'returns default with no beliefs' do
+      default = Legion::Extensions::Agentic::Executive::Inertia::Helpers::Constants::DEFAULT_INERTIA
+      expect(engine.average_inertia).to eq(default)
+    end
+  end
+
+  describe '#overall_flexibility' do
+    it 'returns 0.5 with no beliefs' do
+      expect(engine.overall_flexibility).to eq(0.5)
+    end
+
+    it 'is inverse of average inertia' do
+      belief
+      expect(engine.overall_flexibility).to eq((1.0 - engine.average_inertia).round(10))
+    end
+  end
+
+  describe '#inertia_report' do
+    it 'includes all report fields' do
+      belief
+      report = engine.inertia_report
+      expect(report).to include(
+        :total_beliefs, :entrenched_count, :flexible_count,
+        :average_inertia, :average_conviction, :overall_flexibility,
+        :most_resistant
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_beliefs, :entrenched_count, :flexible_count,
+        :average_inertia, :overall_flexibility
+      )
+    end
+  end
+
+  describe 'pruning' do
+    it 'prunes most flexible belief when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Executive::Inertia::Helpers::Constants::MAX_BELIEFS', 3)
+      eng = described_class.new
+      4.times { |i| eng.form_belief(content: "b#{i}") }
+      expect(eng.to_h[:total_beliefs]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/inertia/runners/cognitive_inertia_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inertia::Runners::CognitiveInertia do
+  let(:client) { Legion::Extensions::Agentic::Executive::Inertia::Client.new }
+
+  describe '#form_belief' do
+    it 'returns success with belief hash' do
+      result = client.form_belief(content: 'test')
+      expect(result[:success]).to be true
+      expect(result[:belief]).to include(:id, :content, :conviction, :inertia)
+    end
+  end
+
+  describe '#challenge_belief' do
+    it 'returns outcome' do
+      b = client.form_belief(content: 'test')
+      result = client.challenge_belief(belief_id: b[:belief][:id], strength: 0.5)
+      expect(result[:success]).to be true
+      expect(result[:outcome]).to be_a(Symbol)
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.challenge_belief(belief_id: 'fake')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#reinforce_belief' do
+    it 'returns updated belief' do
+      b = client.form_belief(content: 'test')
+      result = client.reinforce_belief(belief_id: b[:belief][:id])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#entrenched_beliefs' do
+    it 'returns beliefs array' do
+      result = client.entrenched_beliefs
+      expect(result[:success]).to be true
+      expect(result[:beliefs]).to be_a(Array)
+    end
+  end
+
+  describe '#average_inertia' do
+    it 'returns inertia score' do
+      result = client.average_inertia
+      expect(result[:success]).to be true
+      expect(result[:inertia]).to be_a(Numeric)
+    end
+  end
+
+  describe '#inertia_report' do
+    it 'returns a full report' do
+      result = client.inertia_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_beliefs, :average_inertia)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/inhibition/client_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inhibition::Client do
+  describe '#initialize' do
+    it 'creates default inhibition store' do
+      client = described_class.new
+      expect(client.inhibition_store).to be_a(Legion::Extensions::Agentic::Executive::Inhibition::Helpers::InhibitionStore)
+    end
+
+    it 'accepts injected inhibition store' do
+      store  = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::InhibitionStore.new
+      client = described_class.new(inhibition_store: store)
+      expect(client.inhibition_store).to be(store)
+    end
+
+    it 'ignores unknown kwargs' do
+      expect { described_class.new(unknown: :value) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    let(:client) { described_class.new }
+
+    it { expect(client).to respond_to(:update_inhibition) }
+    it { expect(client).to respond_to(:evaluate_impulse) }
+    it { expect(client).to respond_to(:delay_gratification) }
+    it { expect(client).to respond_to(:check_stroop) }
+    it { expect(client).to respond_to(:willpower_status) }
+    it { expect(client).to respond_to(:inhibition_history) }
+    it { expect(client).to respond_to(:inhibition_stats) }
+  end
+
+  describe 'injected store is used by runner' do
+    it 'uses the injected store when evaluating impulses' do
+      store  = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::InhibitionStore.new
+      client = described_class.new(inhibition_store: store)
+      client.evaluate_impulse(action: :act, type: :reactive, strength: :mild)
+      expect(store.impulses.size).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/inhibition/helpers/constants_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Constants do
+  describe 'IMPULSE_TYPES' do
+    it 'defines 5 types' do
+      expect(described_class::IMPULSE_TYPES.size).to eq(5)
+    end
+
+    it 'includes reactive' do
+      expect(described_class::IMPULSE_TYPES).to include(:reactive)
+    end
+
+    it 'includes emotional' do
+      expect(described_class::IMPULSE_TYPES).to include(:emotional)
+    end
+
+    it 'is frozen' do
+      expect(described_class::IMPULSE_TYPES).to be_frozen
+    end
+  end
+
+  describe 'INHIBITION_STRATEGIES' do
+    it 'defines 5 strategies' do
+      expect(described_class::INHIBITION_STRATEGIES.size).to eq(5)
+    end
+
+    it 'includes suppression' do
+      expect(described_class::INHIBITION_STRATEGIES).to include(:suppression)
+    end
+
+    it 'includes delay' do
+      expect(described_class::INHIBITION_STRATEGIES).to include(:delay)
+    end
+
+    it 'is frozen' do
+      expect(described_class::INHIBITION_STRATEGIES).to be_frozen
+    end
+  end
+
+  describe 'IMPULSE_STRENGTHS' do
+    it 'defines 5 strength levels' do
+      expect(described_class::IMPULSE_STRENGTHS.size).to eq(5)
+    end
+
+    it 'has overwhelming at 1.0' do
+      expect(described_class::IMPULSE_STRENGTHS[:overwhelming]).to eq(1.0)
+    end
+
+    it 'has negligible as the lowest' do
+      expect(described_class::IMPULSE_STRENGTHS[:negligible]).to eq(0.1)
+    end
+
+    it 'has values in descending order' do
+      values = described_class::IMPULSE_STRENGTHS.values
+      expect(values).to eq(values.sort.reverse)
+    end
+
+    it 'is frozen' do
+      expect(described_class::IMPULSE_STRENGTHS).to be_frozen
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'defines INHIBITION_ALPHA' do
+      expect(described_class::INHIBITION_ALPHA).to eq(0.12)
+    end
+
+    it 'defines FATIGUE_PER_INHIBITION' do
+      expect(described_class::FATIGUE_PER_INHIBITION).to eq(0.05)
+    end
+
+    it 'defines FATIGUE_RECOVERY_RATE' do
+      expect(described_class::FATIGUE_RECOVERY_RATE).to eq(0.02)
+    end
+
+    it 'defines MAX_INHIBITION_LOG' do
+      expect(described_class::MAX_INHIBITION_LOG).to eq(200)
+    end
+
+    it 'defines WILLPOWER_THRESHOLD' do
+      expect(described_class::WILLPOWER_THRESHOLD).to eq(0.3)
+    end
+
+    it 'defines AUTOMATIC_SUPPRESS_THRESHOLD' do
+      expect(described_class::AUTOMATIC_SUPPRESS_THRESHOLD).to eq(0.2)
+    end
+
+    it 'defines DELAY_DISCOUNT_RATE' do
+      expect(described_class::DELAY_DISCOUNT_RATE).to eq(0.1)
+    end
+
+    it 'defines STROOP_CONFLICT_THRESHOLD' do
+      expect(described_class::STROOP_CONFLICT_THRESHOLD).to eq(0.6)
+    end
+  end
+
+  describe 'threshold relationships' do
+    it 'has AUTOMATIC_SUPPRESS below WILLPOWER_THRESHOLD' do
+      expect(described_class::AUTOMATIC_SUPPRESS_THRESHOLD).to be < described_class::WILLPOWER_THRESHOLD
+    end
+
+    it 'has WILLPOWER_THRESHOLD below 1.0' do
+      expect(described_class::WILLPOWER_THRESHOLD).to be < 1.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/inhibition/helpers/impulse_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse do
+  subject(:impulse) do
+    described_class.new(type: :reactive, action: :send_message, strength: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(impulse.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns type' do
+      expect(impulse.type).to eq(:reactive)
+    end
+
+    it 'assigns action' do
+      expect(impulse.action).to eq(:send_message)
+    end
+
+    it 'assigns strength' do
+      expect(impulse.strength).to eq(0.5)
+    end
+
+    it 'defaults source to nil' do
+      expect(impulse.source).to be_nil
+    end
+
+    it 'defaults context to empty hash' do
+      expect(impulse.context).to eq({})
+    end
+
+    it 'sets created_at' do
+      expect(impulse.created_at).to be_a(Time)
+    end
+
+    it 'accepts optional source' do
+      i = described_class.new(type: :emotional, action: :speak, strength: 0.3, source: :tick)
+      expect(i.source).to eq(:tick)
+    end
+
+    it 'accepts optional context' do
+      i = described_class.new(type: :social, action: :reply, strength: 0.4, context: { trigger: :mention })
+      expect(i.context[:trigger]).to eq(:mention)
+    end
+  end
+
+  describe '#overwhelming?' do
+    it 'returns true when strength >= 0.75' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.75)
+      expect(i.overwhelming?).to be true
+    end
+
+    it 'returns true for 1.0' do
+      i = described_class.new(type: :reactive, action: :act, strength: 1.0)
+      expect(i.overwhelming?).to be true
+    end
+
+    it 'returns false for moderate strength' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.5)
+      expect(i.overwhelming?).to be false
+    end
+
+    it 'returns false for mild strength' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.25)
+      expect(i.overwhelming?).to be false
+    end
+  end
+
+  describe '#auto_suppressible?' do
+    it 'returns true when strength <= 0.2' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.1)
+      expect(i.auto_suppressible?).to be true
+    end
+
+    it 'returns true at exactly 0.2' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.2)
+      expect(i.auto_suppressible?).to be true
+    end
+
+    it 'returns false for moderate strength' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.5)
+      expect(i.auto_suppressible?).to be false
+    end
+
+    it 'returns false for strong strength' do
+      i = described_class.new(type: :reactive, action: :act, strength: 0.8)
+      expect(i.auto_suppressible?).to be false
+    end
+  end
+
+  describe 'unique ids' do
+    it 'generates different ids for different instances' do
+      i1 = described_class.new(type: :reactive, action: :act, strength: 0.5)
+      i2 = described_class.new(type: :reactive, action: :act, strength: 0.5)
+      expect(i1.id).not_to eq(i2.id)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/inhibition/helpers/inhibition_model_spec.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Inhibition::Helpers::InhibitionModel do
+  subject(:model) { described_class.new }
+
+  let(:mild_impulse) do
+    Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+      type: :reactive, action: :act, strength: 0.25
+    )
+  end
+
+  let(:negligible_impulse) do
+    Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+      type: :reactive, action: :act, strength: 0.1
+    )
+  end
+
+  let(:strong_impulse) do
+    Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+      type: :emotional, action: :react, strength: 0.8
+    )
+  end
+
+  describe '#initialize' do
+    it 'starts willpower at 0.8' do
+      expect(model.willpower).to eq(0.8)
+    end
+
+    it 'starts with empty inhibition log' do
+      expect(model.inhibition_log).to be_empty
+    end
+
+    it 'starts suppressed count at 0' do
+      expect(model.suppressed_count).to eq(0)
+    end
+
+    it 'starts failed count at 0' do
+      expect(model.failed_count).to eq(0)
+    end
+
+    it 'starts redirected count at 0' do
+      expect(model.redirected_count).to eq(0)
+    end
+  end
+
+  describe '#evaluate_impulse' do
+    it 'returns :auto_suppress for auto-suppressible impulses' do
+      expect(model.evaluate_impulse(negligible_impulse)).to eq(:auto_suppress)
+    end
+
+    it 'returns :failed when willpower is exhausted' do
+      model.instance_variable_set(:@willpower, 0.1)
+      expect(model.evaluate_impulse(mild_impulse)).to eq(:failed)
+    end
+
+    it 'returns a valid strategy for normal impulses' do
+      strategies = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Constants::INHIBITION_STRATEGIES + %i[auto_suppress failed]
+      expect(strategies).to include(model.evaluate_impulse(mild_impulse))
+    end
+
+    it 'selects :redirect for habitual type' do
+      habitual = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :habitual, action: :routine, strength: 0.5
+      )
+      expect(model.evaluate_impulse(habitual)).to eq(:redirect)
+    end
+
+    it 'selects :delay for overwhelming emotional impulse' do
+      overwhelming = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :emotional, action: :react, strength: 0.9
+      )
+      expect(model.evaluate_impulse(overwhelming)).to eq(:delay)
+    end
+
+    it 'selects :suppression for non-overwhelming emotional impulse' do
+      moderate_emotional = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :emotional, action: :react, strength: 0.4
+      )
+      expect(model.evaluate_impulse(moderate_emotional)).to eq(:suppression)
+    end
+
+    it 'selects :substitute for social impulse' do
+      social = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :social, action: :conform, strength: 0.5
+      )
+      expect(model.evaluate_impulse(social)).to eq(:substitute)
+    end
+
+    it 'selects :defer for competitive impulse' do
+      competitive = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :competitive, action: :escalate, strength: 0.5
+      )
+      expect(model.evaluate_impulse(competitive)).to eq(:defer)
+    end
+
+    it 'selects :suppression for reactive impulse' do
+      reactive = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+        type: :reactive, action: :react, strength: 0.5
+      )
+      expect(model.evaluate_impulse(reactive)).to eq(:suppression)
+    end
+  end
+
+  describe '#apply_strategy' do
+    it 'returns a log entry hash' do
+      entry = model.apply_strategy(mild_impulse, :suppression)
+      expect(entry).to include(:impulse_id, :type, :action, :strength, :strategy, :willpower, :at)
+    end
+
+    it 'increments suppressed_count for suppression' do
+      model.apply_strategy(mild_impulse, :suppression)
+      expect(model.suppressed_count).to eq(1)
+    end
+
+    it 'increments failed_count for failed' do
+      model.apply_strategy(mild_impulse, :failed)
+      expect(model.failed_count).to eq(1)
+    end
+
+    it 'increments both redirected and suppressed for redirect' do
+      model.apply_strategy(mild_impulse, :redirect)
+      expect(model.redirected_count).to eq(1)
+      expect(model.suppressed_count).to eq(1)
+    end
+
+    it 'does not deplete willpower for auto_suppress' do
+      initial = model.willpower
+      model.apply_strategy(negligible_impulse, :auto_suppress)
+      expect(model.willpower).to eq(initial)
+    end
+
+    it 'depletes willpower for active strategies' do
+      initial = model.willpower
+      model.apply_strategy(strong_impulse, :suppression)
+      expect(model.willpower).to be < initial
+    end
+
+    it 'logs the entry' do
+      model.apply_strategy(mild_impulse, :suppression)
+      expect(model.inhibition_log.size).to eq(1)
+    end
+
+    it 'caps the log at MAX_INHIBITION_LOG' do
+      max = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Constants::MAX_INHIBITION_LOG
+      (max + 10).times do
+        imp = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Impulse.new(
+          type: :reactive, action: :act, strength: 0.25
+        )
+        model.apply_strategy(imp, :suppression)
+      end
+      expect(model.inhibition_log.size).to eq(max)
+    end
+  end
+
+  describe '#recover_willpower' do
+    it 'increases willpower by FATIGUE_RECOVERY_RATE' do
+      model.instance_variable_set(:@willpower, 0.5)
+      model.recover_willpower
+      expect(model.willpower).to be_within(0.001).of(0.52)
+    end
+
+    it 'caps at 1.0' do
+      model.instance_variable_set(:@willpower, 0.99)
+      model.recover_willpower
+      expect(model.willpower).to eq(1.0)
+    end
+  end
+
+  describe '#willpower_status' do
+    it 'returns :healthy when willpower >= 0.6' do
+      model.instance_variable_set(:@willpower, 0.7)
+      expect(model.willpower_status).to eq(:healthy)
+    end
+
+    it 'returns :depleted when willpower is between threshold and 0.6' do
+      model.instance_variable_set(:@willpower, 0.4)
+      expect(model.willpower_status).to eq(:depleted)
+    end
+
+    it 'returns :exhausted when willpower is below threshold' do
+      model.instance_variable_set(:@willpower, 0.1)
+      expect(model.willpower_status).to eq(:exhausted)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 1.0 with no attempts' do
+      expect(model.success_rate).to eq(1.0)
+    end
+
+    it 'returns ratio of suppressed to total' do
+      model.apply_strategy(mild_impulse, :suppression)
+      model.apply_strategy(mild_impulse, :failed)
+      expect(model.success_rate).to eq(0.5)
+    end
+
+    it 'returns 0.0 when all failed' do
+      3.times { model.apply_strategy(mild_impulse, :failed) }
+      expect(model.success_rate).to eq(0.0)
+    end
+  end
+
+  describe '#delay_discount' do
+    it 'returns full value at zero delay' do
+      expect(model.delay_discount(100.0, 0)).to eq(100.0)
+    end
+
+    it 'reduces value with delay' do
+      discounted = model.delay_discount(100.0, 5)
+      expect(discounted).to be < 100.0
+    end
+
+    it 'reduces value more with longer delay' do
+      short = model.delay_discount(100.0, 5)
+      long  = model.delay_discount(100.0, 20)
+      expect(long).to be < short
+    end
+
+    it 'uses DELAY_DISCOUNT_RATE' do
+      rate     = Legion::Extensions::Agentic::Executive::Inhibition::Helpers::Constants::DELAY_DISCOUNT_RATE
+      expected = 100.0 / (1.0 + (rate * 10))
+      expect(model.delay_discount(100.0, 10)).to be_within(0.001).of(expected)
+    end
+  end
+
+  describe '#stroop_conflict?' do
+    it 'returns false when responses match' do
+      expect(model.stroop_conflict?(:respond, :respond)).to be false
+    end
+
+    it 'returns true when responses differ and automatic is strong' do
+      automatic  = { strength: 0.8 }
+      controlled = { strength: 0.4 }
+      expect(model.stroop_conflict?(automatic, controlled)).to be true
+    end
+
+    it 'returns false when automatic strength is below threshold' do
+      automatic  = { strength: 0.3 }
+      controlled = { strength: 0.7 }
+      expect(model.stroop_conflict?(automatic, controlled)).to be false
+    end
+  end
+end