lex-agentic-self 0.1.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Fingerprint
+          module Helpers
+            module Constants
+              MAX_TRAITS   = 100
+              MAX_SAMPLES  = 500
+              EMA_ALPHA    = 0.15
+
+              TRAIT_CATEGORIES = %i[
+                processing_speed
+                accuracy
+                creativity
+                caution
+                thoroughness
+                risk_tolerance
+                abstraction_preference
+                social_orientation
+              ].freeze
+
+              DEVIATION_THRESHOLD = 0.3
+
+              IDENTITY_CONFIDENCE_LABELS = [
+                { range: (0.85..1.0), label: :certain },
+                { range: (0.65...0.85), label: :confident },
+                { range: (0.40...0.65), label: :developing },
+                { range: (0.20...0.40), label: :uncertain },
+                { range: (0.0...0.20),  label: :unknown }
+              ].freeze
+
+              TRAIT_STRENGTH_LABELS = [
+                { range: (0.80..1.0), label: :dominant },
+                { range: (0.60...0.80), label: :strong },
+                { range: (0.40...0.60), label: :moderate },
+                { range: (0.20...0.40), label: :weak },
+                { range: (0.0...0.20),  label: :absent }
+              ].freeze
+
+              module_function
+
+              def identity_label_for(confidence)
+                entry = IDENTITY_CONFIDENCE_LABELS.find { |e| e[:range].cover?(confidence) }
+                entry ? entry[:label] : :unknown
+              end
+
+              def trait_strength_label_for(value)
+                entry = TRAIT_STRENGTH_LABELS.find { |e| e[:range].cover?(value) }
+                entry ? entry[:label] : :absent
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/fingerprint/helpers/fingerprint_engine.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Fingerprint
+          module Helpers
+            class FingerprintEngine
+              attr_reader :samples
+
+              def initialize
+                @traits  = {}
+                @samples = []
+              end
+
+              def record_observation(category:, value:)
+                return { status: :invalid_category, category: category } unless Constants::TRAIT_CATEGORIES.include?(category)
+
+                trait = get_or_create_trait(category)
+                trait.record_sample!(value.clamp(0.0, 1.0))
+
+                @samples << { category: category, value: value.clamp(0.0, 1.0), recorded_at: Time.now.utc }
+                @samples.shift while @samples.size > Constants::MAX_SAMPLES
+
+                {
+                  status:   :recorded,
+                  category: category,
+                  baseline: trait.baseline,
+                  variance: trait.variance,
+                  samples:  trait.sample_count
+                }
+              end
+
+              def verify_identity(observations:)
+                return { match_score: 0.0, verdict: :insufficient_data } if observations.empty? || @traits.empty?
+
+                scored = score_observations(observations)
+                return { match_score: 0.0, verdict: :insufficient_data } if scored.empty?
+
+                score = (scored.sum / scored.size).round(10)
+                { match_score: score, verdict: score_verdict(score), observations_checked: scored.size }
+              end
+
+              def trait_profile
+                @traits.transform_values(&:baseline)
+              end
+
+              def strongest_traits(top_n = 3)
+                @traits.values
+                       .sort_by { |t| -t.baseline }
+                       .first(top_n)
+                       .map(&:to_h)
+              end
+
+              def weakest_traits(top_n = 3)
+                @traits.values
+                       .sort_by(&:baseline)
+                       .first(top_n)
+                       .map(&:to_h)
+              end
+
+              def identity_confidence
+                return 0.0 if @traits.empty?
+
+                stable_count = @traits.values.count(&:stable?)
+                sampled      = @traits.values.select { |t| t.sample_count.positive? }
+                return 0.0 if sampled.empty?
+
+                coverage  = sampled.size.to_f / Constants::TRAIT_CATEGORIES.size
+                stability = stable_count.to_f / @traits.size
+
+                ((coverage * 0.6) + (stability * 0.4)).round(10).clamp(0.0, 1.0)
+              end
+
+              def identity_label
+                Constants.identity_label_for(identity_confidence)
+              end
+
+              def anomaly_check(category:, value:)
+                trait = @traits[category]
+                return { anomaly: false, reason: :no_baseline } unless trait
+
+                dev     = trait.deviation_from(value.clamp(0.0, 1.0))
+                anomaly = dev >= Constants::DEVIATION_THRESHOLD
+                {
+                  anomaly:   anomaly,
+                  category:  category,
+                  value:     value.clamp(0.0, 1.0),
+                  baseline:  trait.baseline,
+                  deviation: dev.round(10),
+                  threshold: Constants::DEVIATION_THRESHOLD
+                }
+              end
+
+              def fingerprint_hash
+                return nil if @traits.empty?
+
+                profile_string = Constants::TRAIT_CATEGORIES.map do |cat|
+                  t = @traits[cat]
+                  t ? "#{cat}:#{t.baseline.round(6)}" : "#{cat}:nil"
+                end.join('|')
+
+                require 'digest'
+                ::Digest::SHA256.hexdigest(profile_string)[0, 16]
+              end
+
+              def trait_count
+                @traits.size
+              end
+
+              def sample_count
+                @samples.size
+              end
+
+              def fingerprint_report
+                {
+                  fingerprint_hash:    fingerprint_hash,
+                  identity_confidence: identity_confidence,
+                  identity_label:      identity_label,
+                  trait_count:         trait_count,
+                  sample_count:        @samples.size,
+                  traits:              @traits.transform_values(&:to_h)
+                }
+              end
+
+              def to_h
+                fingerprint_report
+              end
+
+              private
+
+              def score_observations(observations)
+                observations.filter_map do |obs|
+                  cat   = obs[:category]
+                  val   = obs[:value]
+                  trait = @traits[cat]
+                  next unless trait && Constants::TRAIT_CATEGORIES.include?(cat)
+
+                  dev = trait.deviation_from(val.clamp(0.0, 1.0))
+                  [1.0 - (dev / [Constants::DEVIATION_THRESHOLD, 0.001].max), 0.0].max.clamp(0.0, 1.0)
+                end
+              end
+
+              def score_verdict(score)
+                if score >= 0.7
+                  :verified
+                elsif score >= 0.4
+                  :uncertain
+                else
+                  :mismatch
+                end
+              end
+
+              def get_or_create_trait(category)
+                @traits[category] ||= CognitiveTrait.new(category: category)
+                if @traits.size > Constants::MAX_TRAITS
+                  oldest_key = @traits.min_by { |_, t| t.last_updated }.first
+                  @traits.delete(oldest_key)
+                end
+                @traits[category]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Fingerprint
+          module Runners
+            module CognitiveFingerprint
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def record_observation(category:, value:, **)
+                category = category.to_sym
+                result   = fingerprint_engine.record_observation(category: category, value: value.to_f)
+                Legion::Logging.debug "[cognitive_fingerprint] record category=#{category} " \
+                                      "baseline=#{result[:baseline]&.round(4)} samples=#{result[:samples]}"
+                result
+              end
+
+              def verify_identity(observations:, **)
+                parsed = Array(observations).map do |obs|
+                  { category: obs[:category].to_sym, value: obs[:value].to_f }
+                end
+                result = fingerprint_engine.verify_identity(observations: parsed)
+                Legion::Logging.info "[cognitive_fingerprint] verify score=#{result[:match_score]&.round(4)} " \
+                                     "verdict=#{result[:verdict]}"
+                result
+              end
+
+              def anomaly_check(category:, value:, **)
+                result = fingerprint_engine.anomaly_check(category: category.to_sym, value: value.to_f)
+                if result[:anomaly]
+                  Legion::Logging.warn "[cognitive_fingerprint] anomaly category=#{category} " \
+                                       "deviation=#{result[:deviation]&.round(4)}"
+                end
+                result
+              end
+
+              def trait_profile(**)
+                { profile: fingerprint_engine.trait_profile }
+              end
+
+              def strongest_traits(top_n: 3, **)
+                { traits: fingerprint_engine.strongest_traits(top_n.to_i) }
+              end
+
+              def weakest_traits(top_n: 3, **)
+                { traits: fingerprint_engine.weakest_traits(top_n.to_i) }
+              end
+
+              def identity_confidence(**)
+                confidence = fingerprint_engine.identity_confidence
+                label      = fingerprint_engine.identity_label
+                Legion::Logging.debug "[cognitive_fingerprint] confidence=#{confidence.round(4)} label=#{label}"
+                { confidence: confidence, label: label }
+              end
+
+              def fingerprint_hash(**)
+                { fingerprint_hash: fingerprint_engine.fingerprint_hash }
+              end
+
+              def fingerprint_report(**)
+                fingerprint_engine.fingerprint_report
+              end
+
+              def fingerprint_status(**)
+                {
+                  trait_count:  fingerprint_engine.trait_count,
+                  sample_count: fingerprint_engine.sample_count,
+                  label:        fingerprint_engine.identity_label
+                }
+              end
+
+              private
+
+              def fingerprint_engine
+                @fingerprint_engine ||= Helpers::FingerprintEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/fingerprint/version'
+require 'legion/extensions/agentic/self/fingerprint/helpers/constants'
+require 'legion/extensions/agentic/self/fingerprint/helpers/cognitive_trait'
+require 'legion/extensions/agentic/self/fingerprint/helpers/fingerprint_engine'
+require 'legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint'
+require 'legion/extensions/agentic/self/fingerprint/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Fingerprint
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/identity/actors/credential_refresh.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Identity
+          module Actor
+            class CredentialRefresh < Legion::Extensions::Actors::Every
+              CREDENTIAL_REFRESH_INTERVAL = 21_600 # 6 hours
+
+              def runner_class
+                Legion::Extensions::Agentic::Self::Identity::Runners::Entra
+              end
+
+              def runner_function
+                'credential_refresh_cycle'
+              end
+
+              def time
+                CREDENTIAL_REFRESH_INTERVAL
+              end
+
+              def enabled?
+                defined?(Legion::Data) && Legion::Settings[:data][:connected] != false
+              rescue StandardError
+                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/identity/actors/orphan_check.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Identity
+          module Actor
+            # Periodic orphan detection: scans active workers for disabled Entra apps
+            # or inactive owners. Runs every 4 hours by default.
+            # Requires legion-data for worker records.
+            class OrphanCheck < Legion::Extensions::Actors::Every
+              ORPHAN_CHECK_INTERVAL = 14_400 # 4 hours in seconds
+
+              def runner_class
+                Legion::Extensions::Agentic::Self::Identity::Runners::Entra
+              end
+
+              def runner_function
+                'check_orphans'
+              end
+
+              def time
+                ORPHAN_CHECK_INTERVAL
+              end
+
+              def enabled?
+                defined?(Legion::Data) && Legion::Settings[:data][:connected] != false
+              rescue StandardError
+                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/identity/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/identity/helpers/dimensions'
+require 'legion/extensions/agentic/self/identity/helpers/fingerprint'
+require 'legion/extensions/agentic/self/identity/runners/identity'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Identity
+          class Client
+            include Runners::Identity
+
+            def initialize(**)
+              @identity_fingerprint = Helpers::Fingerprint.new
+            end
+
+            private
+
+            attr_reader :identity_fingerprint
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/identity/helpers/dimensions.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Identity
+          module Helpers
+            module Dimensions
+              # The 6 behavioral dimensions that constitute identity
+              IDENTITY_DIMENSIONS = %i[
+                communication_cadence
+                vocabulary_patterns
+                emotional_response
+                decision_patterns
+                contextual_consistency
+                temporal_patterns
+              ].freeze
+
+              # Entropy thresholds (from tick-loop-spec Phase 4)
+              HIGH_ENTROPY_THRESHOLD = 0.70
+              LOW_ENTROPY_THRESHOLD  = 0.20
+              OPTIMAL_ENTROPY_RANGE  = (0.20..0.70)
+
+              # EMA alpha for dimension updates
+              OBSERVATION_ALPHA = 0.1
+
+              module_function
+
+              def new_identity_model
+                IDENTITY_DIMENSIONS.to_h do |dim|
+                  [dim, { mean: 0.5, variance: 0.1, observations: 0, last_observed: nil }]
+                end
+              end
+
+              def compute_entropy(observations, model)
+                return 0.5 if observations.empty?
+
+                divergences = IDENTITY_DIMENSIONS.filter_map do |dim|
+                  obs = observations[dim]
+                  next unless obs
+
+                  baseline = model[dim]
+                  next 0.0 unless baseline && baseline[:observations].positive?
+
+                  # Weighted divergence from established baseline
+                  (obs - baseline[:mean]).abs / [baseline[:variance].to_f, 0.1].max
+                end
+
+                return 0.5 if divergences.empty?
+
+                raw = divergences.sum / divergences.size
+                clamp(raw / 3.0) # normalize: divergence of 3.0 stddevs = entropy 1.0
+              end
+
+              def classify_entropy(entropy)
+                if entropy > HIGH_ENTROPY_THRESHOLD
+                  :high_entropy
+                elsif entropy < LOW_ENTROPY_THRESHOLD
+                  :low_entropy
+                else
+                  :normal
+                end
+              end
+
+              def clamp(value, min = 0.0, max = 1.0)
+                value.clamp(min, max)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end