lex-agentic-executive 0.1.0

data/spec/legion/extensions/agentic/executive/dual_process/helpers/heuristic_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Heuristic do
+  let(:heuristic) do
+    described_class.new(pattern: 'greeting', domain: :social, response: :wave)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(heuristic.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores pattern, domain, and response' do
+      expect(heuristic.pattern).to eq('greeting')
+      expect(heuristic.domain).to eq(:social)
+      expect(heuristic.response).to eq(:wave)
+    end
+
+    it 'defaults confidence to DEFAULT_CONFIDENCE' do
+      expect(heuristic.confidence).to eq(Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::DEFAULT_CONFIDENCE)
+    end
+
+    it 'accepts custom confidence' do
+      h = described_class.new(pattern: :x, domain: :d, response: :r, confidence: 0.8)
+      expect(h.confidence).to eq(0.8)
+    end
+
+    it 'clamps confidence to floor' do
+      h = described_class.new(pattern: :x, domain: :d, response: :r, confidence: -1.0)
+      expect(h.confidence).to eq(Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::CONFIDENCE_FLOOR)
+    end
+
+    it 'clamps confidence to ceiling' do
+      h = described_class.new(pattern: :x, domain: :d, response: :r, confidence: 2.0)
+      expect(h.confidence).to eq(Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::CONFIDENCE_CEILING)
+    end
+
+    it 'starts with zero use_count and success_count' do
+      expect(heuristic.use_count).to eq(0)
+      expect(heuristic.success_count).to eq(0)
+    end
+
+    it 'sets created_at' do
+      expect(heuristic.created_at).to be_a(Time)
+    end
+
+    it 'starts with nil last_used_at' do
+      expect(heuristic.last_used_at).to be_nil
+    end
+  end
+
+  describe '#use!' do
+    it 'increments use_count' do
+      heuristic.use!(success: true)
+      expect(heuristic.use_count).to eq(1)
+    end
+
+    it 'increments success_count on success' do
+      heuristic.use!(success: true)
+      expect(heuristic.success_count).to eq(1)
+    end
+
+    it 'does not increment success_count on failure' do
+      heuristic.use!(success: false)
+      expect(heuristic.success_count).to eq(0)
+    end
+
+    it 'sets last_used_at' do
+      heuristic.use!(success: true)
+      expect(heuristic.last_used_at).to be_a(Time)
+    end
+
+    it 'boosts confidence on success' do
+      original = heuristic.confidence
+      heuristic.use!(success: true)
+      expect(heuristic.confidence).to be > original
+    end
+
+    it 'reduces confidence on failure' do
+      original = heuristic.confidence
+      heuristic.use!(success: false)
+      expect(heuristic.confidence).to be < original
+    end
+
+    it 'does not exceed CONFIDENCE_CEILING' do
+      10.times { heuristic.use!(success: true) }
+      expect(heuristic.confidence).to be <= Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::CONFIDENCE_CEILING
+    end
+
+    it 'does not go below CONFIDENCE_FLOOR' do
+      10.times { heuristic.use!(success: false) }
+      expect(heuristic.confidence).to be >= Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::CONFIDENCE_FLOOR
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no uses' do
+      expect(heuristic.success_rate).to eq(0.0)
+    end
+
+    it 'computes ratio correctly' do
+      2.times { heuristic.use!(success: true) }
+      heuristic.use!(success: false)
+      expect(heuristic.success_rate).to be_within(0.001).of(2.0 / 3.0)
+    end
+  end
+
+  describe '#reliable?' do
+    it 'returns false with no uses' do
+      expect(heuristic.reliable?).to be false
+    end
+
+    it 'returns false with fewer than 3 uses' do
+      2.times { heuristic.use!(success: true) }
+      expect(heuristic.reliable?).to be false
+    end
+
+    it 'returns true with high success rate and enough uses' do
+      5.times { heuristic.use!(success: true) }
+      expect(heuristic.reliable?).to be true
+    end
+
+    it 'returns false with low success rate even with many uses' do
+      5.times { heuristic.use!(success: false) }
+      expect(heuristic.reliable?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all key fields' do
+      result = heuristic.to_h
+      expect(result).to include(:id, :pattern, :domain, :response, :confidence,
+                                :use_count, :success_count, :success_rate, :reliable,
+                                :created_at, :last_used_at)
+    end
+
+    it 'reflects current state' do
+      heuristic.use!(success: true)
+      result = heuristic.to_h
+      expect(result[:use_count]).to eq(1)
+      expect(result[:success_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/dual_process/runners/dual_process_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/dual_process/client'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::DualProcess::Runners::DualProcess do
+  let(:client) { Legion::Extensions::Agentic::Executive::DualProcess::Client.new }
+
+  describe '#register_heuristic' do
+    it 'returns success: true' do
+      result = client.register_heuristic(pattern: 'hello', domain: :social, response: :wave)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns heuristic data' do
+      result = client.register_heuristic(pattern: 'hello', domain: :social, response: :wave)
+      expect(result[:heuristic]).to include(:id, :pattern, :domain, :response, :confidence)
+    end
+
+    it 'accepts custom confidence' do
+      result = client.register_heuristic(pattern: :x, domain: :d, response: :r, confidence: 0.9)
+      expect(result[:heuristic][:confidence]).to eq(0.9)
+    end
+
+    it 'ignores nil confidence and uses default' do
+      result = client.register_heuristic(pattern: :x, domain: :d, response: :r, confidence: nil)
+      expect(result[:heuristic][:confidence]).to eq(Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::DEFAULT_CONFIDENCE)
+    end
+  end
+
+  describe '#route_decision' do
+    it 'returns success: true' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a system key' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(Legion::Extensions::Agentic::Executive::DualProcess::Helpers::Constants::SYSTEMS).to include(result[:system])
+    end
+
+    it 'returns a reason' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(result[:reason]).not_to be_nil
+    end
+  end
+
+  describe '#execute_system_one' do
+    it 'returns success: true' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns system: :system_one' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:system]).to eq(:system_one)
+    end
+
+    it 'returns a decision_id' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:decision_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#execute_system_two' do
+    it 'returns success: true' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns system: :system_two' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:system]).to eq(:system_two)
+    end
+
+    it 'returns a decision_id' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:decision_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'accepts deliberation context' do
+      result = client.execute_system_two(
+        query: 'complex', domain: :work,
+        deliberation: { confidence: 0.9, response: :approved }
+      )
+      expect(result[:confidence]).to eq(0.9)
+      expect(result[:response]).to eq(:approved)
+    end
+  end
+
+  describe '#record_decision_outcome' do
+    it 'returns success for known decision' do
+      exec = client.execute_system_one(query: 'x', domain: :d)
+      result = client.record_decision_outcome(decision_id: exec[:decision_id], outcome: :correct)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown decision' do
+      result = client.record_decision_outcome(decision_id: 'bogus-id', outcome: :correct)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#effort_assessment' do
+    it 'returns success: true' do
+      result = client.effort_assessment
+      expect(result[:success]).to be true
+    end
+
+    it 'includes effort_level' do
+      result = client.effort_assessment
+      expect(result[:effort_level]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes routing_label' do
+      result = client.effort_assessment
+      expect(result[:routing_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#best_heuristics' do
+    it 'returns success: true' do
+      result = client.best_heuristics
+      expect(result[:success]).to be true
+    end
+
+    it 'returns heuristics array' do
+      result = client.best_heuristics
+      expect(result[:heuristics]).to be_an(Array)
+    end
+
+    it 'respects custom limit' do
+      5.times do |i|
+        client.register_heuristic(pattern: "p#{i}", domain: :d, response: :r, confidence: 0.9)
+      end
+      engine = client.send(:engine)
+      engine.instance_variable_get(:@heuristics).each_value do |h|
+        5.times { h.use!(success: true) }
+      end
+      result = client.best_heuristics(limit: 2)
+      expect(result[:heuristics].size).to be <= 2
+    end
+  end
+
+  describe '#system_usage_stats' do
+    it 'returns success: true' do
+      result = client.system_usage_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes stats hash' do
+      result = client.system_usage_stats
+      expect(result[:stats]).to include(:system_one, :system_two, :total)
+    end
+  end
+
+  describe '#update_dual_process' do
+    it 'returns success: true' do
+      result = client.update_dual_process
+      expect(result[:success]).to be true
+    end
+
+    it 'recovers effort' do
+      client.execute_system_two(query: 'x', domain: :d)
+      before = client.effort_assessment[:effort_level]
+      client.update_dual_process
+      after = client.effort_assessment[:effort_level]
+      expect(after).to be >= before
+    end
+
+    it 'returns routing_label' do
+      result = client.update_dual_process
+      expect(result[:routing_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#dual_process_stats' do
+    it 'returns success: true' do
+      result = client.dual_process_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes full stats' do
+      result = client.dual_process_stats
+      expect(result).to include(:effort_budget, :effort_level, :routing_label,
+                                :heuristic_count, :decision_count, :system_stats)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/dwell/cognitive_dwell_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Dwell do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Executive::Dwell::VERSION).to eq('0.1.0')
+  end
+end

data/spec/legion/extensions/agentic/executive/dwell/helpers/dwell_engine_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Dwell::Helpers::DwellEngine do
+  subject(:engine) { described_class.new }
+
+  let(:problem) { engine.add_topic(content: 'hard bug', topic_type: :problem, salience: 0.8, emotional_intensity: 0.6) }
+  let(:idea) { engine.add_topic(content: 'new feature', topic_type: :concept, novelty: 0.9) }
+
+  describe '#add_topic' do
+    it 'creates a dwell topic' do
+      topic = engine.add_topic(content: 'test')
+      expect(topic).to be_a(Legion::Extensions::Agentic::Executive::Dwell::Helpers::DwellTopic)
+    end
+  end
+
+  describe '#focus_on' do
+    it 'engages the topic' do
+      original = problem.dwell_level
+      engine.focus_on(topic_id: problem.id)
+      expect(problem.dwell_level).to be > original
+    end
+
+    it 'sets current topic' do
+      engine.focus_on(topic_id: problem.id)
+      expect(engine.current_topic.id).to eq(problem.id)
+    end
+
+    it 'returns nil for unknown topic' do
+      expect(engine.focus_on(topic_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#disengage' do
+    it 'reduces dwell level' do
+      engine.focus_on(topic_id: problem.id)
+      original = problem.dwell_level
+      engine.disengage(topic_id: problem.id)
+      expect(problem.dwell_level).to be < original
+    end
+
+    it 'clears current topic' do
+      engine.focus_on(topic_id: problem.id)
+      engine.disengage(topic_id: problem.id)
+      expect(engine.current_topic).to be_nil
+    end
+
+    it 'returns nil for unknown topic' do
+      expect(engine.disengage(topic_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays all topics' do
+      original = problem.dwell_level
+      engine.decay_all!
+      expect(problem.dwell_level).to be < original
+    end
+  end
+
+  describe '#current_topic' do
+    it 'returns nil initially' do
+      expect(engine.current_topic).to be_nil
+    end
+  end
+
+  describe '#sticky_topics' do
+    it 'returns topics with high dwell' do
+      high = engine.add_topic(content: 'crisis', salience: 0.9, novelty: 0.9,
+                              emotional_intensity: 0.9, complexity: 0.9)
+      3.times { engine.focus_on(topic_id: high.id) }
+      expect(engine.sticky_topics.map(&:id)).to include(high.id)
+    end
+  end
+
+  describe '#fleeting_topics' do
+    it 'returns heavily decayed topics' do
+      topic = engine.add_topic(content: 'minor thing', salience: 0.1, novelty: 0.1,
+                               emotional_intensity: 0.0, complexity: 0.1)
+      8.times { topic.decay! }
+      expect(engine.fleeting_topics.map(&:id)).to include(topic.id)
+    end
+  end
+
+  describe '#most_engaging' do
+    it 'returns topics sorted by dwell level' do
+      problem
+      idea
+      top = engine.most_engaging(limit: 1)
+      expect(top.size).to eq(1)
+    end
+  end
+
+  describe '#hardest_to_disengage' do
+    it 'returns topics sorted by difficulty' do
+      problem
+      idea
+      hard = engine.hardest_to_disengage(limit: 1)
+      expect(hard.size).to eq(1)
+    end
+  end
+
+  describe '#average_dwell' do
+    it 'returns base with no topics' do
+      base = Legion::Extensions::Agentic::Executive::Dwell::Helpers::Constants::BASE_DWELL
+      expect(engine.average_dwell).to eq(base)
+    end
+
+    it 'computes average' do
+      problem
+      idea
+      expect(engine.average_dwell).to be > 0
+    end
+  end
+
+  describe '#dwell_report' do
+    it 'returns comprehensive report' do
+      problem
+      report = engine.dwell_report
+      expect(report).to include(
+        :total_topics, :current_topic, :sticky_count, :fleeting_count,
+        :ruminating_count, :average_dwell, :average_disengagement_difficulty,
+        :most_engaging
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_topics, :current_topic_id, :sticky_count,
+        :ruminating_count, :average_dwell
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/dwell/helpers/dwell_topic_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Dwell::Helpers::DwellTopic do
+  subject(:topic) { described_class.new(content: 'test problem') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(topic.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets content' do
+      expect(topic.content).to eq('test problem')
+    end
+
+    it 'defaults to concept type' do
+      expect(topic.topic_type).to eq(:concept)
+    end
+
+    it 'computes initial dwell from weighted factors' do
+      expect(topic.dwell_level).to be > 0.0
+      expect(topic.dwell_level).to be <= 1.0
+    end
+
+    it 'high inputs produce higher dwell' do
+      high = described_class.new(content: 'x', salience: 0.9, novelty: 0.9,
+                                 emotional_intensity: 0.9, complexity: 0.9)
+      expect(high.dwell_level).to be > topic.dwell_level
+    end
+
+    it 'clamps values' do
+      high = described_class.new(content: 'x', salience: 5.0)
+      expect(high.salience).to eq(1.0)
+    end
+  end
+
+  describe '#engage!' do
+    it 'increases dwell level' do
+      original = topic.dwell_level
+      topic.engage!
+      expect(topic.dwell_level).to be > original
+    end
+
+    it 'increments engagement count' do
+      topic.engage!
+      expect(topic.engagement_count).to eq(1)
+    end
+
+    it 'clamps at 1.0' do
+      15.times { topic.engage! }
+      expect(topic.dwell_level).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces dwell level' do
+      original = topic.dwell_level
+      topic.decay!
+      expect(topic.dwell_level).to be < original
+    end
+
+    it 'reduces novelty' do
+      original = topic.novelty
+      topic.decay!
+      expect(topic.novelty).to be < original
+    end
+  end
+
+  describe '#disengage!' do
+    it 'reduces dwell level' do
+      original = topic.dwell_level
+      topic.disengage!
+      expect(topic.dwell_level).to be < original
+    end
+
+    it 'reduces more with force' do
+      t1 = described_class.new(content: 'a', salience: 0.8, emotional_intensity: 0.8)
+      t2 = described_class.new(content: 'b', salience: 0.8, emotional_intensity: 0.8)
+      t1.disengage!(force: 0.0)
+      t2.disengage!(force: 0.5)
+      expect(t2.dwell_level).to be < t1.dwell_level
+    end
+  end
+
+  describe '#sticky?' do
+    it 'is false for low-input topic' do
+      low = described_class.new(content: 'x', salience: 0.1, novelty: 0.1,
+                                emotional_intensity: 0.0, complexity: 0.1)
+      expect(low.sticky?).to be false
+    end
+
+    it 'is true for high-input topic' do
+      high = described_class.new(content: 'x', salience: 0.9, novelty: 0.9,
+                                 emotional_intensity: 0.9, complexity: 0.9)
+      expect(high.sticky?).to be true
+    end
+  end
+
+  describe '#fleeting?' do
+    it 'is false at moderate levels' do
+      expect(topic.fleeting?).to be false
+    end
+
+    it 'is true after heavy decay on low topic' do
+      low = described_class.new(content: 'x', salience: 0.1, novelty: 0.1,
+                                emotional_intensity: 0.0, complexity: 0.1)
+      5.times { low.decay! }
+      expect(low.fleeting?).to be true
+    end
+  end
+
+  describe '#ruminating?' do
+    it 'is false normally' do
+      expect(topic.ruminating?).to be false
+    end
+  end
+
+  describe '#disengagement_difficulty' do
+    it 'returns a value between 0 and 1' do
+      expect(topic.disengagement_difficulty).to be_between(0.0, 1.0)
+    end
+
+    it 'is higher with high emotion' do
+      emotional = described_class.new(content: 'x', emotional_intensity: 0.9)
+      calm = described_class.new(content: 'y', emotional_intensity: 0.1)
+      expect(emotional.disengagement_difficulty).to be > calm.disengagement_difficulty
+    end
+  end
+
+  describe '#dwell_label' do
+    it 'returns a symbol' do
+      expect(topic.dwell_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#engagement_label' do
+    it 'returns a symbol' do
+      expect(topic.engagement_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = topic.to_h
+      expect(hash).to include(
+        :id, :content, :topic_type, :salience, :novelty,
+        :emotional_intensity, :complexity, :dwell_level, :dwell_label,
+        :sticky, :fleeting, :ruminating, :disengagement_difficulty,
+        :disengage_label, :engagement_count, :engagement_label, :created_at
+      )
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/executive_function/client'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::ExecutiveFunction::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    %i[inhibit shift_task update_wm common_ef_status component_status
+       can_perform task_switch_cost executive_load
+       update_executive_function executive_function_stats].each do |method|
+      expect(client).to respond_to(method)
+    end
+  end
+
+  it 'maintains state across calls' do
+    client.inhibit(target: :noise)
+    stats = client.executive_function_stats
+    expect(stats[:inhibition_count]).to eq(1)
+  end
+
+  it 'full round-trip: inhibit -> shift -> update -> stats' do
+    client.inhibit(target: :distraction, reason: :prepotent)
+    client.shift_task(from: :idle, to: :active)
+    client.update_wm(slot: :focus, new_value: :high)
+
+    stats = client.executive_function_stats
+    expect(stats[:success]).to be true
+    expect(stats[:inhibition_count]).to eq(1)
+    expect(stats[:task_history_size]).to eq(1)
+    expect(stats[:update_count]).to eq(1)
+    expect(stats[:current_task_set]).to eq(:active)
+  end
+
+  it 'common EF level decreases under load' do
+    initial = client.common_ef_status[:common_ef_level]
+    15.times { client.inhibit(target: :x) }
+    expect(client.common_ef_status[:common_ef_level]).to be <= initial
+  end
+end