lex-agentic-self 0.1.0

data/lib/legion/extensions/agentic/self/narrative_self/helpers/episode.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module NarrativeSelf
+          module Helpers
+            class Episode
+              include Constants
+
+              attr_reader :id, :description, :episode_type, :domain, :significance,
+                          :emotional_valence, :tags, :created_at, :thread_ids
+
+              def initialize(description:, episode_type: :insight, domain: :general,
+                             significance: nil, emotional_valence: 0.0, tags: [])
+                @id                = SecureRandom.uuid
+                @description       = description
+                @episode_type      = episode_type
+                @domain            = domain
+                @significance      = significance || DEFAULT_SIGNIFICANCE
+                @emotional_valence = emotional_valence.clamp(-1.0, 1.0)
+                @tags              = tags
+                @created_at        = Time.now.utc
+                @thread_ids        = []
+              end
+
+              def boost(amount)
+                emotional_factor = @emotional_valence.abs * EMOTIONAL_BOOST
+                @significance = [(@significance + amount + emotional_factor), 1.0].min
+              end
+
+              def decay
+                @significance = [(@significance - EPISODE_DECAY), 0.0].max
+              end
+
+              def faded?
+                @significance < SIGNIFICANCE_FLOOR
+              end
+
+              def label
+                SIGNIFICANCE_LABELS.each do |range, lbl|
+                  return lbl if range.cover?(@significance)
+                end
+                :minor
+              end
+
+              def link_thread(thread_id)
+                @thread_ids << thread_id unless @thread_ids.include?(thread_id)
+              end
+
+              def matches_tags?(query_tags)
+                return false if query_tags.empty? || @tags.empty?
+
+                overlap = (@tags & query_tags).size
+                overlap.to_f / query_tags.size
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  description:       @description,
+                  episode_type:      @episode_type,
+                  domain:            @domain,
+                  significance:      @significance,
+                  emotional_valence: @emotional_valence,
+                  label:             label,
+                  tags:              @tags.dup,
+                  thread_ids:        @thread_ids.dup,
+                  created_at:        @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/narrative_self/helpers/narrative_thread.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module NarrativeSelf
+          module Helpers
+            class NarrativeThread
+              include Constants
+
+              attr_reader :id, :theme, :domain, :strength, :episode_ids, :created_at
+
+              def initialize(theme:, domain: :general)
+                @id          = SecureRandom.uuid
+                @theme       = theme
+                @domain      = domain
+                @strength    = 0.5
+                @episode_ids = []
+                @created_at  = Time.now.utc
+              end
+
+              def add_episode(episode_id)
+                return if @episode_ids.include?(episode_id)
+
+                @episode_ids << episode_id
+                @episode_ids.shift if @episode_ids.size > MAX_CHAPTER_SIZE
+                reinforce
+              end
+
+              def reinforce
+                @strength = [@strength + 0.1, 1.0].min
+              end
+
+              def decay
+                @strength = [(@strength - THREAD_DECAY), 0.0].max
+              end
+
+              def weak?
+                @strength < SIGNIFICANCE_FLOOR
+              end
+
+              def size
+                @episode_ids.size
+              end
+
+              def to_h
+                {
+                  id:         @id,
+                  theme:      @theme,
+                  domain:     @domain,
+                  strength:   @strength,
+                  episodes:   @episode_ids.size,
+                  created_at: @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module NarrativeSelf
+          module Runners
+            module NarrativeSelf
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def record_episode(description:, episode_type: :insight, domain: :general,
+                                 significance: nil, emotional_valence: 0.0, tags: [], **)
+                episode = autobiography.record_episode(
+                  description:       description,
+                  episode_type:      episode_type,
+                  domain:            domain,
+                  significance:      significance,
+                  emotional_valence: emotional_valence,
+                  tags:              tags
+                )
+                Legion::Logging.debug "[narrative_self] recorded episode=#{episode_type} domain=#{domain} sig=#{episode.significance.round(3)}"
+                { success: true, episode: episode.to_h }
+              end
+
+              def recent_episodes(count: 10, **)
+                episodes = autobiography.recent_episodes(count)
+                { success: true, episodes: episodes.map(&:to_h), count: episodes.size }
+              end
+
+              def significant_episodes(min_significance: 0.6, **)
+                episodes = autobiography.significant_episodes(min_significance: min_significance)
+                { success: true, episodes: episodes.map(&:to_h), count: episodes.size }
+              end
+
+              def episodes_by_type(episode_type:, **)
+                episodes = autobiography.episodes_by_type(episode_type)
+                { success: true, episodes: episodes.map(&:to_h), count: episodes.size }
+              end
+
+              def create_thread(theme:, domain: :general, **)
+                thread = autobiography.create_thread(theme: theme, domain: domain)
+                Legion::Logging.debug "[narrative_self] created thread=#{theme} domain=#{domain}"
+                { success: true, thread: thread.to_h }
+              end
+
+              def strongest_threads(count: 5, **)
+                threads = autobiography.strongest_threads(count)
+                { success: true, threads: threads.map(&:to_h), count: threads.size }
+              end
+
+              def timeline(window: nil, **)
+                w = window || Helpers::Constants::MAX_TIMELINE_WINDOW
+                entries = autobiography.timeline(window: w)
+                { success: true, timeline: entries, count: entries.size }
+              end
+
+              def self_summary(**)
+                summary = autobiography.self_summary
+                Legion::Logging.debug "[narrative_self] summary: episodes=#{summary[:total_episodes]} richness=#{summary[:narrative_richness].round(3)}"
+                { success: true, summary: summary }
+              end
+
+              def update_narrative_self(**)
+                autobiography.decay_all
+                Legion::Logging.debug "[narrative_self] tick: episodes=#{autobiography.episodes.size} threads=#{autobiography.threads.size}"
+                { success: true, episode_count: autobiography.episodes.size, thread_count: autobiography.threads.size }
+              end
+
+              def narrative_self_stats(**)
+                { success: true, stats: autobiography.to_h }
+              end
+
+              private
+
+              def autobiography
+                @autobiography ||= Helpers::Autobiography.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/narrative_self/version'
+require 'legion/extensions/agentic/self/narrative_self/helpers/constants'
+require 'legion/extensions/agentic/self/narrative_self/helpers/episode'
+require 'legion/extensions/agentic/self/narrative_self/helpers/narrative_thread'
+require 'legion/extensions/agentic/self/narrative_self/helpers/autobiography'
+require 'legion/extensions/agentic/self/narrative_self/runners/narrative_self'
+require 'legion/extensions/agentic/self/narrative_self/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module NarrativeSelf
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Personality
+          module Helpers
+            module Constants
+              # The Big Five personality dimensions (OCEAN)
+              TRAITS = %i[openness conscientiousness extraversion agreeableness neuroticism].freeze
+
+              # Starting values — neutral personality (0.5 = average on each trait)
+              DEFAULT_TRAIT_VALUE = 0.5
+
+              # EMA alpha for trait updates — very slow (personality is stable)
+              TRAIT_ALPHA = 0.02
+
+              # Minimum observations before personality is considered "formed"
+              FORMATION_THRESHOLD = 100
+
+              # Maximum trait history entries
+              MAX_HISTORY = 200
+
+              # Trait descriptors for each level
+              TRAIT_DESCRIPTORS = {
+                openness:          {
+                  high: 'highly curious and open to new experiences',
+                  mid:  'moderately exploratory',
+                  low:  'preferring familiar approaches and known domains'
+                },
+                conscientiousness: {
+                  high: 'very reliable, consistent, and detail-oriented',
+                  mid:  'reasonably organized and dependable',
+                  low:  'flexible but sometimes inconsistent'
+                },
+                extraversion:      {
+                  high: 'socially engaged, frequently communicating with other agents',
+                  mid:  'balanced between collaboration and independent work',
+                  low:  'preferring independent work with minimal social interaction'
+                },
+                agreeableness:     {
+                  high: 'cooperative, trusting, and conflict-averse',
+                  mid:  'balanced between cooperation and independent judgment',
+                  low:  'assertive and willing to challenge others'
+                },
+                neuroticism:       {
+                  high: 'emotionally sensitive, prone to anxiety under stress',
+                  mid:  'moderately resilient to emotional fluctuation',
+                  low:  'emotionally stable and stress-resistant'
+                }
+              }.freeze
+
+              # Signal extraction: maps tick_results keys to trait influences
+              # Each entry: [trait, direction, weight]
+              # direction: :positive means high signal increases trait, :negative means high signal decreases it
+              SIGNAL_MAP = {
+                curiosity_intensity:   [:openness, :positive, 0.3],
+                novel_domains:         [:openness, :positive, 0.4],
+                prediction_accuracy:   [:conscientiousness, :positive, 0.3],
+                habit_automatic_ratio: [:conscientiousness, :positive, 0.3],
+                error_rate:            [:conscientiousness, :negative, 0.4],
+                mesh_message_count:    [:extraversion, :positive, 0.4],
+                empathy_model_count:   [:extraversion, :positive, 0.3],
+                cooperation_ratio:     [:agreeableness, :positive, 0.4],
+                trust_extension_rate:  [:agreeableness, :positive, 0.3],
+                conflict_frequency:    [:agreeableness, :negative, 0.3],
+                emotional_volatility:  [:neuroticism, :positive, 0.4],
+                anxiety_frequency:     [:neuroticism, :positive, 0.3],
+                mood_stability:        [:neuroticism, :negative, 0.3]
+              }.freeze
+
+              # Threshold for "high" trait descriptor
+              HIGH_THRESHOLD = 0.65
+
+              # Threshold for "low" trait descriptor
+              LOW_THRESHOLD = 0.35
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Personality
+          module Helpers
+            class PersonalityStore
+              attr_reader :model
+
+              def initialize
+                @model = TraitModel.new
+              end
+
+              def update(tick_results)
+                signals = extract_signals(tick_results)
+                @model.update(signals)
+              end
+
+              def full_description
+                return 'Personality not yet formed — insufficient observations.' unless @model.formed?
+
+                parts = Constants::TRAITS.filter_map do |trait|
+                  @model.describe(trait)
+                end
+                "#{parts.join('. ')}."
+              end
+
+              def compatibility_score(other_profile)
+                return nil unless other_profile.is_a?(Hash)
+
+                diffs = Constants::TRAITS.map do |trait|
+                  mine = @model.trait(trait) || 0.5
+                  theirs = other_profile[trait] || 0.5
+                  (mine - theirs).abs
+                end
+                avg_diff = diffs.sum / diffs.size.to_f
+                (1.0 - avg_diff).round(3)
+              end
+
+              private
+
+              def extract_signals(tick_results)
+                signals = {}
+
+                signals[:curiosity_intensity] = extract_curiosity(tick_results)
+                signals[:novel_domains] = extract_novelty(tick_results)
+                signals[:prediction_accuracy] = extract_prediction(tick_results)
+                signals[:error_rate] = extract_error_rate(tick_results)
+                signals[:mesh_message_count] = extract_mesh(tick_results)
+                signals[:empathy_model_count] = extract_empathy(tick_results)
+                signals[:cooperation_ratio] = extract_cooperation(tick_results)
+                signals[:conflict_frequency] = extract_conflict(tick_results)
+                signals[:emotional_volatility] = extract_volatility(tick_results)
+                signals[:mood_stability] = extract_mood_stability(tick_results)
+
+                signals.compact
+              end
+
+              def extract_curiosity(tick_results)
+                tick_results.dig(:working_memory_integration, :intensity) ||
+                  tick_results.dig(:curiosity, :intensity)
+              end
+
+              def extract_novelty(tick_results)
+                count = tick_results.dig(:working_memory_integration, :wonder_count) ||
+                        tick_results.dig(:curiosity, :wonder_count)
+                return nil unless count.is_a?(Numeric)
+
+                (count / 10.0).clamp(0.0, 1.0)
+              end
+
+              def extract_prediction(tick_results)
+                tick_results.dig(:prediction_engine, :accuracy) ||
+                  tick_results.dig(:prediction, :accuracy)
+              end
+
+              def extract_error_rate(tick_results)
+                accuracy = extract_prediction(tick_results)
+                return nil unless accuracy.is_a?(Numeric)
+
+                1.0 - accuracy
+              end
+
+              def extract_mesh(tick_results)
+                count = tick_results.dig(:mesh_interface, :message_count) ||
+                        tick_results.dig(:mesh, :message_count)
+                return nil unless count.is_a?(Numeric)
+
+                (count / 20.0).clamp(0.0, 1.0)
+              end
+
+              def extract_empathy(tick_results)
+                count = tick_results.dig(:empathy, :model_count)
+                return nil unless count.is_a?(Numeric)
+
+                (count / 10.0).clamp(0.0, 1.0)
+              end
+
+              def extract_cooperation(tick_results)
+                tick_results.dig(:empathy, :cooperation_ratio)
+              end
+
+              def extract_conflict(tick_results)
+                count = tick_results.dig(:conflict, :active_count)
+                return nil unless count.is_a?(Numeric)
+
+                (count / 5.0).clamp(0.0, 1.0)
+              end
+
+              def extract_volatility(tick_results)
+                tick_results.dig(:emotional_evaluation, :volatility) ||
+                  tick_results.dig(:emotion, :volatility)
+              end
+
+              def extract_mood_stability(tick_results)
+                tick_results.dig(:mood, :stability)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Personality
+          module Helpers
+            class TraitModel
+              attr_reader :traits, :observation_count, :history
+
+              def initialize
+                @traits = Constants::TRAITS.to_h do |trait|
+                  [trait, Constants::DEFAULT_TRAIT_VALUE]
+                end
+                @observation_count = 0
+                @history = []
+              end
+
+              def update(signals)
+                observations = extract_observations(signals)
+                return if observations.empty?
+
+                apply_observations(observations)
+                @observation_count += 1
+                record_snapshot
+              end
+
+              def trait(name)
+                @traits[name.to_sym]
+              end
+
+              def formed?
+                @observation_count >= Constants::FORMATION_THRESHOLD
+              end
+
+              def dominant_trait
+                @traits.max_by { |_k, v| (v - 0.5).abs }&.first
+              end
+
+              def trait_level(name)
+                value = @traits[name.to_sym]
+                return nil unless value
+
+                if value >= Constants::HIGH_THRESHOLD
+                  :high
+                elsif value <= Constants::LOW_THRESHOLD
+                  :low
+                else
+                  :mid
+                end
+              end
+
+              def describe(name)
+                level = trait_level(name)
+                return nil unless level
+
+                Constants::TRAIT_DESCRIPTORS.dig(name.to_sym, level)
+              end
+
+              def profile
+                @traits.transform_values { |v| v.round(3) }
+              end
+
+              def stability
+                return 0.0 if @history.size < 5
+
+                recent = @history.last(10)
+                variances = Constants::TRAITS.map do |t|
+                  values = recent.map { |h| h[:traits][t] }
+                  mean = values.sum / values.size.to_f
+                  values.map { |v| (v - mean)**2 }.sum / values.size.to_f
+                end
+                avg_variance = variances.sum / variances.size.to_f
+                (1.0 - (avg_variance * 10)).clamp(0.0, 1.0)
+              end
+
+              def trend(name)
+                return :insufficient_data if @history.size < 5
+
+                values = @history.last(10).map { |h| h[:traits][name.to_sym] }
+                first_half = values[0...(values.size / 2)]
+                second_half = values[(values.size / 2)..]
+                diff = (second_half.sum / second_half.size.to_f) - (first_half.sum / first_half.size.to_f)
+
+                if diff > 0.02
+                  :increasing
+                elsif diff < -0.02
+                  :decreasing
+                else
+                  :stable
+                end
+              end
+
+              def to_h
+                {
+                  traits:            profile,
+                  observation_count: @observation_count,
+                  formed:            formed?,
+                  stability:         stability,
+                  dominant_trait:    dominant_trait,
+                  history_size:      @history.size
+                }
+              end
+
+              private
+
+              def extract_observations(signals)
+                observations = Hash.new { |h, k| h[k] = [] }
+
+                Constants::SIGNAL_MAP.each do |signal_key, (trait, direction, weight)|
+                  value = signals[signal_key]
+                  next unless value.is_a?(Numeric)
+
+                  effective = direction == :positive ? value : 1.0 - value
+                  observations[trait] << { value: effective, weight: weight }
+                end
+
+                observations
+              end
+
+              def apply_observations(observations)
+                observations.each do |trait, obs_list|
+                  weighted_sum = obs_list.sum { |o| o[:value] * o[:weight] }
+                  total_weight = obs_list.sum { |o| o[:weight] }
+                  next if total_weight.zero?
+
+                  target = (weighted_sum / total_weight).clamp(0.0, 1.0)
+                  @traits[trait] = ema(@traits[trait], target, Constants::TRAIT_ALPHA)
+                end
+              end
+
+              def ema(current, observed, alpha)
+                (current * (1.0 - alpha)) + (observed * alpha)
+              end
+
+              def record_snapshot
+                @history << { traits: @traits.dup, at: Time.now.utc }
+                @history.shift while @history.size > Constants::MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end