lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/coherence/runners/cognitive_coherence_spec.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/coherence/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Coherence::Runners::CognitiveCoherence do
+  let(:client) { Legion::Extensions::Agentic::Inference::Coherence::Client.new }
+
+  describe '#add_coherence_proposition' do
+    it 'adds a proposition and returns its id' do
+      result = client.add_coherence_proposition(content: 'The sky is blue', domain: :perception)
+      expect(result[:success]).to be true
+      expect(result[:proposition_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:domain]).to eq(:perception)
+    end
+
+    it 'uses default acceptance when none provided' do
+      result = client.add_coherence_proposition(content: 'Water is wet')
+      expect(result[:acceptance]).to eq(Legion::Extensions::Agentic::Inference::Coherence::Helpers::Constants::DEFAULT_ACCEPTANCE)
+    end
+
+    it 'accepts a custom acceptance value' do
+      result = client.add_coherence_proposition(content: 'Fire is hot', acceptance: 0.9)
+      expect(result[:acceptance]).to eq(0.9)
+    end
+
+    it 'returns failure for empty content' do
+      result = client.add_coherence_proposition(content: '')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:missing_content)
+    end
+
+    it 'accepts extra keyword arguments via splat' do
+      result = client.add_coherence_proposition(content: 'test', extra_param: 'ignored')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#add_coherence_constraint' do
+    let(:prop_a_id) { client.add_coherence_proposition(content: 'A')[:proposition_id] }
+    let(:prop_b_id) { client.add_coherence_proposition(content: 'B')[:proposition_id] }
+
+    it 'adds a positive coherence constraint between two propositions' do
+      result = client.add_coherence_constraint(
+        prop_a_id:       prop_a_id,
+        prop_b_id:       prop_b_id,
+        constraint_type: :explanatory,
+        positive:        true
+      )
+      expect(result[:success]).to be true
+      expect(result[:constraint_type]).to eq(:explanatory)
+      expect(result[:positive]).to be true
+    end
+
+    it 'adds a negative (incoherence) constraint' do
+      result = client.add_coherence_constraint(
+        prop_a_id:       prop_a_id,
+        prop_b_id:       prop_b_id,
+        constraint_type: :deductive,
+        positive:        false
+      )
+      expect(result[:success]).to be true
+      expect(result[:positive]).to be false
+    end
+
+    it 'rejects invalid constraint types' do
+      result = client.add_coherence_constraint(
+        prop_a_id:       prop_a_id,
+        prop_b_id:       prop_b_id,
+        constraint_type: :invalid_type
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:invalid_constraint_type)
+    end
+
+    it 'returns failure when proposition not found' do
+      result = client.add_coherence_constraint(
+        prop_a_id:       'nonexistent-id',
+        prop_b_id:       prop_b_id,
+        constraint_type: :explanatory
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:proposition_not_found)
+    end
+  end
+
+  describe '#compute_proposition_coherence' do
+    it 'computes coherence score for an existing proposition' do
+      result = client.add_coherence_proposition(content: 'test proposition', acceptance: 0.7)
+      prop_id = result[:proposition_id]
+
+      coherence = client.compute_proposition_coherence(proposition_id: prop_id)
+      expect(coherence[:success]).to be true
+      expect(coherence[:coherence_score]).to be_a(Float)
+      expect(coherence[:coherence_score]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns not_found for missing proposition' do
+      result = client.compute_proposition_coherence(proposition_id: 'no-such-id')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'increases coherence score when positive constraints are linked' do
+      prop_a = client.add_coherence_proposition(content: 'A', acceptance: 0.8)[:proposition_id]
+      prop_b = client.add_coherence_proposition(content: 'B', acceptance: 0.8)[:proposition_id]
+
+      score_before = client.compute_proposition_coherence(proposition_id: prop_a)[:coherence_score]
+
+      client.add_coherence_constraint(
+        prop_a_id:       prop_a,
+        prop_b_id:       prop_b,
+        constraint_type: :explanatory,
+        positive:        true
+      )
+
+      score_after = client.compute_proposition_coherence(proposition_id: prop_a)[:coherence_score]
+      expect(score_after).to be > score_before
+    end
+
+    it 'decreases coherence score when negative constraints are linked' do
+      prop_a = client.add_coherence_proposition(content: 'A', acceptance: 0.8)[:proposition_id]
+      prop_b = client.add_coherence_proposition(content: 'B', acceptance: 0.9)[:proposition_id]
+
+      score_before = client.compute_proposition_coherence(proposition_id: prop_a)[:coherence_score]
+
+      client.add_coherence_constraint(
+        prop_a_id:       prop_a,
+        prop_b_id:       prop_b,
+        constraint_type: :deductive,
+        positive:        false
+      )
+
+      score_after = client.compute_proposition_coherence(proposition_id: prop_a)[:coherence_score]
+      expect(score_after).to be < score_before
+    end
+  end
+
+  describe '#maximize_coherence' do
+    it 'returns success with iteration info when propositions exist' do
+      client.add_coherence_proposition(content: 'p1', acceptance: 0.7)
+      client.add_coherence_proposition(content: 'p2', acceptance: 0.3)
+
+      result = client.maximize_coherence
+      expect(result[:success]).to be true
+      expect(result[:proposition_count]).to eq(2)
+      expect(result[:overall_coherence]).to be_a(Float)
+    end
+
+    it 'returns success with zero iterations when no propositions' do
+      result = client.maximize_coherence
+      expect(result[:success]).to be true
+      expect(result[:iterations]).to eq(0)
+    end
+
+    it 'adjusts propositions toward coherent neighbors' do
+      prop_a = client.add_coherence_proposition(content: 'A', acceptance: 0.9)[:proposition_id]
+      prop_b = client.add_coherence_proposition(content: 'B', acceptance: 0.1)[:proposition_id]
+
+      client.add_coherence_constraint(
+        prop_a_id:       prop_a,
+        prop_b_id:       prop_b,
+        constraint_type: :explanatory,
+        positive:        true
+      )
+
+      client.maximize_coherence
+
+      prop_b_coherence = client.compute_proposition_coherence(proposition_id: prop_b)
+      expect(prop_b_coherence[:coherence_score]).to be > 0.1
+    end
+  end
+
+  describe '#find_contradictions' do
+    it 'returns empty list when no contradictions exist' do
+      client.add_coherence_proposition(content: 'p1', acceptance: 0.8)
+      result = client.find_contradictions
+      expect(result[:success]).to be true
+      expect(result[:contradictions]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'detects contradictory accepted propositions' do
+      prop_a = client.add_coherence_proposition(content: 'A', acceptance: 0.9)[:proposition_id]
+      prop_b = client.add_coherence_proposition(content: 'B', acceptance: 0.9)[:proposition_id]
+
+      client.add_coherence_constraint(
+        prop_a_id:       prop_a,
+        prop_b_id:       prop_b,
+        constraint_type: :deductive,
+        positive:        false
+      )
+
+      result = client.find_contradictions
+      expect(result[:count]).to eq(1)
+      expect(result[:contradictions].first).to include(:prop_a, :prop_b)
+    end
+
+    it 'does not flag contradictions when one proposition is rejected' do
+      prop_a = client.add_coherence_proposition(content: 'A', acceptance: 0.9)[:proposition_id]
+      prop_b = client.add_coherence_proposition(content: 'B', acceptance: 0.1)[:proposition_id]
+
+      client.add_coherence_constraint(
+        prop_a_id:       prop_a,
+        prop_b_id:       prop_b,
+        constraint_type: :deductive,
+        positive:        false
+      )
+
+      result = client.find_contradictions
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#coherence_partition' do
+    it 'partitions propositions by state' do
+      client.add_coherence_proposition(content: 'accepted', acceptance: 0.9)
+      client.add_coherence_proposition(content: 'rejected', acceptance: 0.1)
+      client.add_coherence_proposition(content: 'undecided', acceptance: 0.5)
+
+      result = client.coherence_partition
+      expect(result[:success]).to be true
+      expect(result[:counts][:accepted]).to be >= 1
+      expect(result[:counts][:rejected]).to be >= 1
+      expect(result[:counts][:undecided]).to be >= 1
+    end
+
+    it 'returns partition with proposition hashes' do
+      client.add_coherence_proposition(content: 'high', acceptance: 0.8)
+      result = client.coherence_partition
+      expect(result[:partition][:accepted].first).to include(:id, :content, :acceptance, :state)
+    end
+  end
+
+  describe '#update_cognitive_coherence' do
+    it 'runs maximize and decay, returning coherence info' do
+      client.add_coherence_proposition(content: 'p1', acceptance: 0.8)
+      client.add_coherence_proposition(content: 'p2', acceptance: 0.2)
+
+      result = client.update_cognitive_coherence
+      expect(result[:success]).to be true
+      expect(result[:overall_coherence]).to be_a(Float)
+      expect(result[:coherence_label]).to be_a(Symbol)
+      expect(result).to have_key(:decayed_count)
+    end
+  end
+
+  describe '#cognitive_coherence_stats' do
+    it 'returns stats summary' do
+      client.add_coherence_proposition(content: 'stat test', acceptance: 0.7)
+
+      result = client.cognitive_coherence_stats
+      expect(result[:success]).to be true
+      expect(result[:proposition_count]).to eq(1)
+      expect(result[:overall_coherence]).to be_a(Float)
+      expect(result[:coherence_label]).to be_a(Symbol)
+      expect(result[:partition_counts]).to be_a(Hash)
+      expect(result[:contradiction_count]).to be_a(Integer)
+      expect(result[:history_size]).to be_a(Integer)
+    end
+
+    it 'reports zero when no propositions' do
+      result = client.cognitive_coherence_stats
+      expect(result[:proposition_count]).to eq(0)
+      expect(result[:overall_coherence]).to eq(0.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/counterfactual/client_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Counterfactual::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to imagine_counterfactual' do
+    expect(client).to respond_to(:imagine_counterfactual)
+  end
+
+  it 'responds to generate_alternatives' do
+    expect(client).to respond_to(:generate_alternatives)
+  end
+
+  it 'responds to resolve_counterfactual' do
+    expect(client).to respond_to(:resolve_counterfactual)
+  end
+
+  it 'responds to compute_regret' do
+    expect(client).to respond_to(:compute_regret)
+  end
+
+  it 'responds to net_regret_level' do
+    expect(client).to respond_to(:net_regret_level)
+  end
+
+  it 'responds to domain_regret' do
+    expect(client).to respond_to(:domain_regret)
+  end
+
+  it 'responds to lessons_learned' do
+    expect(client).to respond_to(:lessons_learned)
+  end
+
+  it 'responds to update_counterfactual' do
+    expect(client).to respond_to(:update_counterfactual)
+  end
+
+  it 'responds to counterfactual_stats' do
+    expect(client).to respond_to(:counterfactual_stats)
+  end
+
+  it 'accepts an injected engine' do
+    fake_engine = Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::CounterfactualEngine.new
+    client_with_engine = described_class.new(engine: fake_engine)
+    result = client_with_engine.counterfactual_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/inference/counterfactual/helpers/constants_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::Constants do
+  subject(:klass) do
+    Class.new { include Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::Constants }
+  end
+
+  it 'defines MAX_SCENARIOS' do
+    expect(klass::MAX_SCENARIOS).to eq(200)
+  end
+
+  it 'defines MAX_HISTORY' do
+    expect(klass::MAX_HISTORY).to eq(300)
+  end
+
+  it 'defines MAX_ALTERNATIVES' do
+    expect(klass::MAX_ALTERNATIVES).to eq(10)
+  end
+
+  it 'defines PLAUSIBILITY_THRESHOLD' do
+    expect(klass::PLAUSIBILITY_THRESHOLD).to eq(0.4)
+  end
+
+  it 'defines RELEVANCE_THRESHOLD' do
+    expect(klass::RELEVANCE_THRESHOLD).to eq(0.3)
+  end
+
+  it 'defines REGRET_DECAY' do
+    expect(klass::REGRET_DECAY).to eq(0.02)
+  end
+
+  it 'defines UPWARD_WEIGHT as 0.7' do
+    expect(klass::UPWARD_WEIGHT).to eq(0.7)
+  end
+
+  it 'defines DOWNWARD_WEIGHT as 0.3' do
+    expect(klass::DOWNWARD_WEIGHT).to eq(0.3)
+  end
+
+  it 'defines all COUNTERFACTUAL_TYPES' do
+    expect(klass::COUNTERFACTUAL_TYPES).to include(:upward, :downward, :additive, :subtractive, :semifactual,
+                                                   :prefactual)
+  end
+
+  it 'defines all MUTATION_TYPES' do
+    expect(klass::MUTATION_TYPES).to include(:action, :inaction, :antecedent, :outcome, :context, :agent)
+  end
+
+  it 'defines EMOTIONAL_RESPONSES mapping' do
+    expect(klass::EMOTIONAL_RESPONSES[:upward]).to eq(:regret)
+    expect(klass::EMOTIONAL_RESPONSES[:downward]).to eq(:relief)
+    expect(klass::EMOTIONAL_RESPONSES[:semifactual]).to eq(:acceptance)
+    expect(klass::EMOTIONAL_RESPONSES[:prefactual]).to eq(:anxiety)
+  end
+end

data/spec/legion/extensions/agentic/inference/counterfactual/helpers/counterfactual_engine_spec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::CounterfactualEngine do
+  subject(:engine) { described_class.new }
+
+  let(:base_generate_params) do
+    {
+      actual_outcome:         'task failed',
+      counterfactual_outcome: 'task succeeded',
+      antecedent:             'had more time',
+      scenario_type:          :upward,
+      mutation_type:          :action,
+      domain:                 :work,
+      plausibility:           0.75,
+      regret_magnitude:       0.6
+    }
+  end
+
+  describe '#initialize' do
+    it 'starts with empty scenarios' do
+      expect(engine.scenarios).to be_empty
+    end
+  end
+
+  describe '#generate' do
+    it 'returns a Scenario instance' do
+      result = engine.generate(**base_generate_params)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::Scenario)
+    end
+
+    it 'stores the scenario' do
+      scenario = engine.generate(**base_generate_params)
+      expect(engine.scenarios[scenario.id]).to eq(scenario)
+    end
+
+    it 'increments scenario count' do
+      engine.generate(**base_generate_params)
+      engine.generate(**base_generate_params, scenario_type: :downward)
+      expect(engine.scenarios.size).to eq(2)
+    end
+  end
+
+  describe '#generate_alternatives' do
+    it 'returns an array of scenarios' do
+      result = engine.generate_alternatives(actual_outcome: 'outcome', domain: :testing)
+      expect(result).to all(be_a(Legion::Extensions::Agentic::Inference::Counterfactual::Helpers::Scenario))
+    end
+
+    it 'stores all generated alternatives' do
+      result = engine.generate_alternatives(actual_outcome: 'outcome', domain: :testing)
+      result.each { |s| expect(engine.scenarios[s.id]).to eq(s) }
+    end
+
+    it 'generates both upward and downward types' do
+      result = engine.generate_alternatives(actual_outcome: 'outcome', domain: :testing)
+      types = result.map(&:scenario_type).uniq
+      expect(types).to include(:upward, :downward)
+    end
+
+    it 'uses the provided domain' do
+      result = engine.generate_alternatives(actual_outcome: 'outcome', domain: :ops)
+      expect(result.all? { |s| s.domain == :ops }).to be true
+    end
+  end
+
+  describe '#resolve' do
+    it 'resolves an existing scenario with a lesson' do
+      scenario = engine.generate(**base_generate_params)
+      result = engine.resolve(scenario_id: scenario.id, lesson: 'plan ahead')
+      expect(result.resolved).to be true
+      expect(result.lesson).to eq('plan ahead')
+    end
+
+    it 'returns nil for unknown scenario_id' do
+      result = engine.resolve(scenario_id: 'nonexistent', lesson: 'lesson')
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#compute_regret' do
+    it 'computes positive regret for upward scenario' do
+      scenario = engine.generate(**base_generate_params, scenario_type: :upward)
+      regret = engine.compute_regret(scenario_id: scenario.id)
+      expect(regret).to be > 0
+    end
+
+    it 'computes negative regret (relief) for downward scenario' do
+      scenario = engine.generate(**base_generate_params, scenario_type: :downward)
+      regret = engine.compute_regret(scenario_id: scenario.id)
+      expect(regret).to be < 0
+    end
+
+    it 'returns 0.0 for unknown scenario' do
+      expect(engine.compute_regret(scenario_id: 'missing')).to eq(0.0)
+    end
+
+    it 'returns 0.0 for non-upward/downward types' do
+      scenario = engine.generate(**base_generate_params, scenario_type: :semifactual)
+      expect(engine.compute_regret(scenario_id: scenario.id)).to eq(0.0)
+    end
+
+    it 'upward regret uses UPWARD_WEIGHT * magnitude * plausibility' do
+      scenario = engine.generate(**base_generate_params, scenario_type:    :upward,
+                                                         regret_magnitude: 0.5,
+                                                         plausibility:     1.0)
+      expected = 0.5 * 0.7 * 1.0
+      expect(engine.compute_regret(scenario_id: scenario.id)).to be_within(0.001).of(expected)
+    end
+  end
+
+  describe '#net_regret' do
+    it 'sums regret across all unresolved scenarios' do
+      engine.generate(**base_generate_params, scenario_type: :upward)
+      engine.generate(**base_generate_params, scenario_type: :downward)
+      net = engine.net_regret
+      expect(net).to be_a(Float)
+    end
+
+    it 'returns 0.0 when there are no scenarios' do
+      expect(engine.net_regret).to eq(0.0)
+    end
+
+    it 'excludes resolved scenarios' do
+      scenario = engine.generate(**base_generate_params, scenario_type: :upward)
+      engine.resolve(scenario_id: scenario.id, lesson: 'learned')
+      expect(engine.net_regret).to eq(0.0)
+    end
+  end
+
+  describe '#domain_regret' do
+    it 'returns regret only for matching domain' do
+      engine.generate(**base_generate_params, domain: :work)
+      engine.generate(**base_generate_params, domain: :personal, scenario_type: :downward)
+      work_regret = engine.domain_regret(domain: :work)
+      expect(work_regret).to be_a(Float)
+    end
+
+    it 'returns 0.0 for domain with no scenarios' do
+      expect(engine.domain_regret(domain: :unknown)).to eq(0.0)
+    end
+  end
+
+  describe '#lessons_learned' do
+    it 'returns only resolved scenarios with lessons' do
+      s1 = engine.generate(**base_generate_params)
+      engine.generate(**base_generate_params, scenario_type: :downward)
+      engine.resolve(scenario_id: s1.id, lesson: 'be more careful')
+      lessons = engine.lessons_learned
+      expect(lessons.size).to eq(1)
+      expect(lessons.first.lesson).to eq('be more careful')
+    end
+
+    it 'returns empty array when no lessons' do
+      engine.generate(**base_generate_params)
+      expect(engine.lessons_learned).to be_empty
+    end
+  end
+
+  describe '#regret_decay' do
+    it 'reduces regret_magnitude on unresolved scenarios' do
+      scenario = engine.generate(**base_generate_params, regret_magnitude: 0.5)
+      engine.regret_decay
+      expect(scenario.regret_magnitude).to be < 0.5
+    end
+
+    it 'does not decay below REGRET_FLOOR' do
+      scenario = engine.generate(**base_generate_params, regret_magnitude: 0.0)
+      engine.regret_decay
+      expect(scenario.regret_magnitude).to eq(0.0)
+    end
+
+    it 'does not decay resolved scenarios' do
+      scenario = engine.generate(**base_generate_params, regret_magnitude: 0.5)
+      engine.resolve(scenario_id: scenario.id, lesson: 'learned')
+      engine.regret_decay
+      expect(scenario.regret_magnitude).to eq(0.5)
+    end
+  end
+
+  describe '#by_type' do
+    it 'returns scenarios matching type' do
+      engine.generate(**base_generate_params, scenario_type: :upward)
+      engine.generate(**base_generate_params, scenario_type: :downward)
+      upward = engine.by_type(type: :upward)
+      expect(upward.all? { |s| s.scenario_type == :upward }).to be true
+      expect(upward.size).to eq(1)
+    end
+  end
+
+  describe '#by_domain' do
+    it 'returns scenarios matching domain' do
+      engine.generate(**base_generate_params, domain: :work)
+      engine.generate(**base_generate_params, domain: :home)
+      work = engine.by_domain(domain: :work)
+      expect(work.size).to eq(1)
+      expect(work.first.domain).to eq(:work)
+    end
+  end
+
+  describe '#unresolved' do
+    it 'returns only unresolved scenarios' do
+      s1 = engine.generate(**base_generate_params)
+      engine.generate(**base_generate_params, scenario_type: :downward)
+      engine.resolve(scenario_id: s1.id, lesson: 'lesson')
+      expect(engine.unresolved.size).to eq(1)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns last n scenarios by created_at' do
+      3.times { engine.generate(**base_generate_params) }
+      result = engine.recent(count: 2)
+      expect(result.size).to eq(2)
+    end
+
+    it 'returns all when count > total' do
+      engine.generate(**base_generate_params)
+      result = engine.recent(count: 10)
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a stats summary hash' do
+      engine.generate(**base_generate_params)
+      h = engine.to_h
+      expect(h[:total]).to eq(1)
+      expect(h[:unresolved]).to eq(1)
+      expect(h[:resolved]).to eq(0)
+      expect(h[:net_regret]).to be_a(Float)
+      expect(h[:by_type]).to be_a(Hash)
+    end
+  end
+end