lex-agentic-self 0.1.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+          module Runners
+            module Anosognosia
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_deficit(domain:, deficit_type:, severity:, acknowledged: false, **)
+                deficit = engine.register_deficit(
+                  domain:       domain,
+                  deficit_type: deficit_type,
+                  severity:     severity,
+                  acknowledged: acknowledged
+                )
+                {
+                  registered:      true,
+                  deficit_id:      deficit.id,
+                  domain:          domain,
+                  deficit_type:    deficit_type,
+                  severity:        deficit.severity,
+                  severity_label:  deficit.severity_label,
+                  acknowledged:    deficit.acknowledged,
+                  awareness_score: engine.awareness_score.round(10)
+                }
+              end
+
+              def acknowledge_deficit(deficit_id:, **)
+                Legion::Logging.debug "[anosognosia] acknowledge_deficit: id=#{deficit_id}"
+                engine.acknowledge_deficit(deficit_id: deficit_id)
+              end
+
+              def reveal_blind_spot(deficit_id:, **)
+                Legion::Logging.info "[anosognosia] reveal_blind_spot: id=#{deficit_id}"
+                engine.reveal_blind_spot(deficit_id: deficit_id)
+              end
+
+              def awareness_score(**)
+                score = engine.awareness_score
+                Legion::Logging.debug "[anosognosia] awareness_score: score=#{score.round(2)}"
+                {
+                  awareness_score: score.round(10),
+                  awareness_gap:   engine.awareness_gap,
+                  awareness_label: awareness_label_for(score)
+                }
+              end
+
+              def awareness_gap(**)
+                gap = engine.awareness_gap
+                Legion::Logging.debug "[anosognosia] awareness_gap: gap=#{gap.round(2)}"
+                { awareness_gap: gap, awareness_score: engine.awareness_score.round(10) }
+              end
+
+              def blind_spots(**)
+                spots = engine.blind_spots
+                Legion::Logging.debug "[anosognosia] blind_spots: count=#{spots.size}"
+                { blind_spots: spots.map(&:to_h), count: spots.size }
+              end
+
+              def calibration_report(**)
+                Legion::Logging.info '[anosognosia] calibration_report requested'
+                engine.calibration_report
+              end
+
+              def decay_awareness(amount: nil, **)
+                amt   = amount || Helpers::Constants::AWARENESS_DECAY
+                score = engine.decay_awareness(amount: amt)
+                { awareness_score: score.round(10), awareness_gap: engine.awareness_gap, decayed_by: amt }
+              end
+
+              def anosognosia_status(**)
+                { total_deficits: engine.deficits.size, awareness_score: engine.awareness_score.round(10),
+                  blind_spot_count: engine.blind_spots.size }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::AnosognosiaEngine.new
+              end
+
+              def awareness_label_for(score)
+                Helpers::Constants::AWARENESS_LABELS.each do |range, label|
+                  return label if range.include?(score)
+                end
+                :anosognosic
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/anosognosia/version'
+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'
+require 'legion/extensions/agentic/self/anosognosia/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Anosognosia
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          class Client
+            include Runners::CognitiveArchitecture
+
+            def initialize(**)
+              @engine = Helpers::ArchitectureEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/architecture/helpers/architecture_engine.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          module Helpers
+            class ArchitectureEngine
+              include Constants
+
+              def initialize
+                @subsystems  = {}
+                @connections = {}
+              end
+
+              def register_subsystem(name:, subsystem_type:, health: Constants::DEFAULT_HEALTH)
+                raise ArgumentError, "subsystem '#{name}' already registered" if @subsystems.key?(name.to_sym)
+                raise ArgumentError, "max subsystems (#{Constants::MAX_SUBSYSTEMS}) reached" if @subsystems.size >= Constants::MAX_SUBSYSTEMS
+
+                subsystem = Subsystem.new(name: name, subsystem_type: subsystem_type, health: health)
+                @subsystems[subsystem.name] = subsystem
+                subsystem
+              end
+
+              def create_connection(source_name:, target_name:, connection_type: :informational, weight: 0.5)
+                raise ArgumentError, "max connections (#{Constants::MAX_CONNECTIONS}) reached" if @connections.size >= Constants::MAX_CONNECTIONS
+
+                source = find_subsystem!(source_name)
+                target = find_subsystem!(target_name)
+
+                conn = Connection.new(
+                  source_id:       source.id,
+                  target_id:       target.id,
+                  connection_type: connection_type,
+                  weight:          weight
+                )
+                @connections[conn.id] = conn
+                conn
+              end
+
+              def activate_subsystem(name:)
+                subsystem = find_subsystem!(name)
+                subsystem.activate!
+
+                excitatory_connections_from(subsystem.id).each do |conn|
+                  target = subsystem_by_id(conn.target_id)
+                  target&.activate!
+                end
+
+                { name: subsystem.name, status: subsystem.status, health: subsystem.health }
+              end
+
+              def degrade_subsystem(name:)
+                subsystem = find_subsystem!(name)
+                subsystem.degrade!
+                { name: subsystem.name, status: subsystem.status, health: subsystem.health }
+              end
+
+              def recover_subsystem(name:)
+                subsystem = find_subsystem!(name)
+                subsystem.recover!
+                { name: subsystem.name, status: subsystem.status, health: subsystem.health }
+              end
+
+              def subsystem_status(name:)
+                find_subsystem!(name).to_h
+              end
+
+              def active_subsystems
+                @subsystems.values.select { |s| s.status == :active }
+              end
+
+              def bottlenecked_subsystems
+                @subsystems.values.select(&:bottlenecked?)
+              end
+
+              def connections_for(name:)
+                subsystem = find_subsystem!(name)
+                @connections.values.select do |c|
+                  c.source_id == subsystem.id || c.target_id == subsystem.id
+                end
+              end
+
+              def downstream(name:, max_depth: 5)
+                start   = find_subsystem!(name)
+                visited = bfs_visited(start.id, max_depth)
+                visited.keys.filter_map { |sid| subsystem_by_id(sid) }.reject { |s| s.id == start.id }
+              end
+
+              def architecture_health
+                return 0.0 if @subsystems.empty?
+
+                total = @subsystems.values.sum(&:health)
+                total / @subsystems.size
+              end
+
+              def architecture_graph
+                {
+                  nodes: @subsystems.values.map(&:to_h),
+                  edges: @connections.values.map(&:to_h)
+                }
+              end
+
+              def decay_all
+                @subsystems.each_value { |s| s.degrade!(Constants::HEALTH_DECAY) }
+                { decayed: @subsystems.size }
+              end
+
+              def to_h
+                {
+                  subsystem_count:     @subsystems.size,
+                  connection_count:    @connections.size,
+                  active_count:        active_subsystems.size,
+                  bottlenecked_count:  bottlenecked_subsystems.size,
+                  architecture_health: architecture_health
+                }
+              end
+
+              private
+
+              def find_subsystem!(name)
+                @subsystems.fetch(name.to_sym) do
+                  raise ArgumentError, "subsystem '#{name}' not found"
+                end
+              end
+
+              def subsystem_by_id(id)
+                @subsystems.values.find { |s| s.id == id }
+              end
+
+              def excitatory_connections_from(source_id)
+                @connections.values.select do |c|
+                  c.source_id == source_id && c.connection_type == :excitatory && c.active
+                end
+              end
+
+              def bfs_visited(start_id, max_depth)
+                visited = {}
+                queue   = [[start_id, 0]]
+
+                until queue.empty?
+                  current_id, depth = queue.shift
+                  next if visited.key?(current_id)
+
+                  visited[current_id] = depth
+                  enqueue_neighbors(current_id, depth, visited, queue) if depth < max_depth
+                end
+
+                visited
+              end
+
+              def enqueue_neighbors(current_id, depth, visited, queue)
+                @connections.each_value do |conn|
+                  next unless conn.source_id == current_id && conn.active
+                  next if visited.key?(conn.target_id)
+
+                  queue << [conn.target_id, depth + 1]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/architecture/helpers/connection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          module Helpers
+            class Connection
+              attr_reader :id, :source_id, :target_id, :connection_type, :created_at
+              attr_accessor :weight, :active
+
+              def initialize(source_id:, target_id:, connection_type: :informational, weight: 0.5)
+                @id              = SecureRandom.uuid
+                @source_id       = source_id
+                @target_id       = target_id
+                @connection_type = connection_type.to_sym
+                @weight          = weight.clamp(0.0, 1.0)
+                @active          = true
+                @created_at      = Time.now.utc
+              end
+
+              def strengthen!(amount = 0.05)
+                @weight = (@weight + amount).clamp(0.0, 1.0)
+                self
+              end
+
+              def weaken!(amount = 0.05)
+                @weight = (@weight - amount).clamp(0.0, 1.0)
+                self
+              end
+
+              def toggle!
+                @active = !@active
+                self
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  source_id:       @source_id,
+                  target_id:       @target_id,
+                  connection_type: @connection_type,
+                  weight:          @weight,
+                  active:          @active,
+                  created_at:      @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          module Helpers
+            module Constants
+              SUBSYSTEM_TYPES  = %i[perception cognition memory motivation safety communication introspection coordination].freeze
+              CONNECTION_TYPES = %i[excitatory inhibitory modulatory informational].freeze
+              STATUS_LEVELS    = %i[active idle degraded offline].freeze
+
+              HEALTH_LABELS = {
+                (0.8..)     => :excellent,
+                (0.6...0.8) => :good,
+                (0.4...0.6) => :fair,
+                (0.2...0.4) => :degraded,
+                (..0.2)     => :critical
+              }.freeze
+
+              BOTTLENECK_THRESHOLD = 0.3
+
+              MAX_SUBSYSTEMS  = 200
+              MAX_CONNECTIONS = 1000
+              MAX_HISTORY     = 500
+
+              DEFAULT_HEALTH = 0.8
+              HEALTH_DECAY   = 0.01
+              HEALTH_BOOST   = 0.05
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/architecture/helpers/subsystem.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          module Helpers
+            class Subsystem
+              include Constants
+
+              attr_reader :id, :name, :subsystem_type, :activation_count, :last_activated_at, :created_at
+              attr_accessor :health, :status, :load
+
+              def initialize(name:, subsystem_type:, health: Constants::DEFAULT_HEALTH)
+                @id               = SecureRandom.uuid
+                @name             = name.to_sym
+                @subsystem_type   = subsystem_type.to_sym
+                @health           = health.clamp(0.0, 1.0)
+                @status           = :active
+                @load             = 0.0
+                @activation_count = 0
+                @last_activated_at = nil
+                @created_at       = Time.now.utc
+              end
+
+              def activate!
+                @activation_count += 1
+                @last_activated_at = Time.now.utc
+                @health = (@health + Constants::HEALTH_BOOST).clamp(0.0, 1.0)
+                self
+              end
+
+              def degrade!(amount = Constants::HEALTH_DECAY)
+                @health = (@health - amount).clamp(0.0, 1.0)
+                @status = :degraded if @health < 0.4
+                self
+              end
+
+              def recover!(amount = Constants::HEALTH_BOOST)
+                @health = (@health + amount).clamp(0.0, 1.0)
+                @status = :active if @health >= 0.4
+                self
+              end
+
+              def bottlenecked?
+                @load > Constants::BOTTLENECK_THRESHOLD && @health < 0.5
+              end
+
+              def health_label
+                Constants::HEALTH_LABELS.each do |range, label|
+                  return label if range.cover?(@health)
+                end
+                :critical
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  name:              @name,
+                  subsystem_type:    @subsystem_type,
+                  health:            @health,
+                  health_label:      health_label,
+                  status:            @status,
+                  load:              @load,
+                  activation_count:  @activation_count,
+                  last_activated_at: @last_activated_at,
+                  created_at:        @created_at,
+                  bottlenecked:      bottlenecked?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/architecture/runners/cognitive_architecture.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+          module Runners
+            module CognitiveArchitecture
+              extend self
+
+              def register_architecture_subsystem(name:, subsystem_type:, health: Helpers::Constants::DEFAULT_HEALTH, **)
+                Legion::Logging.debug "[cognitive_architecture] registering subsystem: #{name} (#{subsystem_type})"
+                subsystem = engine.register_subsystem(name: name, subsystem_type: subsystem_type, health: health)
+                { status: :registered, subsystem: subsystem.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_architecture] register_subsystem failed: #{e.message}"
+                { status: :error, message: e.message }
+              end
+
+              def create_architecture_connection(source_name:, target_name:,
+                                                 connection_type: :informational, weight: 0.5, **)
+                Legion::Logging.debug "[cognitive_architecture] creating connection: #{source_name} -> #{target_name} (#{connection_type})"
+                conn = engine.create_connection(
+                  source_name:     source_name,
+                  target_name:     target_name,
+                  connection_type: connection_type,
+                  weight:          weight
+                )
+                { status: :created, connection: conn.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_architecture] create_connection failed: #{e.message}"
+                { status: :error, message: e.message }
+              end
+
+              def activate_architecture_subsystem(name:, **)
+                Legion::Logging.debug "[cognitive_architecture] activating subsystem: #{name}"
+                result = engine.activate_subsystem(name: name)
+                { status: :activated, name: result[:name], health: result[:health], subsystem_status: result[:status] }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_architecture] activate_subsystem failed: #{e.message}"
+                { status: :error, message: e.message }
+              end
+
+              def degrade_architecture_subsystem(name:, **)
+                Legion::Logging.debug "[cognitive_architecture] degrading subsystem: #{name}"
+                result = engine.degrade_subsystem(name: name)
+                { status: :degraded, name: result[:name], health: result[:health], subsystem_status: result[:status] }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_architecture] degrade_subsystem failed: #{e.message}"
+                { status: :error, message: e.message }
+              end
+
+              def subsystem_status_report(name:, **)
+                Legion::Logging.debug "[cognitive_architecture] status report for: #{name}"
+                engine.subsystem_status(name: name)
+              rescue ArgumentError => e
+                { status: :error, message: e.message }
+              end
+
+              def bottleneck_report(**)
+                bottlenecked = engine.bottlenecked_subsystems
+                Legion::Logging.debug "[cognitive_architecture] bottleneck_report: #{bottlenecked.size} bottlenecked"
+                {
+                  bottlenecked_count: bottlenecked.size,
+                  subsystems:         bottlenecked.map(&:to_h)
+                }
+              end
+
+              def architecture_health_report(**)
+                health = engine.architecture_health
+                Legion::Logging.debug "[cognitive_architecture] architecture_health: #{health.round(3)}"
+                {
+                  health:       health,
+                  health_label: label_for_health(health),
+                  active_count: engine.active_subsystems.size
+                }
+              end
+
+              def architecture_graph_report(**)
+                Legion::Logging.debug '[cognitive_architecture] building architecture_graph'
+                engine.architecture_graph
+              end
+
+              def downstream_subsystems(name:, max_depth: 5, **)
+                Legion::Logging.debug "[cognitive_architecture] downstream traversal from: #{name} (max_depth=#{max_depth})"
+                reachable = engine.downstream(name: name, max_depth: max_depth)
+                {
+                  source:    name,
+                  reachable: reachable.map(&:to_h),
+                  count:     reachable.size
+                }
+              rescue ArgumentError => e
+                { status: :error, message: e.message }
+              end
+
+              def update_cognitive_architecture(**)
+                Legion::Logging.debug '[cognitive_architecture] running decay cycle'
+                result = engine.decay_all
+                { status: :updated, decayed: result[:decayed] }
+              end
+
+              def cognitive_architecture_stats(**)
+                engine.to_h
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::ArchitectureEngine.new
+              end
+
+              def label_for_health(health)
+                Helpers::Constants::HEALTH_LABELS.each do |range, label|
+                  return label if range.cover?(health)
+                end
+                :critical
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/architecture/version'
+require 'legion/extensions/agentic/self/architecture/helpers/constants'
+require 'legion/extensions/agentic/self/architecture/helpers/subsystem'
+require 'legion/extensions/agentic/self/architecture/helpers/connection'
+require 'legion/extensions/agentic/self/architecture/helpers/architecture_engine'
+require 'legion/extensions/agentic/self/architecture/runners/cognitive_architecture'
+require 'legion/extensions/agentic/self/architecture/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module Architecture
+        end
+      end
+    end
+  end
+end