lex-agentic-executive 0.1.0

data/lib/legion/extensions/agentic/executive/inertia/helpers/belief.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+          module Helpers
+            class Belief
+              include Constants
+
+              attr_reader :id, :content, :domain, :conviction, :inertia,
+                          :challenges_resisted, :challenges_accepted, :created_at
+
+              def initialize(content:, domain: :factual, conviction: 0.5)
+                @id                  = SecureRandom.uuid
+                @content             = content
+                @domain              = domain.to_sym
+                @conviction          = conviction.to_f.clamp(0.0, 1.0)
+                @inertia             = DEFAULT_INERTIA
+                @challenges_resisted = 0
+                @challenges_accepted = 0
+                @created_at          = Time.now.utc
+              end
+
+              def challenge!(strength: 0.5)
+                effective = (strength * (1.0 - @inertia)).round(10)
+                if effective > @conviction * 0.5
+                  @conviction = (@conviction - (effective * 0.3)).clamp(0.0, 1.0).round(10)
+                  @challenges_accepted += 1
+                  @inertia = (@inertia - INERTIA_REDUCTION_RATE).clamp(0.0, 1.0).round(10)
+                  :accepted
+                else
+                  @challenges_resisted += 1
+                  @inertia = (@inertia + INERTIA_GROWTH_RATE).clamp(0.0, 1.0).round(10)
+                  :resisted
+                end
+              end
+
+              def reinforce!(amount: 0.1)
+                @conviction = (@conviction + amount).clamp(0.0, 1.0).round(10)
+                @inertia = (@inertia + INERTIA_GROWTH_RATE).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def entrenched?
+                @inertia >= CONVICTION_THRESHOLD
+              end
+
+              def flexible?
+                @inertia <= FLEXIBILITY_THRESHOLD
+              end
+
+              def total_challenges
+                @challenges_resisted + @challenges_accepted
+              end
+
+              def resistance_rate
+                return 0.0 if total_challenges.zero?
+
+                (@challenges_resisted.to_f / total_challenges).round(4)
+              end
+
+              def inertia_label
+                match = INERTIA_LABELS.find { |range, _| range.cover?(@inertia) }
+                match ? match.last : :fluid
+              end
+
+              def conviction_label
+                match = CONVICTION_LABELS.find { |range, _| range.cover?(@conviction) }
+                match ? match.last : :uncertain
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  content:             @content,
+                  domain:              @domain,
+                  conviction:          @conviction,
+                  conviction_label:    conviction_label,
+                  inertia:             @inertia,
+                  inertia_label:       inertia_label,
+                  entrenched:          entrenched?,
+                  flexible:            flexible?,
+                  challenges_resisted: @challenges_resisted,
+                  challenges_accepted: @challenges_accepted,
+                  resistance_rate:     resistance_rate,
+                  created_at:          @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inertia/helpers/constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+          module Helpers
+            module Constants
+              MAX_BELIEFS = 300
+              MAX_CHALLENGES = 500
+
+              DEFAULT_INERTIA = 0.5
+              INERTIA_GROWTH_RATE = 0.03
+              INERTIA_REDUCTION_RATE = 0.05
+              CONVICTION_THRESHOLD = 0.8
+              FLEXIBILITY_THRESHOLD = 0.3
+
+              INERTIA_LABELS = {
+                (0.8..)     => :entrenched,
+                (0.6...0.8) => :resistant,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :flexible,
+                (..0.2)     => :fluid
+              }.freeze
+
+              CONVICTION_LABELS = {
+                (0.8..)     => :absolute,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :tentative,
+                (..0.2)     => :uncertain
+              }.freeze
+
+              BELIEF_DOMAINS = %i[
+                factual causal procedural evaluative
+                social predictive normative
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inertia/helpers/inertia_engine.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+          module Helpers
+            class InertiaEngine
+              include Constants
+
+              def initialize
+                @beliefs = {}
+              end
+
+              def form_belief(content:, domain: :factual, conviction: 0.5)
+                prune_if_needed
+                belief = Belief.new(content: content, domain: domain, conviction: conviction)
+                @beliefs[belief.id] = belief
+                belief
+              end
+
+              def challenge_belief(belief_id:, strength: 0.5)
+                belief = @beliefs[belief_id]
+                return nil unless belief
+
+                outcome = belief.challenge!(strength: strength)
+                { outcome: outcome, belief: belief }
+              end
+
+              def reinforce_belief(belief_id:, amount: 0.1)
+                belief = @beliefs[belief_id]
+                return nil unless belief
+
+                belief.reinforce!(amount: amount)
+              end
+
+              def entrenched_beliefs
+                @beliefs.values.select(&:entrenched?)
+              end
+
+              def flexible_beliefs
+                @beliefs.values.select(&:flexible?)
+              end
+
+              def beliefs_by_domain(domain:)
+                d = domain.to_sym
+                @beliefs.values.select { |b| b.domain == d }
+              end
+
+              def most_resistant(limit: 5)
+                @beliefs.values.sort_by { |b| -b.resistance_rate }.first(limit)
+              end
+
+              def average_inertia
+                return DEFAULT_INERTIA if @beliefs.empty?
+
+                inertias = @beliefs.values.map(&:inertia)
+                (inertias.sum / inertias.size).round(10)
+              end
+
+              def average_conviction
+                return 0.5 if @beliefs.empty?
+
+                convictions = @beliefs.values.map(&:conviction)
+                (convictions.sum / convictions.size).round(10)
+              end
+
+              def overall_flexibility
+                return 0.5 if @beliefs.empty?
+
+                (1.0 - average_inertia).round(10)
+              end
+
+              def inertia_report
+                {
+                  total_beliefs:       @beliefs.size,
+                  entrenched_count:    entrenched_beliefs.size,
+                  flexible_count:      flexible_beliefs.size,
+                  average_inertia:     average_inertia,
+                  average_conviction:  average_conviction,
+                  overall_flexibility: overall_flexibility,
+                  most_resistant:      most_resistant(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_beliefs:       @beliefs.size,
+                  entrenched_count:    entrenched_beliefs.size,
+                  flexible_count:      flexible_beliefs.size,
+                  average_inertia:     average_inertia,
+                  overall_flexibility: overall_flexibility
+                }
+              end
+
+              private
+
+              def prune_if_needed
+                return if @beliefs.size < MAX_BELIEFS
+
+                most_flexible = @beliefs.values.min_by(&:inertia)
+                @beliefs.delete(most_flexible.id) if most_flexible
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inertia/runners/cognitive_inertia.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+          module Runners
+            module CognitiveInertia
+              include Helpers::Constants
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def form_belief(content:, engine: nil, domain: :factual, conviction: 0.5, **)
+                eng = engine || default_engine
+                belief = eng.form_belief(content: content, domain: domain, conviction: conviction)
+                { success: true, belief: belief.to_h }
+              end
+
+              def challenge_belief(belief_id:, engine: nil, strength: 0.5, **)
+                eng = engine || default_engine
+                result = eng.challenge_belief(belief_id: belief_id, strength: strength)
+                return { success: false, error: 'belief not found' } unless result
+
+                { success: true, outcome: result[:outcome], belief: result[:belief].to_h }
+              end
+
+              def reinforce_belief(belief_id:, engine: nil, amount: 0.1, **)
+                eng = engine || default_engine
+                result = eng.reinforce_belief(belief_id: belief_id, amount: amount)
+                return { success: false, error: 'belief not found' } unless result
+
+                { success: true, belief: result.to_h }
+              end
+
+              def entrenched_beliefs(engine: nil, **)
+                eng = engine || default_engine
+                beliefs = eng.entrenched_beliefs.map(&:to_h)
+                { success: true, beliefs: beliefs, count: beliefs.size }
+              end
+
+              def flexible_beliefs(engine: nil, **)
+                eng = engine || default_engine
+                beliefs = eng.flexible_beliefs.map(&:to_h)
+                { success: true, beliefs: beliefs, count: beliefs.size }
+              end
+
+              def average_inertia(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, inertia: eng.average_inertia }
+              end
+
+              def overall_flexibility(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, flexibility: eng.overall_flexibility }
+              end
+
+              def inertia_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.inertia_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::InertiaEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inertia/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inertia.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'inertia/version'
+require_relative 'inertia/helpers/constants'
+require_relative 'inertia/helpers/belief'
+require_relative 'inertia/helpers/inertia_engine'
+require_relative 'inertia/runners/cognitive_inertia'
+require_relative 'inertia/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inertia
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inhibition/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/inhibition/helpers/constants'
+require 'legion/extensions/agentic/executive/inhibition/helpers/impulse'
+require 'legion/extensions/agentic/executive/inhibition/helpers/inhibition_model'
+require 'legion/extensions/agentic/executive/inhibition/helpers/inhibition_store'
+require 'legion/extensions/agentic/executive/inhibition/runners/inhibition'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inhibition
+          class Client
+            include Runners::Inhibition
+
+            attr_reader :inhibition_store
+
+            def initialize(inhibition_store: nil, **)
+              @inhibition_store = inhibition_store || Helpers::InhibitionStore.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inhibition/helpers/constants.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inhibition
+          module Helpers
+            module Constants
+              IMPULSE_TYPES = %i[reactive habitual emotional social competitive].freeze
+
+              INHIBITION_STRATEGIES = %i[suppression delay redirect substitute defer].freeze
+
+              IMPULSE_STRENGTHS = {
+                overwhelming: 1.0,
+                strong:       0.75,
+                moderate:     0.5,
+                mild:         0.25,
+                negligible:   0.1
+              }.freeze
+
+              INHIBITION_ALPHA         = 0.12
+              FATIGUE_PER_INHIBITION   = 0.05
+              FATIGUE_RECOVERY_RATE    = 0.02
+              MAX_INHIBITION_LOG       = 200
+              WILLPOWER_THRESHOLD      = 0.3
+              AUTOMATIC_SUPPRESS_THRESHOLD = 0.2
+              DELAY_DISCOUNT_RATE = 0.1
+              STROOP_CONFLICT_THRESHOLD = 0.6
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inhibition/helpers/impulse.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inhibition
+          module Helpers
+            class Impulse
+              attr_reader :id, :type, :action, :strength, :source, :context, :created_at
+
+              def initialize(type:, action:, strength:, source: nil, context: {})
+                @id         = SecureRandom.uuid
+                @type       = type
+                @action     = action
+                @strength   = strength
+                @source     = source
+                @context    = context
+                @created_at = Time.now.utc
+              end
+
+              def overwhelming?
+                @strength >= Constants::IMPULSE_STRENGTHS[:strong]
+              end
+
+              def auto_suppressible?
+                @strength <= Constants::AUTOMATIC_SUPPRESS_THRESHOLD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inhibition/helpers/inhibition_model.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inhibition
+          module Helpers
+            class InhibitionModel
+              attr_reader :willpower, :inhibition_log, :suppressed_count, :failed_count, :redirected_count
+
+              def initialize
+                @willpower        = 0.8
+                @inhibition_log   = []
+                @suppressed_count = 0
+                @failed_count     = 0
+                @redirected_count = 0
+              end
+
+              def evaluate_impulse(impulse)
+                if impulse.auto_suppressible?
+                  :auto_suppress
+                elsif @willpower < Constants::WILLPOWER_THRESHOLD
+                  :failed
+                else
+                  select_strategy(impulse)
+                end
+              end
+
+              def apply_strategy(impulse, strategy)
+                deplete_willpower(impulse.strength) unless strategy == :auto_suppress
+
+                case strategy
+                when :failed
+                  @failed_count += 1
+                when :redirect
+                  @redirected_count += 1
+                  @suppressed_count += 1
+                else
+                  @suppressed_count += 1
+                end
+
+                entry = {
+                  impulse_id: impulse.id,
+                  type:       impulse.type,
+                  action:     impulse.action,
+                  strength:   impulse.strength,
+                  strategy:   strategy,
+                  willpower:  @willpower.round(4),
+                  at:         Time.now.utc
+                }
+
+                @inhibition_log << entry
+                @inhibition_log.shift while @inhibition_log.size > Constants::MAX_INHIBITION_LOG
+
+                entry
+              end
+
+              def recover_willpower
+                @willpower = [@willpower + Constants::FATIGUE_RECOVERY_RATE, 1.0].min
+              end
+
+              def willpower_status
+                if @willpower >= 0.6
+                  :healthy
+                elsif @willpower >= Constants::WILLPOWER_THRESHOLD
+                  :depleted
+                else
+                  :exhausted
+                end
+              end
+
+              def success_rate
+                total = @suppressed_count + @failed_count
+                return 1.0 if total.zero?
+
+                @suppressed_count.to_f / total
+              end
+
+              def delay_discount(reward_value, delay_ticks)
+                reward_value / (1.0 + (Constants::DELAY_DISCOUNT_RATE * delay_ticks))
+              end
+
+              def stroop_conflict?(automatic_response, controlled_response)
+                automatic_response != controlled_response &&
+                  automatic_strength(automatic_response) >= Constants::STROOP_CONFLICT_THRESHOLD
+              end
+
+              private
+
+              def select_strategy(impulse)
+                case impulse.type
+                when :habitual
+                  :redirect
+                when :emotional
+                  impulse.overwhelming? ? :delay : :suppression
+                when :social
+                  :substitute
+                when :competitive
+                  :defer
+                else
+                  :suppression
+                end
+              end
+
+              def deplete_willpower(strength)
+                depletion  = Constants::FATIGUE_PER_INHIBITION * strength
+                @willpower = [@willpower - depletion, 0.0].max
+              end
+
+              def automatic_strength(response)
+                return response[:strength] if response.is_a?(Hash) && response.key?(:strength)
+
+                Constants::STROOP_CONFLICT_THRESHOLD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/inhibition/helpers/inhibition_store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Inhibition
+          module Helpers
+            class InhibitionStore
+              attr_reader :model, :impulses
+
+              def initialize
+                @model = InhibitionModel.new
+                @impulses = []
+              end
+
+              def create_impulse(type:, action:, strength:, source: nil, context: {})
+                resolved_strength = resolve_strength(strength)
+
+                impulse = Impulse.new(
+                  type:     type,
+                  action:   action,
+                  strength: resolved_strength,
+                  source:   source,
+                  context:  context
+                )
+
+                @impulses << impulse
+                impulse
+              end
+
+              def evaluate_and_apply(impulse)
+                strategy = @model.evaluate_impulse(impulse)
+                entry    = @model.apply_strategy(impulse, strategy)
+                { strategy: strategy, log_entry: entry }
+              end
+
+              def recover
+                @model.recover_willpower
+              end
+
+              def stats
+                {
+                  willpower:        @model.willpower.round(4),
+                  willpower_status: @model.willpower_status,
+                  suppressed:       @model.suppressed_count,
+                  failed:           @model.failed_count,
+                  redirected:       @model.redirected_count,
+                  success_rate:     @model.success_rate.round(4),
+                  log_size:         @model.inhibition_log.size,
+                  total_impulses:   @impulses.size
+                }
+              end
+
+              def recent_log(limit = 20)
+                @model.inhibition_log.last(limit)
+              end
+
+              private
+
+              def resolve_strength(strength)
+                return strength if strength.is_a?(Float) || strength.is_a?(Integer)
+
+                Constants::IMPULSE_STRENGTHS.fetch(strength.to_sym, Constants::IMPULSE_STRENGTHS[:moderate])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end