lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/gestalt/helpers/pattern_store_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Gestalt::Helpers::PatternStore do
+  subject(:store) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts empty' do
+      expect(store.patterns).to eq([])
+      expect(store.size).to eq(0)
+    end
+  end
+
+  describe '#add' do
+    it 'adds a pattern' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      expect(pattern.name).to eq(:test)
+      expect(store.size).to eq(1)
+    end
+
+    it 'accepts domain' do
+      pattern = store.add(name: :test, elements: %i[a b c], domain: :math)
+      expect(pattern.domain).to eq(:math)
+    end
+  end
+
+  describe '#find' do
+    it 'finds by id' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      found = store.find(pattern.id)
+      expect(found).to eq(pattern)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.find('unknown')).to be_nil
+    end
+  end
+
+  describe '#find_by_name' do
+    it 'returns patterns matching name' do
+      store.add(name: :test, elements: %i[a b c])
+      store.add(name: :test, elements: %i[d e f])
+      store.add(name: :other, elements: %i[g h i])
+      expect(store.find_by_name(:test).size).to eq(2)
+    end
+  end
+
+  describe '#in_domain' do
+    it 'filters by domain' do
+      store.add(name: :a, elements: %i[a b], domain: :math)
+      store.add(name: :b, elements: %i[c d], domain: :language)
+      expect(store.in_domain(:math).size).to eq(1)
+    end
+  end
+
+  describe '#complete' do
+    before do
+      store.add(name: :alphabet, elements: %i[a b c d e])
+      store.add(name: :numbers, elements: %i[one two three four five])
+    end
+
+    it 'returns completions ranked by confidence' do
+      completions = store.complete(%i[a b c])
+      expect(completions.size).to eq(1)
+      expect(completions.first[:pattern_name]).to eq(:alphabet)
+    end
+
+    it 'returns empty for no matches' do
+      expect(store.complete(%i[x y z])).to eq([])
+    end
+
+    it 'filters by domain' do
+      store.add(name: :math_abc, elements: %i[a b c d e], domain: :math)
+      completions = store.complete(%i[a b c], domain: :math)
+      expect(completions.size).to eq(1)
+      expect(completions.first[:pattern_name]).to eq(:math_abc)
+    end
+  end
+
+  describe '#group_by_proximity' do
+    it 'groups nearby items together' do
+      groups = store.group_by_proximity([1, 2, 3, 100, 101, 102])
+      expect(groups.size).to be >= 2
+    end
+
+    it 'returns single group for single item' do
+      groups = store.group_by_proximity([5])
+      expect(groups).to eq([[5]])
+    end
+
+    it 'returns empty for empty input' do
+      groups = store.group_by_proximity([])
+      expect(groups).to eq([[]])
+    end
+  end
+
+  describe '#group_by_similarity' do
+    it 'groups items by shared key' do
+      items = [
+        { type: :animal, name: :dog },
+        { type: :animal, name: :cat },
+        { type: :vehicle, name: :car }
+      ]
+      groups = store.group_by_similarity(items, key: :type)
+      expect(groups.size).to eq(2)
+    end
+  end
+
+  describe '#reinforce / #penalize' do
+    it 'reinforces a pattern' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      initial = pattern.strength
+      store.reinforce(pattern.id)
+      expect(pattern.strength).to be > initial
+    end
+
+    it 'penalizes a pattern' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      initial = pattern.strength
+      store.penalize(pattern.id)
+      expect(pattern.strength).to be < initial
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.reinforce('unknown')).to be_nil
+      expect(store.penalize('unknown')).to be_nil
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all patterns' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      initial = pattern.strength
+      store.decay_all
+      expect(pattern.strength).to be < initial
+    end
+  end
+
+  describe '#remove' do
+    it 'removes a pattern' do
+      pattern = store.add(name: :test, elements: %i[a b c])
+      store.remove(pattern.id)
+      expect(store.size).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats' do
+      store.add(name: :test, elements: %i[a b c])
+      h = store.to_h
+      expect(h).to include(:pattern_count, :by_domain, :total_matches)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/gestalt/runners/gestalt_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Gestalt::Runners::Gestalt do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  before do
+    runner.learn_pattern(name: :alphabet, elements: %i[a b c d e], domain: :language)
+    runner.learn_pattern(name: :counting, elements: %i[one two three four five], domain: :math)
+  end
+
+  describe '#learn_pattern' do
+    it 'stores a pattern' do
+      result = runner.learn_pattern(name: :test, elements: %i[x y z])
+      expect(result[:success]).to be true
+      expect(result[:pattern][:name]).to eq(:test)
+    end
+  end
+
+  describe '#complete_pattern' do
+    it 'completes a partial pattern' do
+      result = runner.complete_pattern(fragment: %i[a b c])
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:best][:pattern_name]).to eq(:alphabet)
+      expect(result[:best][:missing]).to eq(%i[d e])
+    end
+
+    it 'returns empty for no match' do
+      result = runner.complete_pattern(fragment: %i[x y z])
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'filters by domain' do
+      result = runner.complete_pattern(fragment: %i[a b c], domain: :math)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#confirm_completion' do
+    it 'reinforces a correct completion' do
+      pattern_id = runner.store.patterns.first.id
+      result = runner.confirm_completion(pattern_id: pattern_id, correct: true)
+      expect(result[:success]).to be true
+      expect(result[:pattern][:strength]).to be > 1.0
+    end
+
+    it 'penalizes an incorrect completion' do
+      pattern_id = runner.store.patterns.first.id
+      result = runner.confirm_completion(pattern_id: pattern_id, correct: false)
+      expect(result[:success]).to be true
+      expect(result[:pattern][:strength]).to be < 1.0
+    end
+
+    it 'returns not_found for unknown pattern' do
+      result = runner.confirm_completion(pattern_id: 'unknown')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#group_items' do
+    it 'groups by proximity' do
+      result = runner.group_items(items: [1, 2, 3, 100, 101], principle: :proximity)
+      expect(result[:success]).to be true
+      expect(result[:group_count]).to be >= 2
+    end
+
+    it 'groups by similarity' do
+      items = [
+        { type: :a, v: 1 },
+        { type: :a, v: 2 },
+        { type: :b, v: 3 }
+      ]
+      result = runner.group_items(items: items, principle: :similarity)
+      expect(result[:group_count]).to eq(2)
+    end
+  end
+
+  describe '#update_gestalt' do
+    it 'decays patterns' do
+      initial = runner.store.patterns.first.strength
+      runner.update_gestalt
+      expect(runner.store.patterns.first.strength).to be < initial
+    end
+  end
+
+  describe '#patterns_in_domain' do
+    it 'returns patterns for domain' do
+      result = runner.patterns_in_domain(domain: :language)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#remove_pattern' do
+    it 'removes a pattern' do
+      pattern_id = runner.store.patterns.first.id
+      runner.remove_pattern(id: pattern_id)
+      expect(runner.store.size).to eq(1)
+    end
+  end
+
+  describe '#gestalt_stats' do
+    it 'returns stats' do
+      result = runner.gestalt_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:pattern_count, :by_domain, :total_matches)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/global_workspace/client_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::GlobalWorkspace::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::GlobalWorkspace' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Integration::GlobalWorkspace::Runners::GlobalWorkspace)
+  end
+
+  it 'supports full conscious access lifecycle' do
+    # Register subscribers (cognitive subsystems)
+    client.register_subscriber(id: :memory, name: 'lex-memory', domains: [:all])
+    client.register_subscriber(id: :emotion, name: 'lex-emotion', domains: [:safety])
+    client.register_subscriber(id: :planning, name: 'lex-planning', domains: [:cognition])
+
+    # Multiple subsystems submit content for conscious access
+    client.submit_for_broadcast(content: 'threat_nearby', source: :emotion, domain: :safety, salience: 0.85)
+    client.submit_for_broadcast(content: 'plan_step_3', source: :planning, domain: :cognition, salience: 0.5)
+    client.submit_for_broadcast(content: 'memory_trace', source: :memory, domain: :recall, salience: 0.3)
+
+    # Competition: emotion wins (highest salience, clear margin)
+    competition = client.run_competition
+    expect(competition[:success]).to be true
+    expect(competition[:broadcast][:content]).to eq('threat_nearby')
+
+    # Verify consciousness
+    conscious = client.query_consciousness(content: 'threat_nearby')
+    expect(conscious[:conscious]).to be true
+
+    # Subscribers acknowledge receipt
+    client.acknowledge_broadcast(subscriber_id: :memory)
+    client.acknowledge_broadcast(subscriber_id: :emotion)
+
+    # Check current state
+    current = client.current_broadcast
+    expect(current[:broadcast][:received_by]).to include(:memory, :emotion)
+
+    # Tick maintenance
+    client.update_global_workspace
+
+    # History preserved
+    history = client.broadcast_history(limit: 10)
+    expect(history[:total]).to eq(1)
+
+    # Stats
+    stats = client.workspace_stats
+    expect(stats[:stats][:subscribers]).to eq(3)
+  end
+end

data/spec/legion/extensions/agentic/integration/global_workspace/helpers/broadcast_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Broadcast do
+  subject(:broadcast) do
+    described_class.new(content: 'threat_detected', source: :emotion, domain: :safety, salience: 0.9,
+                        coalition: %i[fear attention])
+  end
+
+  let(:constants) { Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(broadcast.content).to eq('threat_detected')
+      expect(broadcast.source).to eq(:emotion)
+      expect(broadcast.domain).to eq(:safety)
+      expect(broadcast.salience).to eq(0.9)
+      expect(broadcast.coalition).to eq(%i[fear attention])
+    end
+
+    it 'clamps salience' do
+      high = described_class.new(content: :x, source: :s, domain: :d, salience: 1.5)
+      expect(high.salience).to eq(1.0)
+    end
+
+    it 'records broadcast_at' do
+      expect(broadcast.broadcast_at).to be_a(Time)
+    end
+
+    it 'starts with empty received_by' do
+      expect(broadcast.received_by).to be_empty
+    end
+
+    it 'limits coalition size' do
+      big = described_class.new(content: :x, source: :s, domain: :d, salience: 0.5,
+                                coalition: (1..20).to_a)
+      expect(big.coalition.size).to eq(constants::MAX_COALITION_SIZE)
+    end
+  end
+
+  describe '#acknowledge' do
+    it 'adds subscriber to received_by' do
+      broadcast.acknowledge(:memory)
+      expect(broadcast.received_by).to include(:memory)
+    end
+
+    it 'does not duplicate' do
+      broadcast.acknowledge(:memory)
+      broadcast.acknowledge(:memory)
+      expect(broadcast.received_by.size).to eq(1)
+    end
+  end
+
+  describe '#expired?' do
+    it 'returns false when fresh' do
+      expect(broadcast.expired?).to be false
+    end
+  end
+
+  describe '#age' do
+    it 'returns elapsed time' do
+      expect(broadcast.age).to be >= 0.0
+    end
+  end
+
+  describe '#label' do
+    it 'returns :dominant for high salience' do
+      expect(broadcast.label).to eq(:dominant)
+    end
+
+    it 'returns :subliminal for low salience' do
+      low = described_class.new(content: :x, source: :s, domain: :d, salience: 0.1)
+      expect(low.label).to eq(:subliminal)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = broadcast.to_h
+      expect(h).to include(:content, :source, :domain, :salience, :label, :coalition, :broadcast_at, :age,
+                           :received_by, :expired)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/global_workspace/helpers/competitor_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Competitor do
+  subject(:competitor) do
+    described_class.new(content: 'idea', source: :cortex, domain: :cognition, salience: 0.6, coalition: [:attention])
+  end
+
+  let(:constants) { Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(competitor.content).to eq('idea')
+      expect(competitor.source).to eq(:cortex)
+      expect(competitor.salience).to eq(0.6)
+      expect(competitor.urgency).to eq(0.0)
+    end
+
+    it 'clamps salience' do
+      high = described_class.new(content: :x, source: :s, domain: :d, salience: 2.0)
+      expect(high.salience).to eq(1.0)
+    end
+  end
+
+  describe '#effective_salience' do
+    it 'equals salience when no urgency' do
+      expect(competitor.effective_salience).to eq(0.6)
+    end
+
+    it 'includes urgency' do
+      competitor.urgency = 0.2
+      expect(competitor.effective_salience).to eq(0.8)
+    end
+
+    it 'clamps to 1.0' do
+      competitor.salience = 0.9
+      competitor.urgency = 0.3
+      expect(competitor.effective_salience).to eq(1.0)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces salience' do
+      before = competitor.salience
+      competitor.decay
+      expect(competitor.salience).to eq(before - constants::SALIENCE_DECAY)
+    end
+
+    it 'does not go below 0' do
+      competitor.salience = 0.01
+      competitor.decay
+      expect(competitor.salience).to eq(0.0)
+    end
+  end
+
+  describe '#boost_urgency' do
+    it 'increases urgency' do
+      competitor.boost_urgency
+      expect(competitor.urgency).to eq(constants::URGENCY_BOOST)
+    end
+
+    it 'caps at MAX_URGENCY' do
+      50.times { competitor.boost_urgency }
+      expect(competitor.urgency).to eq(constants::MAX_URGENCY)
+    end
+  end
+
+  describe '#below_threshold?' do
+    it 'returns false when above threshold' do
+      expect(competitor.below_threshold?).to be false
+    end
+
+    it 'returns true when below threshold' do
+      competitor.salience = 0.1
+      expect(competitor.below_threshold?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = competitor.to_h
+      expect(h).to include(:content, :source, :domain, :salience, :urgency, :effective_salience, :coalition)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/global_workspace/helpers/workspace_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Workspace do
+  subject(:ws) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Constants }
+
+  describe '#register_subscriber / #unregister_subscriber' do
+    it 'registers a subscriber' do
+      expect(ws.register_subscriber(id: :memory, name: 'lex-memory', domains: [:all])).to be true
+      expect(ws.subscriber_count).to eq(1)
+    end
+
+    it 'unregisters a subscriber' do
+      ws.register_subscriber(id: :memory, name: 'lex-memory')
+      expect(ws.unregister_subscriber(id: :memory)).to be true
+      expect(ws.subscriber_count).to eq(0)
+    end
+
+    it 'returns false for unknown unregister' do
+      expect(ws.unregister_subscriber(id: :unknown)).to be false
+    end
+
+    it 'limits subscribers' do
+      constants::MAX_SUBSCRIBERS.times { |i| ws.register_subscriber(id: "sub_#{i}", name: "s#{i}") }
+      expect(ws.register_subscriber(id: :overflow, name: 'over')).to be false
+    end
+  end
+
+  describe '#submit' do
+    it 'adds a competitor' do
+      comp = ws.submit(content: 'idea', source: :cortex, domain: :cognition, salience: 0.6)
+      expect(comp).to be_a(Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Competitor)
+      expect(ws.competitor_count).to eq(1)
+    end
+
+    it 'rejects below-threshold submissions' do
+      result = ws.submit(content: 'weak', source: :s, domain: :d, salience: 0.1)
+      expect(result).to be_nil
+      expect(ws.competitor_count).to eq(0)
+    end
+
+    it 'limits competitor queue' do
+      constants::MAX_COMPETITORS.times { |i| ws.submit(content: "c_#{i}", source: :s, domain: :d, salience: 0.5) }
+      ws.submit(content: :overflow, source: :s, domain: :d, salience: 0.5)
+      expect(ws.competitor_count).to eq(constants::MAX_COMPETITORS)
+    end
+  end
+
+  describe '#compete' do
+    it 'returns nil with no competitors' do
+      expect(ws.compete).to be_nil
+    end
+
+    it 'broadcasts the dominant competitor' do
+      ws.submit(content: 'strong', source: :emotion, domain: :safety, salience: 0.9)
+      ws.submit(content: 'weak', source: :cortex, domain: :cognition, salience: 0.3)
+      broadcast = ws.compete
+      expect(broadcast).to be_a(Legion::Extensions::Agentic::Integration::GlobalWorkspace::Helpers::Broadcast)
+      expect(broadcast.content).to eq('strong')
+    end
+
+    it 'returns nil when no clear winner (within margin)' do
+      ws.submit(content: 'a', source: :s, domain: :d, salience: 0.5)
+      ws.submit(content: 'b', source: :s, domain: :d, salience: 0.5)
+      result = ws.compete
+      expect(result).to be_nil
+    end
+
+    it 'boosts urgency of losers' do
+      ws.submit(content: 'a', source: :s, domain: :d, salience: 0.5)
+      ws.submit(content: 'b', source: :s, domain: :d, salience: 0.5)
+      ws.compete
+      expect(ws.competitors.first.urgency).to be > 0
+    end
+
+    it 'removes winner from competitors' do
+      ws.submit(content: 'winner', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.competitor_count).to eq(0)
+    end
+
+    it 'adds to broadcast history' do
+      ws.submit(content: 'winner', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.broadcast_history.size).to eq(1)
+    end
+  end
+
+  describe '#conscious?' do
+    it 'returns true for current broadcast content' do
+      ws.submit(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.conscious?('idea')).to be true
+    end
+
+    it 'returns false when no broadcast' do
+      expect(ws.conscious?('anything')).to be false
+    end
+
+    it 'returns false for non-matching content' do
+      ws.submit(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.conscious?('other')).to be false
+    end
+  end
+
+  describe '#current_content' do
+    it 'returns broadcast hash when active' do
+      ws.submit(content: 'idea', source: :cortex, domain: :cognition, salience: 0.9)
+      ws.compete
+      content = ws.current_content
+      expect(content[:content]).to eq('idea')
+      expect(content[:source]).to eq(:cortex)
+    end
+
+    it 'returns nil when no active broadcast' do
+      expect(ws.current_content).to be_nil
+    end
+  end
+
+  describe '#acknowledge' do
+    it 'acknowledges current broadcast' do
+      ws.submit(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.acknowledge(subscriber_id: :memory)).to be true
+    end
+
+    it 'returns false when no broadcast' do
+      expect(ws.acknowledge(subscriber_id: :memory)).to be false
+    end
+  end
+
+  describe '#state' do
+    it 'returns :idle when empty' do
+      expect(ws.state).to eq(:idle)
+    end
+
+    it 'returns :broadcasting when broadcast active' do
+      ws.submit(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      ws.compete
+      expect(ws.state).to eq(:broadcasting)
+    end
+
+    it 'returns :contention when multiple competitors' do
+      ws.submit(content: 'a', source: :s, domain: :d, salience: 0.5)
+      ws.submit(content: 'b', source: :s, domain: :d, salience: 0.5)
+      expect(ws.state).to eq(:contention)
+    end
+  end
+
+  describe '#tick' do
+    it 'decays competitors' do
+      ws.submit(content: 'idea', source: :s, domain: :d, salience: 0.5)
+      before = ws.competitors.first.salience
+      ws.tick
+      expect(ws.competitors.first&.salience || 0).to be <= before
+    end
+
+    it 'prunes weak competitors after decay' do
+      ws.submit(content: 'weak', source: :s, domain: :d, salience: constants::COMPETITION_THRESHOLD + 0.01)
+      ws.tick
+      expect(ws.competitor_count).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      h = ws.to_h
+      expect(h).to include(:state, :state_label, :subscribers, :competitors, :broadcast_history, :utilization,
+                           :competitions)
+    end
+  end
+end