lex-agentic-self 0.1.0

data/lib/legion/extensions/agentic/self/anchor/helpers/anchor_engine.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anchor
+          module Helpers
+            class AnchorEngine
+              def initialize
+                @anchors = {}
+                @chains  = {}
+              end
+
+              def create_anchor(anchor_type:, domain:, content:,
+                                reference_value: nil, grip: nil, weight: nil)
+                raise ArgumentError, 'anchor limit reached' if @anchors.size >= Constants::MAX_ANCHORS
+
+                a = Anchor.new(anchor_type: anchor_type, domain: domain, content: content,
+                               reference_value: reference_value, grip: grip, weight: weight)
+                @anchors[a.id] = a
+                a
+              end
+
+              def create_chain(anchor_id:, material: :steel, length: nil, flexibility: nil)
+                raise ArgumentError, 'chain limit reached' if @chains.size >= Constants::MAX_CHAINS
+
+                fetch_anchor(anchor_id)
+                c = Chain.new(anchor_id: anchor_id, material: material,
+                              length: length, flexibility: flexibility)
+                @chains[c.id] = c
+                c
+              end
+
+              def apply_bias(anchor_id:, new_value:)
+                anchor = fetch_anchor(anchor_id)
+                pulled = anchor.bias_pull(new_value.to_f)
+                { anchor: anchor, original: new_value.to_f, biased: pulled,
+                  shift: (pulled - new_value.to_f).abs.round(10) }
+              end
+
+              def drag_anchor(anchor_id:, rate: Constants::DRAG_RATE)
+                anchor = fetch_anchor(anchor_id)
+                anchor.drag!(rate: rate)
+                anchor
+              end
+
+              def drift_all!
+                @anchors.each_value(&:drift!)
+              end
+
+              def wear_all_chains!
+                @chains.each_value(&:wear!)
+              end
+
+              def broken_chains
+                @chains.values.select(&:broken?)
+              end
+
+              def anchors_by_type
+                counts = Constants::ANCHOR_TYPES.to_h { |t| [t, 0] }
+                @anchors.each_value { |a| counts[a.anchor_type] += 1 }
+                counts
+              end
+
+              def strongest_anchors(limit: 5)
+                @anchors.values.sort_by { |a| -a.grip }.first(limit)
+              end
+
+              def weakest_anchors(limit: 5)
+                @anchors.values.sort_by(&:grip).first(limit)
+              end
+
+              def ironclad_anchors
+                @anchors.values.select(&:ironclad?)
+              end
+
+              def drifting_anchors
+                @anchors.values.select(&:drifting?)
+              end
+
+              def chains_for(anchor_id)
+                @chains.values.select { |c| c.anchor_id == anchor_id }
+              end
+
+              def avg_grip
+                return 0.0 if @anchors.empty?
+
+                (@anchors.values.sum(&:grip) / @anchors.size).round(10)
+              end
+
+              def anchor_report
+                {
+                  total_anchors:  @anchors.size,
+                  total_chains:   @chains.size,
+                  by_type:        anchors_by_type,
+                  ironclad_count: ironclad_anchors.size,
+                  drifting_count: drifting_anchors.size,
+                  broken_chains:  broken_chains.size,
+                  avg_grip:       avg_grip
+                }
+              end
+
+              def all_anchors
+                @anchors.values
+              end
+
+              def all_chains
+                @chains.values
+              end
+
+              private
+
+              def fetch_anchor(id)
+                @anchors.fetch(id) { raise ArgumentError, "anchor not found: #{id}" }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/anchor/helpers/chain.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anchor
+          module Helpers
+            class Chain
+              attr_reader :id, :anchor_id, :material, :created_at
+              attr_accessor :length, :flexibility
+
+              def initialize(anchor_id:, material: :steel, length: nil, flexibility: nil)
+                validate_material!(material)
+                @id          = SecureRandom.uuid
+                @anchor_id   = anchor_id
+                @material    = material.to_sym
+                @length      = (length || 0.5).to_f.clamp(0.0, 1.0).round(10)
+                @flexibility = (flexibility || material_flexibility).to_f.clamp(0.0, 1.0).round(10)
+                @created_at  = Time.now.utc
+              end
+
+              def extend!(amount: 0.1)
+                @length = (@length + amount.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def shorten!(amount: 0.1)
+                @length = (@length - amount.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def wear!(rate: 0.05)
+                @flexibility = (@flexibility - rate.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def broken?
+                @flexibility < Constants::BREAK_THRESHOLD
+              end
+
+              def elastic?
+                @flexibility >= 0.8
+              end
+
+              def rigid?
+                @flexibility < 0.2
+              end
+
+              def short?
+                @length < 0.3
+              end
+
+              def long?
+                @length >= 0.7
+              end
+
+              def flexibility_label
+                Constants.label_for(Constants::FLEXIBILITY_LABELS, @flexibility)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  anchor_id:         @anchor_id,
+                  material:          @material,
+                  length:            @length,
+                  flexibility:       @flexibility,
+                  flexibility_label: flexibility_label,
+                  broken:            broken?,
+                  elastic:           elastic?,
+                  created_at:        @created_at
+                }
+              end
+
+              private
+
+              def validate_material!(val)
+                return if Constants::CHAIN_MATERIALS.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown material: #{val.inspect}; " \
+                      "must be one of #{Constants::CHAIN_MATERIALS.inspect}"
+              end
+
+              def material_flexibility
+                { steel: 0.3, rope: 0.6, wire: 0.4, thread: 0.8, cobweb: 0.9 }
+                  .fetch(@material, 0.5)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anchor
+          module Helpers
+            module Constants
+              ANCHOR_TYPES = %i[belief assumption experience authority number].freeze
+
+              CHAIN_MATERIALS = %i[steel rope wire thread cobweb].freeze
+
+              MAX_ANCHORS = 200
+              MAX_CHAINS  = 100
+              DRAG_RATE   = 0.06
+              DRIFT_RATE  = 0.03
+              BREAK_THRESHOLD = 0.1
+
+              GRIP_LABELS = [
+                [(0.8..),      :ironclad],
+                [(0.6...0.8),  :firm],
+                [(0.4...0.6),  :moderate],
+                [(0.2...0.4),  :loose],
+                [(..0.2),      :drifting]
+              ].freeze
+
+              FLEXIBILITY_LABELS = [
+                [(0.8..),      :elastic],
+                [(0.6...0.8),  :flexible],
+                [(0.4...0.6),  :moderate],
+                [(0.2...0.4),  :rigid],
+                [(..0.2),      :brittle]
+              ].freeze
+
+              def self.label_for(table, value)
+                table.each { |range, label| return label if range.cover?(value) }
+                table.last.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/anchor/runners/cognitive_anchor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anchor
+          module Runners
+            module CognitiveAnchor
+              extend self
+
+              def create_anchor(anchor_type:, domain:, content:,
+                                reference_value: nil, grip: nil, weight: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                a   = eng.create_anchor(anchor_type: anchor_type, domain: domain, content: content,
+                                        reference_value: reference_value, grip: grip, weight: weight)
+                { success: true, anchor: a.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def create_chain(anchor_id:, material: :steel, length: nil,
+                               flexibility: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                c   = eng.create_chain(anchor_id: anchor_id, material: material,
+                                       length: length, flexibility: flexibility)
+                { success: true, chain: c.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def apply_bias(anchor_id:, new_value:, engine: nil, **)
+                eng    = resolve_engine(engine)
+                result = eng.apply_bias(anchor_id: anchor_id, new_value: new_value)
+                { success: true, anchor: result[:anchor].to_h,
+                  original: result[:original], biased: result[:biased], shift: result[:shift] }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_anchors(engine: nil, anchor_type: nil, **)
+                eng     = resolve_engine(engine)
+                results = eng.all_anchors
+                results = results.select { |a| a.anchor_type == anchor_type.to_sym } if anchor_type
+                { success: true, anchors: results.map(&:to_h), count: results.size }
+              end
+
+              def anchor_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.anchor_report }
+              end
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              private
+
+              def resolve_engine(engine)
+                engine || default_engine
+              end
+
+              def default_engine
+                @default_engine ||= Helpers::AnchorEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'anchor/version'
+require_relative 'anchor/helpers/constants'
+require_relative 'anchor/helpers/anchor'
+require_relative 'anchor/helpers/chain'
+require_relative 'anchor/helpers/anchor_engine'
+require_relative 'anchor/runners/cognitive_anchor'
+require_relative 'anchor/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anchor
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/anosognosia/helpers/constants'
+require 'legion/extensions/agentic/self/anosognosia/helpers/cognitive_deficit'
+require 'legion/extensions/agentic/self/anosognosia/helpers/anosognosia_engine'
+require 'legion/extensions/agentic/self/anosognosia/runners/anosognosia'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+          class Client
+            include Runners::Anosognosia
+
+            def initialize(**)
+              @engine = Helpers::AnosognosiaEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/anosognosia/helpers/anosognosia_engine.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+          module Helpers
+            class AnosognosiaEngine
+              attr_reader :deficits, :awareness_score
+
+              def initialize
+                @deficits = {} # id => CognitiveDeficit
+                @awareness_score = 1.0
+              end
+
+              def register_deficit(domain:, deficit_type:, severity:, acknowledged: false)
+                prune_if_at_capacity
+
+                deficit = CognitiveDeficit.new(
+                  domain:       domain,
+                  deficit_type: deficit_type,
+                  severity:     severity,
+                  acknowledged: acknowledged
+                )
+                @deficits[deficit.id] = deficit
+
+                Legion::Logging.info "[anosognosia] register_deficit: id=#{deficit.id} domain=#{domain} " \
+                                     "type=#{deficit_type} severity=#{deficit.severity.round(2)} acknowledged=#{acknowledged}"
+
+                deficit
+              end
+
+              def acknowledge_deficit(deficit_id:)
+                deficit = @deficits[deficit_id]
+                return { found: false, deficit_id: deficit_id } unless deficit
+
+                already = deficit.acknowledged
+                changed = deficit.acknowledge!
+
+                Legion::Logging.debug "[anosognosia] acknowledge_deficit: id=#{deficit_id} " \
+                                      "already_acknowledged=#{already} changed=#{changed}"
+
+                recalculate_awareness
+                { found: true, deficit_id: deficit_id, changed: changed, awareness_score: @awareness_score.round(10) }
+              end
+
+              def reveal_blind_spot(deficit_id:)
+                deficit = @deficits[deficit_id]
+                return { found: false, deficit_id: deficit_id } unless deficit
+                return { found: true, deficit_id: deficit_id, already_known: true } if deficit.acknowledged
+
+                deficit.acknowledge!
+                boost_awareness
+
+                Legion::Logging.info "[anosognosia] blind_spot_revealed: id=#{deficit_id} domain=#{deficit.domain} " \
+                                     "type=#{deficit.deficit_type} awareness_score=#{@awareness_score.round(2)}"
+
+                {
+                  found:           true,
+                  deficit_id:      deficit_id,
+                  already_known:   false,
+                  awareness_score: @awareness_score.round(10),
+                  awareness_label: awareness_label
+                }
+              end
+
+              def awareness_gap
+                (1.0 - @awareness_score).clamp(0.0, 1.0).round(10)
+              end
+
+              def blind_spots
+                @deficits.values.reject(&:acknowledged)
+              end
+
+              def calibration_report
+                total         = @deficits.size
+                acknowledged  = @deficits.values.count(&:acknowledged)
+                unacknowledged = total - acknowledged
+
+                {
+                  total_deficits:          total,
+                  acknowledged_deficits:   acknowledged,
+                  unacknowledged_deficits: unacknowledged,
+                  awareness_score:         @awareness_score.round(10),
+                  awareness_gap:           awareness_gap,
+                  awareness_label:         awareness_label,
+                  blind_spots:             blind_spots.map(&:to_h),
+                  deficit_breakdown:       deficit_type_breakdown
+                }
+              end
+
+              def decay_awareness(amount: Constants::AWARENESS_DECAY)
+                @awareness_score = (@awareness_score - amount).clamp(0.0, 1.0)
+                Legion::Logging.debug "[anosognosia] decay_awareness: score=#{@awareness_score.round(2)}"
+                @awareness_score
+              end
+
+              def to_h
+                {
+                  deficits:         @deficits.transform_values(&:to_h),
+                  awareness_score:  @awareness_score.round(10),
+                  awareness_gap:    awareness_gap,
+                  awareness_label:  awareness_label,
+                  total_deficits:   @deficits.size,
+                  blind_spot_count: blind_spots.size
+                }
+              end
+
+              private
+
+              def boost_awareness(amount: Constants::AWARENESS_BOOST)
+                @awareness_score = (@awareness_score + amount).clamp(0.0, 1.0)
+              end
+
+              def recalculate_awareness
+                return if @deficits.empty?
+
+                total        = @deficits.size.to_f
+                acknowledged = @deficits.values.count(&:acknowledged).to_f
+                @awareness_score = (acknowledged / total).clamp(0.0, 1.0)
+              end
+
+              def awareness_label
+                Constants::AWARENESS_LABELS.each do |range, label|
+                  return label if range.include?(@awareness_score)
+                end
+                :anosognosic
+              end
+
+              def deficit_type_breakdown
+                Constants::DEFICIT_TYPES.to_h do |type|
+                  matching = @deficits.values.select { |d| d.deficit_type == type }
+                  [type, { count: matching.size, acknowledged: matching.count(&:acknowledged) }]
+                end
+              end
+
+              def prune_if_at_capacity
+                return unless @deficits.size >= Constants::MAX_DEFICITS
+
+                oldest = @deficits.values
+                                  .reject(&:acknowledged)
+                                  .min_by(&:discovered_at)
+                oldest ||= @deficits.values.min_by(&:discovered_at)
+                @deficits.delete(oldest.id) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/anosognosia/helpers/cognitive_deficit.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+          module Helpers
+            class CognitiveDeficit
+              attr_reader :id, :domain, :deficit_type, :severity, :acknowledged,
+                          :discovered_at, :acknowledged_at
+
+              def initialize(domain:, deficit_type:, severity:, acknowledged: false)
+                validate_deficit_type!(deficit_type)
+
+                @id              = SecureRandom.uuid
+                @domain          = domain
+                @deficit_type    = deficit_type
+                @severity        = severity.clamp(0.0, 1.0)
+                @acknowledged    = acknowledged
+                @discovered_at   = Time.now.utc
+                @acknowledged_at = nil
+              end
+
+              def acknowledge!
+                return false if @acknowledged
+
+                @acknowledged    = true
+                @acknowledged_at = Time.now.utc
+                true
+              end
+
+              def severity_label
+                case @severity
+                when (0.8..1.0)  then :severe
+                when (0.6...0.8) then :high
+                when (0.4...0.6) then :moderate
+                when (0.2...0.4) then :low
+                else                  :minimal
+                end
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  domain:          @domain,
+                  deficit_type:    @deficit_type,
+                  severity:        @severity.round(10),
+                  severity_label:  severity_label,
+                  acknowledged:    @acknowledged,
+                  discovered_at:   @discovered_at,
+                  acknowledged_at: @acknowledged_at
+                }
+              end
+
+              private
+
+              def validate_deficit_type!(deficit_type)
+                return if Constants::DEFICIT_TYPES.include?(deficit_type)
+
+                raise ArgumentError, "Invalid deficit_type: #{deficit_type.inspect}. Must be one of #{Constants::DEFICIT_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+          module Helpers
+            module Constants
+              MAX_DEFICITS     = 200
+              AWARENESS_DECAY  = 0.02
+              AWARENESS_BOOST  = 0.1
+
+              AWARENESS_LABELS = {
+                (0.8..1.0)  => :calibrated,
+                (0.6...0.8) => :mostly_aware,
+                (0.4...0.6) => :partially_blind,
+                (0.2...0.4) => :largely_blind,
+                (0.0...0.2) => :anosognosic
+              }.freeze
+
+              DEFICIT_TYPES = %i[knowledge reasoning memory perception attention judgment].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end