lex-agentic-self 0.1.0

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfModel
+          module Helpers
+            class SelfModel
+              include Constants
+
+              attr_reader :capabilities, :knowledge_domains, :predictions, :history
+
+              def initialize
+                @capabilities      = {}
+                @knowledge_domains = {}
+                @predictions       = []
+                @history           = []
+                @cap_counter       = 0
+                @dom_counter       = 0
+              end
+
+              def add_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE)
+                return nil if @capabilities.size >= MAX_CAPABILITIES
+
+                @cap_counter += 1
+                cap_id = :"cap_#{@cap_counter}"
+                cap = Capability.new(id: cap_id, name: name, domain: domain, competence: competence)
+                @capabilities[cap_id] = cap
+                cap
+              end
+
+              def add_knowledge_domain(name:, depth: 0.0, breadth: 0.0)
+                return nil if @knowledge_domains.size >= MAX_KNOWLEDGE_DOMAINS
+
+                @dom_counter += 1
+                dom_id = :"dom_#{@dom_counter}"
+                dom = KnowledgeDomain.new(id: dom_id, name: name, depth: depth, breadth: breadth)
+                @knowledge_domains[dom_id] = dom
+                dom
+              end
+
+              def predict_success(capability_id:)
+                cap = @capabilities[capability_id]
+                return nil unless cap
+
+                prediction = { capability_id: capability_id, predicted_probability: cap.competence.round(4),
+                               at: Time.now.utc }
+                @predictions << prediction
+                @predictions.shift while @predictions.size > MAX_HISTORY
+                prediction
+              end
+
+              def record_outcome(capability_id:, predicted:, actual:)
+                cap = @capabilities[capability_id]
+                return nil unless cap
+
+                cap.record_attempt(predicted_success: predicted, actual_success: actual)
+                event = { type: :outcome, capability_id: capability_id, predicted: predicted,
+                          actual: actual, at: Time.now.utc }
+                @history << event
+                @history.shift while @history.size > MAX_HISTORY
+                event
+              end
+
+              def introspect
+                {
+                  overall_confidence: overall_confidence.round(4),
+                  strengths:          strengths.map(&:to_h),
+                  weaknesses:         weaknesses.map(&:to_h),
+                  blind_spots:        blind_spots.map(&:to_h),
+                  knowledge_gaps:     knowledge_gaps.map(&:to_h),
+                  calibration:        calibration_report
+                }
+              end
+
+              def strengths
+                @capabilities.values.select { |c| c.competence > 0.7 }
+              end
+
+              def weaknesses
+                @capabilities.values.select { |c| c.competence < 0.3 }
+              end
+
+              def blind_spots
+                @capabilities.values.select(&:overconfident?)
+              end
+
+              def calibration_report
+                caps = @capabilities.values
+                return { label: :uncalibrated, mean_error: 0.0, calibrated_count: 0, total: 0 } if caps.empty?
+
+                errors = caps.map { |c| c.calibration_error.abs }
+                mean_error = errors.sum / errors.size.to_f
+                calibrated_count = caps.count(&:calibrated?)
+
+                label = CALIBRATION_LABELS.each do |lbl, threshold|
+                  break lbl if mean_error <= threshold
+                end
+                label = :uncalibrated unless label.is_a?(Symbol)
+
+                { label: label, mean_error: mean_error.round(4), calibrated_count: calibrated_count,
+                  total: caps.size }
+              end
+
+              def knowledge_gaps
+                @knowledge_domains.values.select { |d| d.depth < 0.3 }
+              end
+
+              def can_do?(capability_name)
+                cap = @capabilities.values.find { |c| c.name == capability_name }
+                return false unless cap
+
+                cap.competence >= 0.5
+              end
+
+              def knows_about?(domain_name)
+                dom = @knowledge_domains.values.find { |d| d.name == domain_name }
+                return false unless dom
+
+                dom.confidence >= 0.5
+              end
+
+              def overall_confidence
+                return DEFAULT_COMPETENCE if @capabilities.empty?
+
+                total = @capabilities.values.sum(&:competence)
+                total / @capabilities.size.to_f
+              end
+
+              def to_h
+                {
+                  capability_count:       @capabilities.size,
+                  knowledge_domain_count: @knowledge_domains.size,
+                  overall_confidence:     overall_confidence.round(4),
+                  strength_count:         strengths.size,
+                  weakness_count:         weaknesses.size,
+                  blind_spot_count:       blind_spots.size,
+                  knowledge_gap_count:    knowledge_gaps.size,
+                  prediction_count:       @predictions.size,
+                  history_size:           @history.size
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfModel
+          module Runners
+            module SelfModel
+              include Helpers::Constants
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def add_self_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE, **)
+                cap = model.add_capability(name: name, domain: domain, competence: competence)
+                return { success: false, reason: :limit_reached } unless cap
+
+                { success: true, capability_id: cap.id, competence: cap.competence.round(4), state: cap.state }
+              end
+
+              def add_self_knowledge(name:, depth: 0.0, breadth: 0.0, **)
+                dom = model.add_knowledge_domain(name: name, depth: depth, breadth: breadth)
+                return { success: false, reason: :limit_reached } unless dom
+
+                { success: true, domain_id: dom.id, depth: dom.depth.round(4), breadth: dom.breadth.round(4),
+                  state: dom.state }
+              end
+
+              def predict_own_success(capability_id:, **)
+                prediction = model.predict_success(capability_id: capability_id)
+                return { success: false, reason: :not_found } unless prediction
+
+                { success: true }.merge(prediction)
+              end
+
+              def record_self_outcome(capability_id:, predicted:, actual:, **)
+                event = model.record_outcome(capability_id: capability_id, predicted: predicted, actual: actual)
+                return { success: false, reason: :not_found } unless event
+
+                cap = model.capabilities[capability_id]
+                { success: true, capability_id: capability_id, competence: cap.competence.round(4),
+                  calibration_error: cap.calibration_error.round(4) }
+              end
+
+              def self_introspection(**)
+                { success: true }.merge(model.introspect)
+              end
+
+              def self_strengths(**)
+                strengths = model.strengths.map(&:to_h)
+                { success: true, strengths: strengths, count: strengths.size }
+              end
+
+              def self_weaknesses(**)
+                weaknesses = model.weaknesses.map(&:to_h)
+                { success: true, weaknesses: weaknesses, count: weaknesses.size }
+              end
+
+              def self_blind_spots(**)
+                blind_spots = model.blind_spots.map(&:to_h)
+                { success: true, blind_spots: blind_spots, count: blind_spots.size }
+              end
+
+              def self_calibration_report(**)
+                { success: true }.merge(model.calibration_report)
+              end
+
+              def self_model_stats(**)
+                { success: true }.merge(model.to_h)
+              end
+
+              private
+
+              def model
+                @model ||= Helpers::SelfModel.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'self_model/version'
+require_relative 'self_model/helpers/constants'
+require_relative 'self_model/helpers/capability'
+require_relative 'self_model/helpers/knowledge_domain'
+require_relative 'self_model/helpers/self_model'
+require_relative 'self_model/runners/self_model'
+require_relative 'self_model/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfModel
+          # Sub-module for self-model: stable beliefs about capabilities, limitations, and values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Actor
+            class VolumeDecay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk
+              end
+
+              def runner_function
+                'decay_voices'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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/runners/self_talk'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          class Client
+            include Runners::SelfTalk
+
+            def initialize(**)
+              @engine = Helpers::SelfTalkEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            module Constants
+              MAX_VOICES           = 10
+              MAX_DIALOGUES        = 200
+              MAX_TURNS_PER_DIALOGUE = 50
+              DEFAULT_VOLUME       = 0.5
+              VOLUME_BOOST         = 0.1
+              VOLUME_DECAY         = 0.05
+
+              VOICE_TYPES = %i[
+                critic
+                encourager
+                analyst
+                devils_advocate
+                pragmatist
+                visionary
+                caretaker
+                rebel
+              ].freeze
+
+              DIALOGUE_STATUSES = %i[open concluded deadlocked abandoned].freeze
+
+              DOMINANCE_LABELS = {
+                (0.8..1.0)  => :commanding,
+                (0.6...0.8) => :assertive,
+                (0.4...0.6) => :balanced,
+                (0.2...0.4) => :quiet,
+                (0.0...0.2) => :silent
+              }.freeze
+
+              CONSENSUS_LABELS = {
+                (0.8..1.0)  => :unanimous,
+                (0.6...0.8) => :agreement,
+                (0.4...0.6) => :mixed,
+                (0.2...0.4) => :disagreement,
+                (0.0...0.2) => :conflict
+              }.freeze
+
+              module_function
+
+              def dominance_label(volume)
+                DOMINANCE_LABELS.each { |range, label| return label if range.cover?(volume) }
+                :silent
+              end
+
+              def consensus_label(score)
+                CONSENSUS_LABELS.each { |range, label| return label if range.cover?(score) }
+                :conflict
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            class Dialogue
+              attr_reader :id, :topic, :turns, :status, :conclusion, :created_at
+
+              def initialize(topic:)
+                @id         = SecureRandom.uuid
+                @topic      = topic
+                @turns      = []
+                @status     = :open
+                @conclusion = nil
+                @created_at = Time.now.utc
+              end
+
+              def add_turn!(voice_id:, content:, position: :clarify, strength: 0.5)
+                return false if @turns.size >= Constants::MAX_TURNS_PER_DIALOGUE
+                return false unless active?
+
+                turn = DialogueTurn.new(
+                  dialogue_id: @id,
+                  voice_id:    voice_id,
+                  content:     content,
+                  position:    position,
+                  strength:    strength
+                )
+                @turns << turn
+                turn
+              end
+
+              def conclude!(summary)
+                return false unless active?
+
+                @conclusion = summary
+                @status     = :concluded
+                true
+              end
+
+              def deadlock!
+                return false unless active?
+
+                @status = :deadlocked
+                true
+              end
+
+              def abandon!
+                return false unless active?
+
+                @status = :abandoned
+                true
+              end
+
+              def active?
+                @status == :open
+              end
+
+              def concluded?
+                @status == :concluded
+              end
+
+              def turn_count
+                @turns.size
+              end
+
+              def voice_positions
+                grouped = @turns.group_by(&:voice_id)
+                grouped.transform_values do |voice_turns|
+                  voice_turns.sum(&:strength) / voice_turns.size.to_f
+                end
+              end
+
+              def consensus_score
+                return 1.0 if @turns.empty?
+
+                support_strength = @turns.select { |t| t.position == :support }.sum(&:strength)
+                oppose_strength  = @turns.select { |t| t.position == :oppose }.sum(&:strength)
+                total            = support_strength + oppose_strength
+                return 0.5 if total.zero?
+
+                stronger = [support_strength, oppose_strength].max
+                stronger / total
+              end
+
+              def consensus_label
+                Constants.consensus_label(consensus_score)
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  topic:           @topic,
+                  status:          @status,
+                  conclusion:      @conclusion,
+                  turn_count:      turn_count,
+                  consensus_score: consensus_score.round(10),
+                  consensus_label: consensus_label,
+                  created_at:      @created_at,
+                  turns:           @turns.map(&:to_h)
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            class DialogueTurn
+              POSITIONS = %i[support oppose question clarify].freeze
+
+              attr_reader :id, :dialogue_id, :voice_id, :content, :position, :strength, :created_at
+
+              def initialize(dialogue_id:, voice_id:, content:, position: :clarify, strength: 0.5)
+                @id          = SecureRandom.uuid
+                @dialogue_id = dialogue_id
+                @voice_id    = voice_id
+                @content     = content
+                @position    = POSITIONS.include?(position) ? position : :clarify
+                @strength    = strength.clamp(0.0, 1.0)
+                @created_at  = Time.now.utc
+              end
+
+              def to_h
+                {
+                  id:          @id,
+                  dialogue_id: @dialogue_id,
+                  voice_id:    @voice_id,
+                  content:     @content,
+                  position:    @position,
+                  strength:    @strength.round(10),
+                  created_at:  @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module SelfTalk
+          module Helpers
+            class InnerVoice
+              attr_reader :id, :name, :voice_type, :bias_direction, :created_at
+              attr_accessor :volume, :active
+
+              def initialize(name:, voice_type:, volume: Constants::DEFAULT_VOLUME, bias_direction: nil, active: true)
+                @id             = SecureRandom.uuid
+                @name           = name
+                @voice_type     = voice_type
+                @volume         = volume.clamp(0.0, 1.0)
+                @bias_direction = bias_direction
+                @active         = active
+                @created_at     = Time.now.utc
+              end
+
+              def amplify!(amount = Constants::VOLUME_BOOST)
+                @volume = (@volume + amount).clamp(0.0, 1.0)
+                self
+              end
+
+              def dampen!(amount = Constants::VOLUME_DECAY)
+                @volume = (@volume - amount).clamp(0.0, 1.0)
+                self
+              end
+
+              def mute!
+                @active = false
+                self
+              end
+
+              def unmute!
+                @active = true
+                self
+              end
+
+              def dominant?
+                @volume >= 0.7
+              end
+
+              def quiet?
+                @volume <= 0.3
+              end
+
+              def volume_label
+                Constants.dominance_label(@volume)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  name:           @name,
+                  voice_type:     @voice_type,
+                  volume:         @volume.round(10),
+                  volume_label:   volume_label,
+                  bias_direction: @bias_direction,
+                  active:         @active,
+                  dominant:       dominant?,
+                  quiet:          quiet?,
+                  created_at:     @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end