lex-agentic-executive 0.1.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/volition/helpers/constants'
+require 'legion/extensions/agentic/executive/volition/helpers/intention'
+require 'legion/extensions/agentic/executive/volition/helpers/intention_stack'
+require 'legion/extensions/agentic/executive/volition/helpers/drive_synthesizer'
+require 'legion/extensions/agentic/executive/volition/runners/volition'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          class Client
+            include Runners::Volition
+
+            attr_reader :intention_stack
+
+            def initialize(stack: nil, **)
+              @intention_stack = stack || Helpers::IntentionStack.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Helpers
+            module Constants
+              # Maximum active intentions
+              MAX_INTENTIONS = 7
+
+              # Drive sources and their default weights
+              DRIVE_WEIGHTS = {
+                curiosity:  0.25,  # from lex-curiosity wonder intensity
+                corrective: 0.20,  # from lex-reflection adaptation recommendations
+                urgency:    0.20,  # from lex-emotion gut signal + arousal
+                epistemic:  0.20,  # from lex-prediction confidence gaps
+                social:     0.15   # from lex-trust + mesh signals
+              }.freeze
+
+              # Minimum drive strength to generate an intention
+              DRIVE_THRESHOLD = 0.15
+
+              # Intention decay per tick when not reinforced
+              INTENTION_DECAY = 0.05
+
+              # Intention salience floor before removal
+              INTENTION_FLOOR = 0.1
+
+              # Maximum intention age in ticks before forced expiry
+              MAX_INTENTION_AGE = 100
+
+              # Drive labels for narrative output
+              DRIVE_LABELS = {
+                curiosity:  'knowledge seeking',
+                corrective: 'self-improvement',
+                urgency:    'urgent response',
+                epistemic:  'uncertainty reduction',
+                social:     'collaborative engagement'
+              }.freeze
+
+              # Intention states
+              STATES = %i[active suspended completed expired].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/volition/helpers/drive_synthesizer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Helpers
+            module DriveSynthesizer
+              module_function
+
+              def synthesize(tick_results: {}, cognitive_state: {})
+                drives = {}
+                drives[:curiosity] = compute_curiosity_drive(tick_results, cognitive_state)
+                drives[:corrective] = compute_corrective_drive(cognitive_state)
+                drives[:urgency] = compute_urgency_drive(tick_results, cognitive_state)
+                drives[:epistemic] = compute_epistemic_drive(tick_results, cognitive_state)
+                drives[:social] = compute_social_drive(cognitive_state)
+                drives
+              end
+
+              def weighted_drives(drives)
+                drives.each_with_object({}) do |(drive, strength), result|
+                  weight = Constants::DRIVE_WEIGHTS[drive] || 0.0
+                  result[drive] = {
+                    raw:      strength,
+                    weighted: (strength * weight).round(4),
+                    weight:   weight
+                  }
+                end
+              end
+
+              def dominant_drive(drives)
+                return nil if drives.empty?
+
+                drives.max_by { |_, strength| strength }&.first
+              end
+
+              def generate_intentions(drives, cognitive_state: {})
+                intentions = []
+
+                drives.each do |drive, strength|
+                  next if strength < Constants::DRIVE_THRESHOLD
+
+                  intention = build_intention_for_drive(drive, strength, cognitive_state)
+                  intentions << intention if intention
+                end
+
+                intentions.sort_by { |i| -(i[:salience] || 0) }
+              end
+
+              def compute_curiosity_drive(tick_results, cognitive_state)
+                curiosity = cognitive_state[:curiosity] || {}
+                wonder_data = tick_results[:working_memory_integration] || {}
+
+                intensity = curiosity[:intensity] || wonder_data[:curiosity_intensity] || 0.0
+                active_count = curiosity[:active_count] || wonder_data[:active_wonders] || 0
+
+                count_factor = [active_count / 5.0, 1.0].min
+                ((intensity * 0.7) + (count_factor * 0.3)).clamp(0.0, 1.0)
+              end
+
+              def compute_corrective_drive(cognitive_state)
+                reflection = cognitive_state[:reflection] || {}
+                health = reflection[:health] || 1.0
+                pending = reflection[:pending_adaptations] || 0
+
+                health_gap = 1.0 - health
+                pending_factor = [pending / 3.0, 1.0].min
+                ((health_gap * 0.6) + (pending_factor * 0.4)).clamp(0.0, 1.0)
+              end
+
+              def compute_urgency_drive(tick_results, cognitive_state)
+                gut = tick_results[:gut_instinct] || cognitive_state[:gut] || {}
+                emotion = tick_results[:emotional_evaluation] || {}
+
+                arousal = emotion[:arousal] || cognitive_state.dig(:emotion, :arousal) || 0.5
+                gut_signal = extract_gut_strength(gut)
+
+                ((arousal * 0.5) + (gut_signal * 0.5)).clamp(0.0, 1.0)
+              end
+
+              def compute_epistemic_drive(tick_results, cognitive_state)
+                pred = tick_results[:prediction_engine] || {}
+                pred_state = cognitive_state[:prediction] || {}
+
+                confidence = pred[:confidence] || pred_state[:confidence] || 0.5
+                pending = pred_state[:pending_count] || 0
+
+                confidence_gap = 1.0 - confidence
+                pending_factor = [pending / 10.0, 1.0].min
+                ((confidence_gap * 0.6) + (pending_factor * 0.4)).clamp(0.0, 1.0)
+              end
+
+              def compute_social_drive(cognitive_state)
+                mesh = cognitive_state[:mesh] || {}
+                trust = cognitive_state[:trust] || {}
+
+                peer_count = mesh[:peer_count] || 0
+                trust_level = trust[:avg_composite] || 0.5
+
+                peer_factor = [peer_count / 5.0, 1.0].min
+                ((peer_factor * 0.4) + (trust_level * 0.6)).clamp(0.0, 1.0)
+              end
+
+              def extract_gut_strength(gut)
+                signal = gut[:signal]
+                return 0.3 unless signal
+
+                case signal
+                when :alarm then 1.0
+                when :heightened then 0.7
+                when :explore   then 0.5
+                when :attend    then 0.4
+                when :calm      then 0.1
+                else 0.3
+                end
+              end
+
+              def build_intention_for_drive(drive, strength, cognitive_state)
+                case drive
+                when :curiosity  then build_curiosity_intention(strength, cognitive_state)
+                when :corrective then build_corrective_intention(strength, cognitive_state)
+                when :urgency    then build_urgency_intention(strength, cognitive_state)
+                when :epistemic  then build_epistemic_intention(strength, cognitive_state)
+                when :social     then build_social_intention(strength, cognitive_state)
+                end
+              end
+
+              def build_curiosity_intention(strength, cognitive_state)
+                question = cognitive_state.dig(:curiosity, :top_question) || 'explore knowledge gaps'
+                domain = cognitive_state.dig(:curiosity, :top_domain) || :general
+                Intention.new_intention(drive: :curiosity, domain: domain, goal: question, salience: strength)
+              end
+
+              def build_corrective_intention(strength, cognitive_state)
+                severity = cognitive_state.dig(:reflection, :recent_severity) || 'cognitive health'
+                Intention.new_intention(drive: :corrective, domain: :self, goal: "address #{severity}", salience: strength)
+              end
+
+              def build_urgency_intention(strength, _cognitive_state)
+                Intention.new_intention(drive: :urgency, domain: :general, goal: 'respond to urgent signal', salience: strength)
+              end
+
+              def build_epistemic_intention(strength, _cognitive_state)
+                Intention.new_intention(drive: :epistemic, domain: :general, goal: 'reduce prediction uncertainty', salience: strength)
+              end
+
+              def build_social_intention(strength, _cognitive_state)
+                Intention.new_intention(drive: :social, domain: :general, goal: 'engage with peer agents', salience: strength)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/volition/helpers/intention.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Helpers
+            module Intention
+              module_function
+
+              def new_intention(drive:, domain:, goal:, salience:, context: {})
+                {
+                  intention_id: SecureRandom.hex(8),
+                  drive:        drive.to_sym,
+                  domain:       domain.to_sym,
+                  goal:         goal,
+                  salience:     salience.clamp(0.0, 1.0),
+                  state:        :active,
+                  created_at:   Time.now.utc,
+                  age_ticks:    0,
+                  context:      context
+                }
+              end
+
+              def decay(intention)
+                new_salience = [intention[:salience] - Constants::INTENTION_DECAY, 0.0].max
+                intention.merge(salience: new_salience, age_ticks: intention[:age_ticks] + 1)
+              end
+
+              def reinforce(intention, amount: 0.1)
+                new_salience = [intention[:salience] + amount, 1.0].min
+                intention.merge(salience: new_salience)
+              end
+
+              def expired?(intention)
+                intention[:age_ticks] >= Constants::MAX_INTENTION_AGE ||
+                  intention[:salience] < Constants::INTENTION_FLOOR
+              end
+
+              def active?(intention)
+                intention[:state] == :active && !expired?(intention)
+              end
+
+              def drive_label(drive)
+                Constants::DRIVE_LABELS[drive.to_sym] || drive.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/volition/helpers/intention_stack.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Helpers
+            class IntentionStack
+              attr_reader :intentions
+
+              def initialize
+                @intentions = []
+              end
+
+              def push(intention)
+                return :duplicate if duplicate?(intention)
+                return :capacity_full if @intentions.size >= Constants::MAX_INTENTIONS
+
+                @intentions << intention
+                sort!
+                :pushed
+              end
+
+              def active
+                @intentions.select { |i| Intention.active?(i) }
+              end
+
+              def top
+                active.first
+              end
+
+              def by_drive(drive)
+                @intentions.select { |i| i[:drive] == drive.to_sym && Intention.active?(i) }
+              end
+
+              def by_domain(domain)
+                @intentions.select { |i| i[:domain] == domain.to_sym && Intention.active?(i) }
+              end
+
+              def find(intention_id)
+                @intentions.find { |i| i[:intention_id] == intention_id }
+              end
+
+              def complete(intention_id)
+                intention = find(intention_id)
+                return :not_found unless intention
+
+                intention[:state] = :completed
+                intention[:completed_at] = Time.now.utc
+                :completed
+              end
+
+              def suspend(intention_id)
+                intention = find(intention_id)
+                return :not_found unless intention
+
+                intention[:state] = :suspended
+                :suspended
+              end
+
+              def resume(intention_id)
+                intention = find(intention_id)
+                return :not_found unless intention
+                return :not_suspended unless intention[:state] == :suspended
+
+                intention[:state] = :active
+                :resumed
+              end
+
+              def decay_all
+                @intentions.each do |intention|
+                  next unless Intention.active?(intention)
+
+                  updated = Intention.decay(intention)
+                  intention.merge!(updated)
+
+                  intention[:state] = :expired if Intention.expired?(intention)
+                end
+
+                expired_count = @intentions.count { |i| i[:state] == :expired }
+                prune_expired
+                expired_count
+              end
+
+              def reinforce(intention_id, amount: 0.1)
+                intention = find(intention_id)
+                return :not_found unless intention
+
+                updated = Intention.reinforce(intention, amount: amount)
+                intention.merge!(updated)
+                sort!
+                :reinforced
+              end
+
+              def size
+                @intentions.size
+              end
+
+              def active_count
+                active.size
+              end
+
+              def stats
+                by_state = @intentions.each_with_object(Hash.new(0)) { |i, h| h[i[:state]] += 1 }
+                by_drive = active.each_with_object(Hash.new(0)) { |i, h| h[i[:drive]] += 1 }
+                {
+                  total:         @intentions.size,
+                  active:        active_count,
+                  by_state:      by_state,
+                  by_drive:      by_drive,
+                  top_intention: top&.slice(:intention_id, :drive, :domain, :goal, :salience)
+                }
+              end
+
+              private
+
+              def sort!
+                @intentions.sort_by! { |i| -(i[:salience] || 0) }
+              end
+
+              def duplicate?(intention)
+                @intentions.any? do |existing|
+                  Intention.active?(existing) &&
+                    existing[:drive] == intention[:drive] &&
+                    existing[:domain] == intention[:domain] &&
+                    existing[:goal] == intention[:goal]
+                end
+              end
+
+              def prune_expired
+                @intentions.reject! { |i| i[:state] == :expired }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/volition/runners/volition.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Runners
+            module Volition
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def form_intentions(tick_results: {}, cognitive_state: {}, **)
+                drives = Helpers::DriveSynthesizer.synthesize(
+                  tick_results:    tick_results,
+                  cognitive_state: cognitive_state
+                )
+
+                new_intentions = Helpers::DriveSynthesizer.generate_intentions(drives, cognitive_state: cognitive_state)
+                pushed = 0
+                new_intentions.each do |intention|
+                  result = intention_stack.push(intention)
+                  pushed += 1 if result == :pushed
+                end
+
+                expired = intention_stack.decay_all
+                dominant = Helpers::DriveSynthesizer.dominant_drive(drives)
+                current = intention_stack.top
+
+                Legion::Logging.debug "[volition] drives=#{format_drives(drives)} pushed=#{pushed} expired=#{expired} " \
+                                      "active=#{intention_stack.active_count} top=#{current&.dig(:goal)}"
+
+                {
+                  drives:            drives,
+                  dominant_drive:    dominant,
+                  new_intentions:    pushed,
+                  expired:           expired,
+                  active_intentions: intention_stack.active_count,
+                  current_intention: format_intention(current)
+                }
+              end
+
+              def current_intention(**)
+                intention = intention_stack.top
+                return { intention: nil, has_will: false } unless intention
+
+                {
+                  intention: format_intention(intention),
+                  has_will:  true,
+                  drive:     intention[:drive],
+                  goal:      intention[:goal],
+                  salience:  intention[:salience]
+                }
+              end
+
+              def complete_intention(intention_id:, **)
+                result = intention_stack.complete(intention_id)
+                Legion::Logging.info "[volition] complete intention=#{intention_id} result=#{result}"
+                { status: result, intention_id: intention_id }
+              end
+
+              def suspend_intention(intention_id:, **)
+                result = intention_stack.suspend(intention_id)
+                Legion::Logging.info "[volition] suspend intention=#{intention_id} result=#{result}"
+                { status: result, intention_id: intention_id }
+              end
+
+              def resume_intention(intention_id:, **)
+                result = intention_stack.resume(intention_id)
+                Legion::Logging.info "[volition] resume intention=#{intention_id} result=#{result}"
+                { status: result, intention_id: intention_id }
+              end
+
+              def reinforce_intention(intention_id:, amount: 0.1, **)
+                result = intention_stack.reinforce(intention_id, amount: amount)
+                { status: result, intention_id: intention_id }
+              end
+
+              def volition_status(**)
+                stats = intention_stack.stats
+                drives = Helpers::DriveSynthesizer.synthesize(tick_results: {}, cognitive_state: {})
+
+                {
+                  intention_stats: stats,
+                  current_drives:  drives,
+                  has_will:        stats[:active].positive?,
+                  dominant_drive:  Helpers::DriveSynthesizer.dominant_drive(drives)
+                }
+              end
+
+              def intention_history(limit: 20, **)
+                all = intention_stack.intentions.last(limit)
+                {
+                  intentions: all.map { |i| format_intention(i) },
+                  count:      all.size
+                }
+              end
+
+              private
+
+              def intention_stack
+                @intention_stack ||= Helpers::IntentionStack.new
+              end
+
+              def format_intention(intention)
+                return nil unless intention
+
+                {
+                  intention_id: intention[:intention_id],
+                  drive:        intention[:drive],
+                  drive_label:  Helpers::Intention.drive_label(intention[:drive]),
+                  domain:       intention[:domain],
+                  goal:         intention[:goal],
+                  salience:     intention[:salience].round(3),
+                  state:        intention[:state],
+                  age_ticks:    intention[:age_ticks]
+                }
+              end
+
+              def format_drives(drives)
+                drives.map { |k, v| "#{k}=#{v.round(2)}" }.join(' ')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/volition/version'
+require 'legion/extensions/agentic/executive/volition/helpers/constants'
+require 'legion/extensions/agentic/executive/volition/helpers/intention'
+require 'legion/extensions/agentic/executive/volition/helpers/intention_stack'
+require 'legion/extensions/agentic/executive/volition/helpers/drive_synthesizer'
+require 'legion/extensions/agentic/executive/volition/runners/volition'
+require 'legion/extensions/agentic/executive/volition/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module WorkingMemory
+          class Client
+            include Runners::WorkingMemory
+
+            attr_reader :buffer
+
+            def initialize(buffer: nil, **)
+              @buffer = buffer || Helpers::Buffer.new
+            end
+          end
+        end
+      end
+    end
+  end
+end