lex-agentic-self 0.1.0

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            module LlmEnhancer
+              SYSTEM_PROMPT = <<~PROMPT
+                You are an internal cognitive voice in an autonomous AI agent's inner dialogue system.
+                When asked to speak as a specific voice type, adopt that perspective fully:
+                - critic: skeptical, identifies flaws and risks
+                - encourager: supportive, finds reasons for optimism
+                - analyst: data-driven, logical, weighs evidence
+                - devils_advocate: challenges assumptions, plays the contrarian
+                - pragmatist: focuses on what's actionable and achievable
+                - visionary: thinks big picture, sees future possibilities
+                - caretaker: concerned about wellbeing and sustainability
+                - rebel: questions authority, pushes for unconventional approaches
+                Be concise (1-3 sentences). Stay in character. Take a clear position.
+              PROMPT
+
+              module_function
+
+              def available?
+                !!(defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?)
+              rescue StandardError
+                false
+              end
+
+              def generate_turn(voice_type:, topic:, prior_turns:)
+                prompt = build_generate_turn_prompt(voice_type: voice_type, topic: topic, prior_turns: prior_turns)
+                response = llm_ask(prompt)
+                parse_generate_turn_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[self_talk:llm] generate_turn failed: #{e.message}"
+                nil
+              end
+
+              def summarize_dialogue(topic:, turns:)
+                prompt = build_summarize_dialogue_prompt(topic: topic, turns: turns)
+                response = llm_ask(prompt)
+                parse_summarize_dialogue_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[self_talk:llm] summarize_dialogue 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_generate_turn_prompt(voice_type:, topic:, prior_turns:)
+                prior_lines = prior_turns.map do |t|
+                  "[#{t[:voice_name] || t[:voice_id]}] (#{t[:position]}): #{t[:content]}"
+                end.join("\n")
+
+                prior_section = prior_lines.empty? ? '(no prior turns)' : prior_lines
+
+                <<~PROMPT
+                  Topic: #{topic}
+                  You are speaking as: #{voice_type}
+
+                  Previous turns in this dialogue:
+                  #{prior_section}
+
+                  Respond in character. Format EXACTLY as:
+                  POSITION: support | oppose | question | clarify
+                  CONTENT: <your 1-3 sentence response>
+                PROMPT
+              end
+              private_class_method :build_generate_turn_prompt
+
+              def parse_generate_turn_response(response)
+                return nil unless response&.content
+
+                text = response.content
+                position_match = text.match(/POSITION:\s*(support|oppose|question|clarify)/i)
+                content_match  = text.match(/CONTENT:\s*(.+)/im)
+
+                return nil unless position_match && content_match
+
+                position = position_match.captures.first.strip.downcase.to_sym
+                content  = content_match.captures.first.strip
+
+                { content: content, position: position }
+              end
+              private_class_method :parse_generate_turn_response
+
+              def build_summarize_dialogue_prompt(topic:, turns:)
+                turn_lines = turns.map do |t|
+                  "[#{t[:voice_name] || t[:voice_id]}] (#{t[:position]}): #{t[:content]}"
+                end.join("\n")
+
+                <<~PROMPT
+                  Topic: #{topic}
+
+                  Dialogue turns:
+                  #{turn_lines}
+
+                  Synthesize this dialogue into a conclusion. Format EXACTLY as:
+                  RECOMMENDATION: support | oppose | abstain
+                  SUMMARY: <2-3 sentence synthesis of the key points and conclusion>
+                PROMPT
+              end
+              private_class_method :build_summarize_dialogue_prompt
+
+              def parse_summarize_dialogue_response(response)
+                return nil unless response&.content
+
+                text = response.content
+                recommendation_match = text.match(/RECOMMENDATION:\s*(support|oppose|abstain)/i)
+                summary_match        = text.match(/SUMMARY:\s*(.+)/im)
+
+                return nil unless recommendation_match && summary_match
+
+                recommendation = recommendation_match.captures.first.strip.downcase.to_sym
+                summary        = summary_match.captures.first.strip
+
+                { summary: summary, recommendation: recommendation }
+              end
+              private_class_method :parse_summarize_dialogue_response
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/self_talk/helpers/self_talk_engine.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            class SelfTalkEngine
+              attr_reader :voices, :dialogues
+
+              def initialize
+                @voices    = {}
+                @dialogues = {}
+              end
+
+              def register_voice(name:, voice_type:, volume: Constants::DEFAULT_VOLUME, bias_direction: nil)
+                return { registered: false, reason: :max_voices } if @voices.size >= Constants::MAX_VOICES
+                return { registered: false, reason: :unknown_type } unless Constants::VOICE_TYPES.include?(voice_type)
+
+                voice = InnerVoice.new(
+                  name:           name,
+                  voice_type:     voice_type,
+                  volume:         volume,
+                  bias_direction: bias_direction
+                )
+                @voices[voice.id] = voice
+                { registered: true, voice: voice.to_h }
+              end
+
+              def start_dialogue(topic:)
+                prune_dialogues_if_needed
+                dialogue = Dialogue.new(topic: topic)
+                @dialogues[dialogue.id] = dialogue
+                { started: true, dialogue: dialogue.to_h }
+              end
+
+              def add_turn(dialogue_id:, voice_id:, content:, position: :clarify, strength: 0.5)
+                dialogue = @dialogues[dialogue_id]
+                return { added: false, reason: :dialogue_not_found } unless dialogue
+
+                voice = @voices[voice_id]
+                return { added: false, reason: :voice_not_found } unless voice
+                return { added: false, reason: :voice_inactive } unless voice.active
+
+                turn = dialogue.add_turn!(
+                  voice_id: voice_id,
+                  content:  content,
+                  position: position,
+                  strength: strength
+                )
+                return { added: false, reason: :limit_reached_or_closed } unless turn
+
+                { added: true, turn: turn.to_h }
+              end
+
+              def conclude_dialogue(dialogue_id:, summary:)
+                dialogue = @dialogues[dialogue_id]
+                return { concluded: false, reason: :not_found } unless dialogue
+
+                result = dialogue.conclude!(summary)
+                { concluded: result, dialogue_id: dialogue_id }
+              end
+
+              def deadlock_dialogue(dialogue_id:)
+                dialogue = @dialogues[dialogue_id]
+                return { deadlocked: false, reason: :not_found } unless dialogue
+
+                result = dialogue.deadlock!
+                { deadlocked: result, dialogue_id: dialogue_id }
+              end
+
+              def active_dialogues
+                @dialogues.values.select(&:active?)
+              end
+
+              def concluded_dialogues
+                @dialogues.values.select(&:concluded?)
+              end
+
+              def dominant_voice
+                active = @voices.values.select(&:active)
+                return nil if active.empty?
+
+                active.max_by(&:volume)
+              end
+
+              def quietest_voice
+                active = @voices.values.select(&:active)
+                return nil if active.empty?
+
+                active.min_by(&:volume)
+              end
+
+              def voice_balance
+                return {} if @voices.empty?
+
+                total = @voices.values.sum(&:volume)
+                @voices.transform_values do |v|
+                  total.positive? ? (v.volume / total).round(10) : 0.0
+                end
+              end
+
+              def amplify_voice(voice_id:, amount: Constants::VOLUME_BOOST)
+                voice = @voices[voice_id]
+                return { amplified: false, reason: :not_found } unless voice
+
+                voice.amplify!(amount)
+                { amplified: true, voice_id: voice_id, volume: voice.volume.round(10) }
+              end
+
+              def dampen_voice(voice_id:, amount: Constants::VOLUME_DECAY)
+                voice = @voices[voice_id]
+                return { dampened: false, reason: :not_found } unless voice
+
+                voice.dampen!(amount)
+                { dampened: true, voice_id: voice_id, volume: voice.volume.round(10) }
+              end
+
+              def dialogue_report(dialogue_id:)
+                dialogue = @dialogues[dialogue_id]
+                return { found: false } unless dialogue
+
+                positions = dialogue.voice_positions.transform_keys do |vid|
+                  @voices[vid]&.name || vid
+                end
+
+                {
+                  found:           true,
+                  dialogue:        dialogue.to_h,
+                  voice_positions: positions
+                }
+              end
+
+              def to_h
+                {
+                  voice_count:           @voices.size,
+                  dialogue_count:        @dialogues.size,
+                  active_dialogue_count: active_dialogues.size,
+                  dominant_voice:        dominant_voice&.to_h,
+                  quietest_voice:        quietest_voice&.to_h,
+                  voice_balance:         voice_balance
+                }
+              end
+
+              private
+
+              def prune_dialogues_if_needed
+                return unless @dialogues.size >= Constants::MAX_DIALOGUES
+
+                oldest_key = @dialogues.min_by { |_, d| d.created_at }&.first
+                @dialogues.delete(oldest_key) if oldest_key
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Runners
+            module SelfTalk
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_voice(name:, voice_type:, volume: Helpers::Constants::DEFAULT_VOLUME,
+                                 bias_direction: nil, **)
+                result = engine.register_voice(
+                  name:           name,
+                  voice_type:     voice_type,
+                  volume:         volume,
+                  bias_direction: bias_direction
+                )
+                Legion::Logging.info "[self_talk] register_voice: name=#{name} type=#{voice_type} registered=#{result[:registered]}"
+                result
+              end
+
+              def start_dialogue(topic:, **)
+                result = engine.start_dialogue(topic: topic)
+                Legion::Logging.debug "[self_talk] start_dialogue: topic=#{topic} id=#{result[:dialogue][:id]}"
+                result
+              end
+
+              def add_turn(dialogue_id:, voice_id:, content:, position: :clarify, strength: 0.5, **)
+                result = engine.add_turn(
+                  dialogue_id: dialogue_id,
+                  voice_id:    voice_id,
+                  content:     content,
+                  position:    position,
+                  strength:    strength
+                )
+                Legion::Logging.debug "[self_talk] add_turn: dialogue=#{dialogue_id} voice=#{voice_id} added=#{result[:added]}"
+                result
+              end
+
+              def conclude_dialogue(dialogue_id:, summary: nil, **)
+                resolved_summary = summary || generate_summary_for_dialogue(dialogue_id)
+                result = engine.conclude_dialogue(dialogue_id: dialogue_id, summary: resolved_summary)
+                Legion::Logging.info "[self_talk] conclude_dialogue: id=#{dialogue_id} concluded=#{result[:concluded]}"
+                result
+              end
+
+              def generate_voice_turn(dialogue_id:, voice_id:, **)
+                dialogue_data = engine.dialogues[dialogue_id]
+                voice_data    = engine.voices[voice_id]
+                return missing_entity_error(dialogue_data) unless dialogue_data && voice_data
+
+                content, source = resolve_turn_content(voice_data, dialogue_data)
+                turn_result = add_turn(
+                  dialogue_id: dialogue_id,
+                  voice_id:    voice_id,
+                  content:     content[:content],
+                  position:    content[:position]
+                )
+                Legion::Logging.debug "[self_talk] generate_voice_turn: dialogue=#{dialogue_id} voice=#{voice_id} source=#{source}"
+                { generated: true, source: source, turn: turn_result[:turn] }
+              end
+
+              def deadlock_dialogue(dialogue_id:, **)
+                result = engine.deadlock_dialogue(dialogue_id: dialogue_id)
+                Legion::Logging.warn "[self_talk] deadlock_dialogue: id=#{dialogue_id} deadlocked=#{result[:deadlocked]}"
+                result
+              end
+
+              def amplify_voice(voice_id:, amount: Helpers::Constants::VOLUME_BOOST, **)
+                result = engine.amplify_voice(voice_id: voice_id, amount: amount)
+                Legion::Logging.debug "[self_talk] amplify_voice: id=#{voice_id} volume=#{result[:volume]}"
+                result
+              end
+
+              def dampen_voice(voice_id:, amount: Helpers::Constants::VOLUME_DECAY, **)
+                result = engine.dampen_voice(voice_id: voice_id, amount: amount)
+                Legion::Logging.debug "[self_talk] dampen_voice: id=#{voice_id} volume=#{result[:volume]}"
+                result
+              end
+
+              def dialogue_report(dialogue_id:, **)
+                result = engine.dialogue_report(dialogue_id: dialogue_id)
+                Legion::Logging.debug "[self_talk] dialogue_report: id=#{dialogue_id} found=#{result[:found]}"
+                result
+              end
+
+              def self_talk_status(**)
+                summary = engine.to_h
+                Legion::Logging.debug "[self_talk] status: voices=#{summary[:voice_count]} dialogues=#{summary[:dialogue_count]}"
+                summary
+              end
+
+              def decay_voices(**)
+                decayed = 0
+                voice_list = engine.voices.values.select(&:active).map do |voice|
+                  voice.dampen!(Helpers::Constants::VOLUME_DECAY)
+                  decayed += 1
+                  { id: voice.id, name: voice.name, volume: voice.volume }
+                end
+                Legion::Logging.debug "[self-talk] voice decay: decayed=#{decayed} voices"
+                { decayed: decayed, voices: voice_list }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::SelfTalkEngine.new
+              end
+
+              def missing_entity_error(dialogue_data)
+                { generated: false, reason: dialogue_data ? :voice_not_found : :dialogue_not_found }
+              end
+
+              def resolve_turn_content(voice_data, dialogue_data)
+                prior_turns = build_prior_turns(dialogue_data)
+                if Helpers::LlmEnhancer.available?
+                  llm_result = Helpers::LlmEnhancer.generate_turn(
+                    voice_type:  voice_data.voice_type,
+                    topic:       dialogue_data.topic,
+                    prior_turns: prior_turns
+                  )
+                  return [llm_result, :llm] if llm_result
+                end
+                [stub_turn_content(voice_data.voice_type, dialogue_data.topic), :mechanical]
+              end
+
+              def build_prior_turns(dialogue_data)
+                dialogue_data.turns.map do |t|
+                  speaking_voice = engine.voices[t.voice_id]
+                  { voice_id: t.voice_id, voice_name: speaking_voice&.name || t.voice_id,
+                    position: t.position, content: t.content }
+                end
+              end
+
+              def stub_turn_content(voice_type, topic)
+                { content: "[#{voice_type} perspective on #{topic}]", position: :clarify }
+              end
+
+              def generate_summary_for_dialogue(dialogue_id)
+                dialogue_data = engine.dialogues[dialogue_id]
+                return 'Dialogue concluded' unless dialogue_data
+
+                if Helpers::LlmEnhancer.available?
+                  turns = dialogue_data.turns.map do |t|
+                    speaking_voice = engine.voices[t.voice_id]
+                    {
+                      voice_id:   t.voice_id,
+                      voice_name: speaking_voice&.name || t.voice_id,
+                      position:   t.position,
+                      content:    t.content
+                    }
+                  end
+
+                  llm_result = Helpers::LlmEnhancer.summarize_dialogue(
+                    topic: dialogue_data.topic,
+                    turns: turns
+                  )
+                  return llm_result[:summary] if llm_result
+                end
+
+                'Dialogue concluded'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/self_talk/version'
+require 'legion/extensions/agentic/self/self_talk/helpers/constants'
+require 'legion/extensions/agentic/self/self_talk/helpers/inner_voice'
+require 'legion/extensions/agentic/self/self_talk/helpers/dialogue_turn'
+require 'legion/extensions/agentic/self/self_talk/helpers/dialogue'
+require 'legion/extensions/agentic/self/self_talk/helpers/self_talk_engine'
+require 'legion/extensions/agentic/self/self_talk/helpers/llm_enhancer'
+require 'legion/extensions/agentic/self/self_talk/runners/self_talk'
+require 'legion/extensions/agentic/self/self_talk/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'self/version'
+require_relative 'self/fingerprint'
+require_relative 'self/narrative_arc'
+require_relative 'self/anchor'
+require_relative 'self/architecture'
+require_relative 'self/narrative_identity'
+require_relative 'self/narrative_self'
+require_relative 'self/metacognition'
+require_relative 'self/metacognitive_monitoring'
+require_relative 'self/self_model'
+require_relative 'self/self_talk'
+require_relative 'self/identity'
+require_relative 'self/personality'
+require_relative 'self/agency'
+require_relative 'self/reflection'
+require_relative 'self/anosognosia'
+require_relative 'self/default_mode_network'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+        def remote_invocable?
+          false
+        end
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/agency/client_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Agency::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a default efficacy model' do
+      expect(client.efficacy_model).to be_a(Legion::Extensions::Agentic::Self::Agency::Helpers::EfficacyModel)
+    end
+
+    it 'accepts an injected model' do
+      custom = Legion::Extensions::Agentic::Self::Agency::Helpers::EfficacyModel.new
+      injected = described_class.new(efficacy_model: custom)
+      expect(injected.efficacy_model).to equal(custom)
+    end
+  end
+
+  describe 'Bandura self-efficacy lifecycle' do
+    it 'models the four sources of self-efficacy and their relative strengths' do
+      # Source 1: Mastery experience (strongest source)
+      client.record_mastery(domain: :coding, outcome_type: :success)
+      client.record_mastery(domain: :coding, outcome_type: :success)
+      coding_after_mastery = client.efficacy_model.efficacy_for(:coding)
+      expect(coding_after_mastery).to be > 0.5
+
+      # Source 2: Vicarious experience (weaker than mastery)
+      client.record_vicarious(domain: :public_speaking, outcome_type: :success)
+      speaking_after_vicarious = client.efficacy_model.efficacy_for(:public_speaking)
+      expect(speaking_after_vicarious).to be > 0.5
+      expect(speaking_after_vicarious).to be < coding_after_mastery
+
+      # Source 3: Verbal persuasion (weakest cognitive source)
+      client.record_persuasion(domain: :management, positive: true)
+      mgmt = client.efficacy_model.efficacy_for(:management)
+      expect(mgmt).to be > 0.5
+
+      # Source 4: Physiological state
+      client.record_physiological(domain: :exercise, state: :energized)
+      exercise = client.efficacy_model.efficacy_for(:exercise)
+      expect(exercise).to be >= 0.5
+
+      # Check overall stats
+      stats = client.agency_stats
+      expect(stats[:stats][:domain_count]).to eq(4)
+
+      # Decision gate: should attempt based on efficacy
+      coding_decision = client.should_attempt?(domain: :coding, threshold: 0.4)
+      expect(coding_decision[:should_attempt]).to be true
+
+      # Strongest domains should be coding (most mastery experiences)
+      strongest = client.strongest_domains(count: 1)
+      expect(strongest[:domains].keys.first).to eq(:coding)
+
+      # Now model failure — repeated failures erode self-efficacy
+      5.times { client.record_mastery(domain: :sales, outcome_type: :failure) }
+      sales_check = client.check_efficacy(domain: :sales)
+      expect(sales_check[:label]).to eq(:helpless).or eq(:doubtful)
+
+      # Decay over time moves everything slowly toward default
+      10.times { client.update_agency }
+      coding_after_decay = client.efficacy_model.efficacy_for(:coding)
+      expect(coding_after_decay).to be < coding_after_mastery
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/agency/helpers/constants_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Agency::Helpers::Constants do
+  describe 'DEFAULT_EFFICACY' do
+    it 'is 0.5 (moderate confidence)' do
+      expect(described_class::DEFAULT_EFFICACY).to eq(0.5)
+    end
+  end
+
+  describe 'EFFICACY_ALPHA' do
+    it 'is a low positive float for slow adaptation' do
+      expect(described_class::EFFICACY_ALPHA).to be_between(0.01, 0.5)
+    end
+  end
+
+  describe 'asymmetric reinforcement' do
+    it 'penalizes failure harder than it rewards success' do
+      expect(described_class::FAILURE_PENALTY).to be > described_class::MASTERY_BOOST
+    end
+  end
+
+  describe 'EFFICACY_SOURCES' do
+    it 'contains Bandura four sources' do
+      expect(described_class::EFFICACY_SOURCES).to contain_exactly(:mastery, :vicarious, :persuasion, :physiological)
+    end
+
+    it 'is frozen' do
+      expect(described_class::EFFICACY_SOURCES).to be_frozen
+    end
+  end
+
+  describe 'ATTRIBUTION_LEVELS' do
+    it 'has four levels' do
+      expect(described_class::ATTRIBUTION_LEVELS.size).to eq(4)
+    end
+
+    it 'has full_agency as highest' do
+      expect(described_class::ATTRIBUTION_LEVELS[:full_agency]).to be > described_class::ATTRIBUTION_LEVELS[:no_agency]
+    end
+
+    it 'is frozen' do
+      expect(described_class::ATTRIBUTION_LEVELS).to be_frozen
+    end
+  end
+
+  describe 'OUTCOME_TYPES' do
+    it 'includes success, failure, partial_success, unexpected' do
+      expect(described_class::OUTCOME_TYPES).to contain_exactly(:success, :failure, :partial_success, :unexpected)
+    end
+  end
+
+  describe 'EFFICACY_LABELS' do
+    it 'has five levels' do
+      expect(described_class::EFFICACY_LABELS.size).to eq(5)
+    end
+
+    it 'is frozen' do
+      expect(described_class::EFFICACY_LABELS).to be_frozen
+    end
+  end
+
+  describe 'bounds' do
+    it 'has a floor above zero' do
+      expect(described_class::EFFICACY_FLOOR).to be > 0.0
+    end
+
+    it 'has a ceiling below one' do
+      expect(described_class::EFFICACY_CEILING).to be < 1.0
+    end
+  end
+end