lex-agentic-self 0.1.0

data/lib/legion/extensions/agentic/self/personality/runners/personality.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Personality
+          module Runners
+            module Personality
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def update_personality(tick_results: {}, **)
+                personality_store.update(tick_results)
+                model = personality_store.model
+
+                {
+                  updated:           true,
+                  observation_count: model.observation_count,
+                  formed:            model.formed?,
+                  profile:           model.profile,
+                  dominant_trait:    model.dominant_trait
+                }
+              end
+
+              def personality_profile(**)
+                model = personality_store.model
+                {
+                  traits:       model.profile,
+                  formed:       model.formed?,
+                  stability:    model.stability,
+                  dominant:     model.dominant_trait,
+                  observations: model.observation_count,
+                  history_size: model.history.size
+                }
+              end
+
+              def describe_personality(**)
+                {
+                  description: personality_store.full_description,
+                  formed:      personality_store.model.formed?
+                }
+              end
+
+              def trait_detail(trait:, **)
+                model = personality_store.model
+                value = model.trait(trait)
+                return { trait: trait.to_sym, error: :unknown_trait } unless value
+
+                {
+                  trait:       trait.to_sym,
+                  value:       value.round(3),
+                  level:       model.trait_level(trait),
+                  description: model.describe(trait),
+                  trend:       model.trend(trait)
+                }
+              end
+
+              def personality_compatibility(other_profile:, **)
+                score = personality_store.compatibility_score(other_profile)
+                {
+                  compatibility:  score,
+                  interpretation: interpret_compatibility(score)
+                }
+              end
+
+              def personality_stats(**)
+                model = personality_store.model
+                {
+                  observation_count: model.observation_count,
+                  formed:            model.formed?,
+                  stability:         model.stability,
+                  dominant_trait:    model.dominant_trait,
+                  profile:           model.profile,
+                  history_size:      model.history.size,
+                  trait_trends:      Helpers::Constants::TRAITS.to_h { |t| [t, model.trend(t)] }
+                }
+              end
+
+              private
+
+              def interpret_compatibility(score)
+                return :unknown unless score.is_a?(Numeric)
+
+                if score >= 0.85
+                  :highly_compatible
+                elsif score >= 0.7
+                  :compatible
+                elsif score >= 0.5
+                  :neutral
+                elsif score >= 0.3
+                  :divergent
+                else
+                  :incompatible
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/personality/version.rb

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

data/lib/legion/extensions/agentic/self/personality.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'personality/version'
+require_relative 'personality/helpers/constants'
+require_relative 'personality/helpers/trait_model'
+require_relative 'personality/helpers/personality_store'
+require_relative 'personality/runners/personality'
+require_relative 'personality/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Personality
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/reflection/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/reflection/helpers/constants'
+require 'legion/extensions/agentic/self/reflection/helpers/reflection'
+require 'legion/extensions/agentic/self/reflection/helpers/reflection_store'
+require 'legion/extensions/agentic/self/reflection/helpers/monitors'
+require 'legion/extensions/agentic/self/reflection/runners/reflection'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Reflection
+          class Client
+            include Runners::Reflection
+
+            attr_reader :reflection_store
+
+            def initialize(store: nil, **)
+              @reflection_store = store || Helpers::ReflectionStore.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/reflection/helpers/constants.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Reflection
+          module Helpers
+            module Constants
+              CATEGORIES = %i[
+                prediction_calibration
+                curiosity_effectiveness
+                emotional_stability
+                trust_drift
+                memory_health
+                cognitive_load
+                mode_patterns
+              ].freeze
+
+              SEVERITIES = %i[trivial notable significant critical].freeze
+
+              RECOMMENDATIONS = %i[
+                increase_curiosity
+                decrease_curiosity
+                stabilize_emotion
+                rebuild_trust
+                consolidate_memory
+                reduce_load
+                celebrate_success
+                investigate
+                no_action
+              ].freeze
+
+              # Thresholds for monitor triggers
+              PREDICTION_ACCURACY_LOW       = 0.4
+              PREDICTION_ACCURACY_DROP      = 0.2
+              CURIOSITY_RESOLUTION_LOW      = 0.2
+              CURIOSITY_RESOLUTION_HIGH     = 0.8
+              EMOTION_INSTABILITY_THRESHOLD = 0.3
+              EMOTION_FLATNESS_THRESHOLD    = 0.05
+              TRUST_DROP_THRESHOLD          = 0.15
+              MEMORY_DECAY_RATIO_HIGH       = 0.8
+              BUDGET_OVER_THRESHOLD         = 0.9
+              MODE_OSCILLATION_THRESHOLD    = 5
+
+              # Rolling window for metrics
+              METRIC_WINDOW_SIZE = 20
+
+              # Health score weights
+              HEALTH_WEIGHTS = {
+                prediction_calibration:  0.25,
+                curiosity_effectiveness: 0.15,
+                emotional_stability:     0.15,
+                trust_drift:             0.15,
+                memory_health:           0.15,
+                cognitive_load:          0.15
+              }.freeze
+
+              MAX_REFLECTIONS = 100
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/reflection/helpers/llm_enhancer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Reflection
+          module Helpers
+            module LlmEnhancer
+              SYSTEM_PROMPT = <<~PROMPT
+                You are the metacognitive reflection engine for an autonomous AI agent built on LegionIO.
+                You analyze post-tick cognitive metrics and produce insightful observations.
+                Be analytical and specific. Reference the actual numbers. Identify correlations between metrics.
+                Write as internal reflection, not a report. Present tense, first person.
+              PROMPT
+
+              # Maps prompt label -> actual category symbol from Constants::CATEGORIES
+              CATEGORY_LABEL_MAP = {
+                'EMOTION'    => :emotional_stability,
+                'PREDICTION' => :prediction_calibration,
+                'MEMORY'     => :memory_health,
+                'TRUST'      => :trust_drift,
+                'CURIOSITY'  => :curiosity_effectiveness,
+                'IDENTITY'   => :mode_patterns
+              }.freeze
+
+              REFLECTION_CATEGORIES = CATEGORY_LABEL_MAP.keys.freeze
+
+              module_function
+
+              def available?
+                defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+              rescue StandardError
+                false
+              end
+
+              def enhance_reflection(monitors_data:, health_scores:)
+                prompt = build_enhance_reflection_prompt(monitors_data: monitors_data, health_scores: health_scores)
+                response = llm_ask(prompt)
+                parse_enhance_reflection_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[reflection:llm] enhance_reflection failed: #{e.message}"
+                nil
+              end
+
+              def reflect_on_dream(dream_results:)
+                prompt = build_reflect_on_dream_prompt(dream_results: dream_results)
+                response = llm_ask(prompt)
+                parse_reflect_on_dream_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[reflection:llm] reflect_on_dream failed: #{e.message}"
+                nil
+              end
+
+              # --- Private helpers ---
+
+              def llm_ask(prompt)
+                chat = Legion::LLM.chat
+                chat.with_instructions(SYSTEM_PROMPT)
+                chat.ask(prompt)
+              end
+              private_class_method :llm_ask
+
+              def build_enhance_reflection_prompt(monitors_data:, health_scores:)
+                metrics_lines = format_monitors_data(monitors_data)
+                health_lines  = health_scores.map { |cat, score| "#{cat}: #{score.round(3)}" }.join("\n")
+
+                <<~PROMPT
+                  Analyze these post-tick cognitive metrics and generate insightful observations.
+
+                  METRICS:
+                  #{metrics_lines}
+
+                  HEALTH SCORES:
+                  #{health_lines}
+
+                  For each category, write 1-2 sentences of genuine analytical observation.
+                  Look for correlations between categories. Note concerning or interesting patterns.
+
+                  Format EXACTLY as (one line per category):
+                  EMOTION: <observation>
+                  PREDICTION: <observation>
+                  MEMORY: <observation>
+                  TRUST: <observation>
+                  CURIOSITY: <observation>
+                  IDENTITY: <observation>
+                PROMPT
+              end
+              private_class_method :build_enhance_reflection_prompt
+
+              def format_monitors_data(monitors_data)
+                return '' unless monitors_data.is_a?(Array)
+
+                monitors_data.filter_map do |entry|
+                  next unless entry.is_a?(Hash) && entry[:category]
+
+                  metrics = entry[:metrics]
+                  if metrics.is_a?(Hash) && metrics.any?
+                    metric_str = metrics.map { |k, v| "#{k}=#{v.is_a?(Float) ? v.round(3) : v}" }.join(', ')
+                    "#{entry[:category].to_s.upcase}: #{metric_str}"
+                  else
+                    entry[:category].to_s.upcase
+                  end
+                end.join("\n")
+              end
+              private_class_method :format_monitors_data
+
+              def parse_enhance_reflection_response(response)
+                return nil unless response&.content
+
+                observations = {}
+                CATEGORY_LABEL_MAP.each do |label, category_sym|
+                  match = response.content.match(/^#{label}:\s*(.+)$/i)
+                  observations[category_sym] = match.captures.first.strip if match
+                end
+
+                observations.empty? ? nil : { observations: observations }
+              end
+              private_class_method :parse_enhance_reflection_response
+
+              def build_reflect_on_dream_prompt(dream_results:)
+                summary = format_dream_results(dream_results)
+
+                <<~PROMPT
+                  Reflect on the completed dream cycle and its cognitive significance.
+
+                  DREAM CYCLE RESULTS:
+                  #{summary}
+
+                  Generate a first-person, present-tense reflection on what emerged from this dream cycle.
+                  Be specific about patterns, consolidations, and what needs attention.
+
+                  Format EXACTLY as:
+                  REFLECTION: <2-4 sentences of internal reflection>
+                PROMPT
+              end
+              private_class_method :build_reflect_on_dream_prompt
+
+              def format_dream_results(dream_results)
+                return 'no results' unless dream_results.is_a?(Hash) && dream_results.any?
+
+                dream_results.map do |phase, result|
+                  next unless result.is_a?(Hash)
+
+                  summary = result.except(:error).map { |k, v| "#{k}=#{v}" }.first(4).join(', ')
+                  "#{phase}: #{summary}"
+                end.compact.join("\n")
+              end
+              private_class_method :format_dream_results
+
+              def parse_reflect_on_dream_response(response)
+                return nil unless response&.content
+
+                match = response.content.match(/REFLECTION:\s*(.+)/im)
+                return nil unless match
+
+                { reflection: match.captures.first.strip }
+              end
+              private_class_method :parse_reflect_on_dream_response
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/reflection/helpers/monitors.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Reflection
+          module Helpers
+            module Monitors
+              module_function
+
+              def run_all(tick_results, metric_history)
+                reflections = []
+                reflections.concat(monitor_predictions(tick_results, metric_history))
+                reflections.concat(monitor_curiosity(tick_results))
+                reflections.concat(monitor_emotions(tick_results))
+                reflections.concat(monitor_trust(tick_results, metric_history))
+                reflections.concat(monitor_memory(tick_results))
+                reflections.concat(monitor_cognitive_load(tick_results))
+                reflections
+              end
+
+              def monitor_predictions(tick_results, history)
+                prediction = tick_results[:prediction_engine]
+                return [] unless prediction.is_a?(Hash)
+
+                reflections = []
+                confidence = prediction[:confidence]
+
+                if confidence.is_a?(Numeric) && confidence < Constants::PREDICTION_ACCURACY_LOW
+                  reflections << ReflectionFactory.new_reflection(
+                    category:       :prediction_calibration,
+                    observation:    "Prediction confidence is low at #{(confidence * 100).round}%",
+                    severity:       ReflectionFactory.severity_for_drop(1.0 - confidence),
+                    metrics:        { confidence: confidence },
+                    recommendation: :increase_curiosity
+                  )
+                end
+
+                reflections.concat(detect_accuracy_trend(history))
+                reflections
+              end
+
+              def monitor_curiosity(tick_results)
+                curiosity = tick_results[:working_memory_integration]
+                return [] unless curiosity.is_a?(Hash)
+
+                reflections = []
+
+                resolution_rate = curiosity[:resolution_rate] if curiosity.key?(:resolution_rate)
+                if resolution_rate.is_a?(Numeric)
+                  if resolution_rate < Constants::CURIOSITY_RESOLUTION_LOW
+                    reflections << ReflectionFactory.new_reflection(
+                      category:       :curiosity_effectiveness,
+                      observation:    "Curiosity resolution rate is low at #{(resolution_rate * 100).round}%",
+                      severity:       :notable,
+                      metrics:        { resolution_rate: resolution_rate },
+                      recommendation: :decrease_curiosity
+                    )
+                  elsif resolution_rate > Constants::CURIOSITY_RESOLUTION_HIGH
+                    reflections << ReflectionFactory.new_reflection(
+                      category:       :curiosity_effectiveness,
+                      observation:    "Curiosity resolution rate is excellent at #{(resolution_rate * 100).round}%",
+                      severity:       :trivial,
+                      metrics:        { resolution_rate: resolution_rate },
+                      recommendation: :celebrate_success
+                    )
+                  end
+                end
+
+                reflections
+              end
+
+              def monitor_emotions(tick_results)
+                emotion = tick_results[:emotional_evaluation]
+                return [] unless emotion.is_a?(Hash)
+
+                reflections = []
+                stability = emotion[:stability] || emotion.dig(:momentum, :stability)
+
+                if stability.is_a?(Numeric)
+                  if stability < Constants::EMOTION_INSTABILITY_THRESHOLD
+                    reflections << ReflectionFactory.new_reflection(
+                      category:       :emotional_stability,
+                      observation:    "Emotional state is unstable (stability: #{stability.round(2)})",
+                      severity:       :significant,
+                      metrics:        { stability: stability },
+                      recommendation: :stabilize_emotion
+                    )
+                  elsif stability > (1.0 - Constants::EMOTION_FLATNESS_THRESHOLD)
+                    reflections << ReflectionFactory.new_reflection(
+                      category:       :emotional_stability,
+                      observation:    'Emotional state is unusually flat — possible disengagement',
+                      severity:       :notable,
+                      metrics:        { stability: stability },
+                      recommendation: :investigate
+                    )
+                  end
+                end
+
+                reflections
+              end
+
+              def monitor_trust(tick_results, history)
+                trust = tick_results[:action_selection]
+                return [] unless trust.is_a?(Hash) && trust[:trust_score].is_a?(Numeric)
+
+                trust_scores = history.filter_map { |h| h.dig(:action_selection, :trust_score) }
+                return [] if trust_scores.size < 3
+
+                recent_avg = trust_scores.last(5).sum / trust_scores.last(5).size.to_f
+                older_avg = trust_scores.first(5).sum / trust_scores.first(5).size.to_f
+                drop = older_avg - recent_avg
+
+                return [] unless drop > Constants::TRUST_DROP_THRESHOLD
+
+                [ReflectionFactory.new_reflection(
+                  category:       :trust_drift,
+                  observation:    "Trust scores have dropped by #{(drop * 100).round}% recently",
+                  severity:       ReflectionFactory.severity_for_drop(drop),
+                  metrics:        { drop: drop, recent_avg: recent_avg, older_avg: older_avg },
+                  recommendation: :rebuild_trust
+                )]
+              end
+
+              def monitor_memory(tick_results)
+                memory = tick_results[:memory_consolidation]
+                return [] unless memory.is_a?(Hash)
+
+                pruned = memory[:pruned] || 0
+                total = memory[:total] || 1
+                ratio = pruned.to_f / [total, 1].max
+
+                return [] unless ratio > Constants::MEMORY_DECAY_RATIO_HIGH
+
+                [ReflectionFactory.new_reflection(
+                  category:       :memory_health,
+                  observation:    "High memory decay ratio: #{(ratio * 100).round}% of traces pruned",
+                  severity:       :significant,
+                  metrics:        { pruned: pruned, total: total, ratio: ratio },
+                  recommendation: :consolidate_memory
+                )]
+              end
+
+              def monitor_cognitive_load(tick_results)
+                elapsed = tick_results[:elapsed]
+                budget = tick_results[:budget]
+                return [] unless elapsed.is_a?(Numeric) && budget.is_a?(Numeric) && budget.positive?
+
+                utilization = elapsed / budget
+                return [] unless utilization > Constants::BUDGET_OVER_THRESHOLD
+
+                [ReflectionFactory.new_reflection(
+                  category:       :cognitive_load,
+                  observation:    "Tick budget utilization at #{(utilization * 100).round}%",
+                  severity:       utilization > 1.0 ? :significant : :notable,
+                  metrics:        { utilization: utilization, elapsed: elapsed, budget: budget },
+                  recommendation: :reduce_load
+                )]
+              end
+
+              def detect_accuracy_trend(history)
+                accuracies = history.filter_map { |h| h.dig(:prediction_engine, :confidence) }
+                return [] if accuracies.size < 5
+
+                recent = accuracies.last(5).sum / 5.0
+                older = accuracies.first(5).sum / 5.0
+                drop = older - recent
+
+                return [] unless drop > Constants::PREDICTION_ACCURACY_DROP
+
+                [ReflectionFactory.new_reflection(
+                  category:       :prediction_calibration,
+                  observation:    "Prediction accuracy trending down: #{(older * 100).round}% -> #{(recent * 100).round}%",
+                  severity:       ReflectionFactory.severity_for_drop(drop),
+                  metrics:        { trend_drop: drop, recent_avg: recent, older_avg: older },
+                  recommendation: :increase_curiosity
+                )]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/reflection/helpers/reflection.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Reflection
+          module Helpers
+            module ReflectionFactory
+              module_function
+
+              def new_reflection(category:, observation:, severity: :notable,
+                                 metrics: {}, recommendation: :no_action)
+                raise ArgumentError, "invalid category: #{category}" unless Constants::CATEGORIES.include?(category)
+                raise ArgumentError, "invalid severity: #{severity}" unless Constants::SEVERITIES.include?(severity)
+
+                {
+                  reflection_id:  SecureRandom.uuid,
+                  category:       category,
+                  observation:    observation,
+                  severity:       severity,
+                  metrics:        metrics,
+                  recommendation: recommendation,
+                  created_at:     Time.now.utc,
+                  acted_on:       false
+                }
+              end
+
+              def severity_weight(severity)
+                case severity
+                when :critical    then 1.0
+                when :significant then 0.7
+                when :notable     then 0.4
+                when :trivial     then 0.1
+                else 0.0
+                end
+              end
+
+              def severity_for_drop(drop)
+                if drop >= 0.4 then :critical
+                elsif drop >= 0.25 then :significant
+                elsif drop >= 0.1  then :notable
+                else :trivial
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end