lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/global_workspace/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/global_workspace/helpers/constants'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/broadcast'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/competitor'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/workspace'
+require 'legion/extensions/agentic/integration/global_workspace/runners/global_workspace'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          class Client
+            include Runners::GlobalWorkspace
+
+            def initialize(workspace: nil, **)
+              @workspace = workspace || Helpers::Workspace.new
+            end
+
+            private
+
+            attr_reader :workspace
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/helpers/broadcast.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Helpers
+            class Broadcast
+              include Constants
+
+              attr_reader :content, :source, :domain, :salience, :coalition,
+                          :broadcast_at, :received_by
+
+              def initialize(content:, source:, domain:, salience:, coalition: [])
+                @content      = content
+                @source       = source
+                @domain       = domain
+                @salience     = salience.to_f.clamp(0.0, 1.0)
+                @coalition    = Array(coalition).first(MAX_COALITION_SIZE)
+                @broadcast_at = Time.now.utc
+                @received_by  = []
+              end
+
+              def acknowledge(subscriber_id)
+                @received_by << subscriber_id unless @received_by.include?(subscriber_id)
+              end
+
+              def expired?
+                (Time.now.utc - @broadcast_at) > BROADCAST_TTL
+              end
+
+              def age
+                Time.now.utc - @broadcast_at
+              end
+
+              def label
+                SALIENCE_LABELS.each { |range, lbl| return lbl if range.cover?(@salience) }
+                :subliminal
+              end
+
+              def to_h
+                {
+                  content:      @content,
+                  source:       @source,
+                  domain:       @domain,
+                  salience:     @salience.round(4),
+                  label:        label,
+                  coalition:    @coalition,
+                  broadcast_at: @broadcast_at,
+                  age:          age.round(2),
+                  received_by:  @received_by.dup,
+                  expired:      expired?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/helpers/competitor.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Helpers
+            class Competitor
+              include Constants
+
+              attr_reader :content, :source, :domain, :coalition, :submitted_at
+              attr_accessor :salience, :urgency
+
+              def initialize(content:, source:, domain:, salience:, coalition: [])
+                @content      = content
+                @source       = source
+                @domain       = domain
+                @salience     = salience.to_f.clamp(0.0, 1.0)
+                @coalition    = Array(coalition).first(MAX_COALITION_SIZE)
+                @urgency      = 0.0
+                @submitted_at = Time.now.utc
+              end
+
+              def effective_salience
+                (@salience + @urgency).clamp(0.0, 1.0)
+              end
+
+              def decay
+                @salience = [@salience - SALIENCE_DECAY, 0.0].max
+              end
+
+              def boost_urgency
+                @urgency = [@urgency + URGENCY_BOOST, MAX_URGENCY].min
+              end
+
+              def below_threshold?
+                effective_salience < COMPETITION_THRESHOLD
+              end
+
+              def to_h
+                {
+                  content:            @content,
+                  source:             @source,
+                  domain:             @domain,
+                  salience:           @salience.round(4),
+                  urgency:            @urgency.round(4),
+                  effective_salience: effective_salience.round(4),
+                  coalition:          @coalition,
+                  submitted_at:       @submitted_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/helpers/constants.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Helpers
+            module Constants
+              # Maximum items that can compete for the workspace in one cycle
+              MAX_COMPETITORS = 50
+
+              # Maximum broadcasts retained in history
+              MAX_BROADCAST_HISTORY = 200
+
+              # Maximum number of coalition members per broadcast
+              MAX_COALITION_SIZE = 10
+
+              # Minimum salience to enter competition
+              COMPETITION_THRESHOLD = 0.2
+
+              # Winner takes all — top competitor must exceed runner-up by this margin
+              DOMINANCE_MARGIN = 0.05
+
+              # How long a broadcast remains "conscious" (seconds)
+              BROADCAST_TTL = 10
+
+              # Salience decay per tick for waiting competitors
+              SALIENCE_DECAY = 0.02
+
+              # Urgency boost per tick for items that keep losing competition
+              URGENCY_BOOST = 0.01
+
+              # Maximum urgency accumulation
+              MAX_URGENCY = 0.5
+
+              # EMA alpha for workspace utilization tracking
+              UTILIZATION_ALPHA = 0.1
+
+              # Maximum registered subscribers
+              MAX_SUBSCRIBERS = 50
+
+              # Labels for workspace state
+              WORKSPACE_STATE_LABELS = {
+                broadcasting: 'actively broadcasting content',
+                idle:         'workspace empty, awaiting input',
+                contention:   'multiple items competing for access',
+                saturated:    'high utilization, processing backlog'
+              }.freeze
+
+              # Labels for broadcast salience
+              SALIENCE_LABELS = {
+                (0.8..)     => :dominant,
+                (0.6...0.8) => :salient,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :marginal,
+                (..0.2)     => :subliminal
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/helpers/workspace.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Helpers
+            class Workspace
+              include Constants
+
+              attr_reader :competitors, :broadcast_history, :subscribers, :current_broadcast, :utilization
+
+              def initialize
+                @competitors       = []
+                @broadcast_history = []
+                @subscribers       = {}   # id => { name:, domains: [] }
+                @current_broadcast = nil
+                @utilization       = 0.0  # EMA of workspace usage
+                @competition_count = 0
+              end
+
+              # --- Subscriber Management ---
+
+              def register_subscriber(id:, name:, domains: [])
+                return false if @subscribers.size >= MAX_SUBSCRIBERS && !@subscribers.key?(id)
+
+                @subscribers[id] = { name: name, domains: Array(domains), registered_at: Time.now.utc }
+                true
+              end
+
+              def unregister_subscriber(id:)
+                !@subscribers.delete(id).nil?
+              end
+
+              # --- Competition ---
+
+              def submit(content:, source:, domain:, salience:, coalition: [])
+                return nil if salience.to_f < COMPETITION_THRESHOLD
+
+                @competitors.shift while @competitors.size >= MAX_COMPETITORS
+                competitor = Competitor.new(
+                  content:   content,
+                  source:    source,
+                  domain:    domain,
+                  salience:  salience,
+                  coalition: coalition
+                )
+                @competitors << competitor
+                competitor
+              end
+
+              def compete
+                @competition_count += 1
+                expire_current_broadcast
+                prune_weak_competitors
+
+                return nil if @competitors.empty?
+
+                sorted = @competitors.sort_by { |c| -c.effective_salience }
+                winner = sorted.first
+
+                if sorted.size > 1
+                  runner_up = sorted[1]
+                  unless (winner.effective_salience - runner_up.effective_salience) >= DOMINANCE_MARGIN
+                    boost_losers
+                    update_utilization(busy: true)
+                    return nil
+                  end
+                end
+
+                @competitors.delete(winner)
+                broadcast = create_broadcast(winner)
+                @current_broadcast = broadcast
+
+                boost_losers
+                update_utilization(busy: true)
+
+                broadcast
+              end
+
+              # --- Query ---
+
+              def conscious?(content)
+                return false unless @current_broadcast && !@current_broadcast.expired?
+
+                @current_broadcast.content == content
+              end
+
+              def current_content
+                return nil unless @current_broadcast && !@current_broadcast.expired?
+
+                @current_broadcast.to_h
+              end
+
+              def acknowledge(subscriber_id:)
+                return false unless @current_broadcast && !@current_broadcast.expired?
+
+                @current_broadcast.acknowledge(subscriber_id)
+                true
+              end
+
+              # --- Workspace State ---
+
+              def state
+                if @current_broadcast && !@current_broadcast.expired?
+                  :broadcasting
+                elsif @competitors.size > 1
+                  :contention
+                elsif @utilization > 0.7
+                  :saturated
+                else
+                  :idle
+                end
+              end
+
+              def subscriber_count
+                @subscribers.size
+              end
+
+              def competitor_count
+                @competitors.size
+              end
+
+              # --- Tick / Maintenance ---
+
+              def tick
+                expire_current_broadcast
+                decay_competitors
+                prune_weak_competitors
+                update_utilization(busy: !@competitors.empty? || (@current_broadcast && !@current_broadcast.expired?))
+              end
+
+              def to_h
+                {
+                  state:             state,
+                  state_label:       WORKSPACE_STATE_LABELS[state],
+                  subscribers:       @subscribers.size,
+                  competitors:       @competitors.size,
+                  broadcast_history: @broadcast_history.size,
+                  utilization:       @utilization.round(4),
+                  competitions:      @competition_count,
+                  current_broadcast: @current_broadcast&.expired? == false ? @current_broadcast.to_h : nil
+                }
+              end
+
+              private
+
+              def create_broadcast(winner)
+                broadcast = Broadcast.new(
+                  content:   winner.content,
+                  source:    winner.source,
+                  domain:    winner.domain,
+                  salience:  winner.effective_salience,
+                  coalition: winner.coalition
+                )
+                @broadcast_history << broadcast
+                @broadcast_history.shift while @broadcast_history.size > MAX_BROADCAST_HISTORY
+                broadcast
+              end
+
+              def expire_current_broadcast
+                @current_broadcast = nil if @current_broadcast&.expired?
+              end
+
+              def prune_weak_competitors
+                @competitors.reject!(&:below_threshold?)
+              end
+
+              def decay_competitors
+                @competitors.each(&:decay)
+              end
+
+              def boost_losers
+                @competitors.each(&:boost_urgency)
+              end
+
+              def update_utilization(busy:)
+                sample = busy ? 1.0 : 0.0
+                @utilization += (UTILIZATION_ALPHA * (sample - @utilization))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/runners/global_workspace.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Runners
+            module GlobalWorkspace
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def submit_for_broadcast(content:, source:, domain:, salience:, coalition: [], **)
+                Legion::Logging.debug "[global_workspace] submit: source=#{source} domain=#{domain} salience=#{salience}"
+                competitor = workspace.submit(
+                  content:   content,
+                  source:    source,
+                  domain:    domain,
+                  salience:  salience,
+                  coalition: coalition
+                )
+                if competitor
+                  { success: true, effective_salience: competitor.effective_salience.round(4),
+                    competitors: workspace.competitor_count }
+                else
+                  { success: false, reason: :below_threshold, competitors: workspace.competitor_count }
+                end
+              end
+
+              def run_competition(**)
+                Legion::Logging.debug '[global_workspace] run_competition'
+                broadcast = workspace.compete
+                if broadcast
+                  {
+                    success:   true,
+                    broadcast: broadcast.to_h,
+                    state:     workspace.state,
+                    remaining: workspace.competitor_count
+                  }
+                else
+                  { success: false, reason: :no_winner, state: workspace.state, competitors: workspace.competitor_count }
+                end
+              end
+
+              def register_subscriber(id:, name:, domains: [], **)
+                Legion::Logging.debug "[global_workspace] register_subscriber: id=#{id} name=#{name}"
+                registered = workspace.register_subscriber(id: id, name: name, domains: domains)
+                { success: registered, subscriber_count: workspace.subscriber_count }
+              end
+
+              def unregister_subscriber(id:, **)
+                Legion::Logging.debug "[global_workspace] unregister_subscriber: id=#{id}"
+                removed = workspace.unregister_subscriber(id: id)
+                { success: removed, subscriber_count: workspace.subscriber_count }
+              end
+
+              def acknowledge_broadcast(subscriber_id:, **)
+                Legion::Logging.debug "[global_workspace] acknowledge: subscriber=#{subscriber_id}"
+                ack = workspace.acknowledge(subscriber_id: subscriber_id)
+                { success: ack }
+              end
+
+              def query_consciousness(content:, **)
+                is_conscious = workspace.conscious?(content)
+                Legion::Logging.debug "[global_workspace] conscious?(#{content}): #{is_conscious}"
+                { success: true, conscious: is_conscious }
+              end
+
+              def current_broadcast(**)
+                content = workspace.current_content
+                Legion::Logging.debug "[global_workspace] current_broadcast: #{content ? 'active' : 'none'}"
+                { success: true, broadcast: content }
+              end
+
+              def broadcast_history(limit: 10, **)
+                history = workspace.broadcast_history.last(limit.to_i).map(&:to_h)
+                Legion::Logging.debug "[global_workspace] history: #{history.size} entries"
+                { success: true, history: history, total: workspace.broadcast_history.size }
+              end
+
+              def update_global_workspace(**)
+                Legion::Logging.debug '[global_workspace] tick'
+                workspace.tick
+                { success: true, state: workspace.state, competitors: workspace.competitor_count,
+                  utilization: workspace.utilization.round(4) }
+              end
+
+              def workspace_stats(**)
+                Legion::Logging.debug '[global_workspace] stats'
+                { success: true, stats: workspace.to_h }
+              end
+
+              private
+
+              def workspace
+                @workspace ||= Helpers::Workspace.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/version.rb

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

data/lib/legion/extensions/agentic/integration/global_workspace.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/global_workspace/version'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/constants'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/broadcast'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/competitor'
+require 'legion/extensions/agentic/integration/global_workspace/helpers/workspace'
+require 'legion/extensions/agentic/integration/global_workspace/runners/global_workspace'
+require 'legion/extensions/agentic/integration/global_workspace/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/integration/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          class Client
+            include Runners::CognitiveIntegration
+
+            def initialize(engine: nil)
+              @default_engine = engine || Helpers::IntegrationEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/integration/helpers/constants.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          module Helpers
+            module Constants
+              MAX_SIGNALS = 500
+              MAX_REPRESENTATIONS = 200
+              MIN_SIGNALS_FOR_BINDING = 2
+
+              # Modality types
+              MODALITIES = %i[
+                visual auditory semantic emotional motor
+                proprioceptive temporal spatial contextual
+              ].freeze
+
+              # Binding dynamics
+              DEFAULT_BINDING_STRENGTH = 0.5
+              BINDING_DECAY_RATE = 0.03
+              REINFORCEMENT_RATE = 0.08
+              CONFLICT_PENALTY = 0.15
+
+              # Thresholds
+              COHERENT_THRESHOLD = 0.6
+              FRAGMENTED_THRESHOLD = 0.3
+
+              # Binding strength labels
+              BINDING_LABELS = {
+                (0.8..)     => :tightly_bound,
+                (0.6...0.8) => :bound,
+                (0.4...0.6) => :loosely_bound,
+                (0.2...0.4) => :fragmentary,
+                (..0.2)     => :unbound
+              }.freeze
+
+              # Signal confidence labels
+              CONFIDENCE_LABELS = {
+                (0.8..)     => :certain,
+                (0.6...0.8) => :confident,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :low,
+                (..0.2)     => :uncertain
+              }.freeze
+
+              # Integration quality labels
+              QUALITY_LABELS = {
+                (0.8..)     => :excellent,
+                (0.6...0.8) => :good,
+                (0.4...0.6) => :adequate,
+                (0.2...0.4) => :poor,
+                (..0.2)     => :failed
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end