lex-cognitive-control 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1de8aff56a2e7595c43898c5be6dad98608ee3d6ddbcb23e100700c54d0bc83
+  data.tar.gz: ff3b7fb5e6eabf9ba94f8c0dc9c2ce0165bbffc045776651189ff6ca97ea60d6
+SHA512:
+  metadata.gz: 588b9b7b395a0a32a0daa14b02b5f92bb6f37fde9baa1330e26e01a25e5476bbf68b418e054356d18c411929c61f56e068d83303877b0c662f0ce1be2dd73e8a
+  data.tar.gz: b2bf9c9f8efc0f0572c958e072cc24301e0180030e8d0a4a2cabcc59ae502f6a97b5896d94f541c86fb68f165b4b99f3b751327a1ad542a68b4d788ed53c25ff

data/lib/legion/extensions/cognitive_control/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      class Client
+        include Runners::CognitiveControl
+
+        def initialize(controller: nil)
+          @controller = controller || Helpers::Controller.new
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/helpers/constants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      module Helpers
+        module Constants
+          MAX_GOALS = 20
+          MAX_POLICIES = 50
+          MAX_HISTORY = 200
+
+          DEFAULT_EFFORT = 0.5
+          EFFORT_FLOOR = 0.1
+          EFFORT_CEILING = 1.0
+          EFFORT_DECAY = 0.02
+          EFFORT_RECOVERY = 0.03
+
+          AUTOMATIC_THRESHOLD = 0.3
+          CONTROLLED_THRESHOLD = 0.6
+          OVERRIDE_THRESHOLD = 0.8
+
+          CONFLICT_BOOST = 0.2
+          ERROR_BOOST = 0.15
+          NOVELTY_BOOST = 0.1
+          ADAPTATION_ALPHA = 0.1
+
+          CONTROL_MODES = %i[automatic controlled override].freeze
+          GOAL_STATES = %i[active suspended completed abandoned].freeze
+
+          EFFORT_LABELS = {
+            (0.8..)     => :maximal,
+            (0.6...0.8) => :effortful,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :low,
+            (..0.2)     => :automatic
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/helpers/control_signal.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      module Helpers
+        class ControlSignal
+          include Constants
+
+          attr_reader :effort_level, :conflict_detected, :error_detected,
+                      :novelty_detected
+
+          def initialize
+            @effort_level = DEFAULT_EFFORT
+            @conflict_detected = false
+            @error_detected = false
+            @novelty_detected = false
+          end
+
+          def detect_conflict
+            @conflict_detected = true
+            @effort_level = [@effort_level + CONFLICT_BOOST, EFFORT_CEILING].min
+          end
+
+          def detect_error
+            @error_detected = true
+            @effort_level = [@effort_level + ERROR_BOOST, EFFORT_CEILING].min
+          end
+
+          def detect_novelty
+            @novelty_detected = true
+            @effort_level = [@effort_level + NOVELTY_BOOST, EFFORT_CEILING].min
+          end
+
+          def reset_detections
+            @conflict_detected = false
+            @error_detected = false
+            @novelty_detected = false
+          end
+
+          def mode
+            return :override if @effort_level >= OVERRIDE_THRESHOLD
+            return :controlled if @effort_level >= CONTROLLED_THRESHOLD
+
+            :automatic
+          end
+
+          def effort_label
+            EFFORT_LABELS.each { |range, lbl| return lbl if range.cover?(@effort_level) }
+            :automatic
+          end
+
+          def decay
+            @effort_level = [@effort_level - EFFORT_DECAY, EFFORT_FLOOR].max
+          end
+
+          def recover(amount: EFFORT_RECOVERY)
+            @effort_level = [@effort_level + amount, EFFORT_CEILING].min
+          end
+
+          def to_h
+            {
+              effort_level:      @effort_level.round(4),
+              mode:              mode,
+              effort_label:      effort_label,
+              conflict_detected: @conflict_detected,
+              error_detected:    @error_detected,
+              novelty_detected:  @novelty_detected
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/helpers/controller.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      module Helpers
+        class Controller
+          include Constants
+
+          attr_reader :goals, :signal, :history
+
+          def initialize
+            @goals    = {}
+            @counter  = 0
+            @signal   = ControlSignal.new
+            @history  = []
+          end
+
+          def set_goal(description:, domain: :general, priority: 0.5)
+            return nil if @goals.size >= MAX_GOALS
+
+            @counter += 1
+            goal_id = :"goal_#{@counter}"
+            goal = Goal.new(id: goal_id, description: description, domain: domain, priority: priority)
+            @goals[goal_id] = goal
+            goal
+          end
+
+          def advance_goal(goal_id:, amount: 0.1)
+            goal = @goals[goal_id]
+            return nil unless goal
+
+            goal.advance(amount: amount)
+          end
+
+          def suspend_goal(goal_id:)
+            goal = @goals[goal_id]
+            return nil unless goal
+
+            goal.suspend!
+          end
+
+          def resume_goal(goal_id:)
+            goal = @goals[goal_id]
+            return nil unless goal
+
+            goal.resume!
+          end
+
+          def abandon_goal(goal_id:)
+            goal = @goals[goal_id]
+            return nil unless goal
+
+            goal.abandon!
+          end
+
+          def evaluate_control_demand(conflict: false, error: false, novelty: false)
+            @signal.reset_detections
+            @signal.detect_conflict if conflict
+            @signal.detect_error if error
+            @signal.detect_novelty if novelty
+            record_evaluation
+            @signal.to_h
+          end
+
+          def current_mode
+            @signal.mode
+          end
+
+          def should_override?
+            @signal.mode == :override
+          end
+
+          def should_control?
+            %i[controlled override].include?(@signal.mode)
+          end
+
+          def active_goals
+            @goals.values.select(&:active?).sort_by { |g| -g.priority }.map(&:to_h)
+          end
+
+          def top_goal
+            active = @goals.values.select(&:active?)
+            return nil if active.empty?
+
+            active.max_by(&:priority).to_h
+          end
+
+          def goal_conflict?
+            active = @goals.values.select(&:active?)
+            return false if active.size < 2
+
+            priorities = active.map(&:priority)
+            (priorities.max - priorities.min) < 0.2 && active.size > 1
+          end
+
+          def tick
+            @signal.decay
+            check_goal_conflicts
+            @signal.to_h
+          end
+
+          def to_h
+            {
+              goal_count:    @goals.size,
+              active_goals:  @goals.values.count(&:active?),
+              effort_level:  @signal.effort_level.round(4),
+              mode:          current_mode,
+              effort_label:  @signal.effort_label,
+              goal_conflict: goal_conflict?,
+              history_size:  @history.size
+            }
+          end
+
+          private
+
+          def check_goal_conflicts
+            @signal.detect_conflict if goal_conflict?
+          end
+
+          def record_evaluation
+            @history << {
+              mode:     @signal.mode,
+              effort:   @signal.effort_level.round(4),
+              conflict: @signal.conflict_detected,
+              error:    @signal.error_detected,
+              novelty:  @signal.novelty_detected,
+              at:       Time.now.utc
+            }
+            @history.shift while @history.size > MAX_HISTORY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/helpers/goal.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      module Helpers
+        class Goal
+          include Constants
+
+          attr_reader :id, :description, :domain, :priority, :state, :progress, :created_at
+
+          def initialize(id:, description:, domain: :general, priority: 0.5)
+            @id          = id
+            @description = description
+            @domain      = domain
+            @priority    = priority.to_f.clamp(0.0, 1.0)
+            @state       = :active
+            @progress    = 0.0
+            @created_at  = Time.now.utc
+          end
+
+          def advance(amount: 0.1)
+            return nil unless @state == :active
+
+            @progress = [@progress + amount, 1.0].min
+            complete! if @progress >= 1.0
+            @progress
+          end
+
+          def complete!
+            @state = :completed
+          end
+
+          def suspend!
+            @state = :suspended if @state == :active
+          end
+
+          def resume!
+            @state = :active if @state == :suspended
+          end
+
+          def abandon!
+            @state = :abandoned unless @state == :completed
+          end
+
+          def active?
+            @state == :active
+          end
+
+          def completed?
+            @state == :completed
+          end
+
+          def to_h
+            {
+              id:          @id,
+              description: @description,
+              domain:      @domain,
+              priority:    @priority.round(4),
+              state:       @state,
+              progress:    @progress.round(4)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/runners/cognitive_control.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      module Runners
+        module CognitiveControl
+          include Helpers::Constants
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def set_control_goal(description:, domain: :general, priority: 0.5, **)
+            goal = controller.set_goal(description: description, domain: domain, priority: priority)
+            return { success: false, reason: :limit_reached } unless goal
+
+            { success: true, goal_id: goal.id, priority: goal.priority }
+          end
+
+          def advance_control_goal(goal_id:, amount: 0.1, **)
+            result = controller.advance_goal(goal_id: goal_id, amount: amount)
+            return { success: false, reason: :not_found } unless result
+
+            { success: true, goal_id: goal_id, progress: result.round(4) }
+          end
+
+          def suspend_control_goal(goal_id:, **)
+            controller.suspend_goal(goal_id: goal_id)
+            { success: true, goal_id: goal_id }
+          end
+
+          def evaluate_control(conflict: false, error: false, novelty: false, **)
+            result = controller.evaluate_control_demand(conflict: conflict, error: error, novelty: novelty)
+            { success: true }.merge(result)
+          end
+
+          def current_control_mode(**)
+            { success: true, mode: controller.current_mode, should_override: controller.should_override?,
+              should_control: controller.should_control? }
+          end
+
+          def active_control_goals(**)
+            goals = controller.active_goals
+            { success: true, goals: goals, count: goals.size }
+          end
+
+          def top_control_goal(**)
+            goal = controller.top_goal
+            return { success: false, reason: :no_active_goals } unless goal
+
+            { success: true }.merge(goal)
+          end
+
+          def update_cognitive_control(**)
+            result = controller.tick
+            { success: true }.merge(result)
+          end
+
+          def cognitive_control_stats(**)
+            { success: true }.merge(controller.to_h)
+          end
+
+          private
+
+          def controller
+            @controller ||= Helpers::Controller.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_control/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveControl
+      VERSION = '0.1.0'
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-control
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Cognitive control for LegionIO — automatic vs. controlled processing,
+  goal management, and effort allocation
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/cognitive_control/client.rb
+- lib/legion/extensions/cognitive_control/helpers/constants.rb
+- lib/legion/extensions/cognitive_control/helpers/control_signal.rb
+- lib/legion/extensions/cognitive_control/helpers/controller.rb
+- lib/legion/extensions/cognitive_control/helpers/goal.rb
+- lib/legion/extensions/cognitive_control/runners/cognitive_control.rb
+- lib/legion/extensions/cognitive_control/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-control
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-control
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-control
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-control/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-control/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-control/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Cognitive control meta-controller for LegionIO
+test_files: []