lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/zeitgeist/runners/cognitive_zeitgeist.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Runners
+            module CognitiveZeitgeist
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def ingest_signal(source_subsystem:, domain:, intensity: Helpers::Constants::DEFAULT_INTENSITY,
+                                valence: 0.0, engine: nil, **)
+                eng     = engine || default_engine
+                signal  = eng.ingest(
+                  source_subsystem: source_subsystem,
+                  domain:           domain,
+                  intensity:        intensity,
+                  valence:          valence
+                )
+                Legion::Logging.debug "[cognitive_zeitgeist] ingest source=#{source_subsystem} " \
+                                      "domain=#{domain} intensity=#{intensity.round(2)} valence=#{valence.round(2)}"
+                { success: true, signal: signal.to_h }
+              end
+
+              def zeitgeist_report(engine: nil, **)
+                eng    = engine || default_engine
+                report = eng.zeitgeist_report
+                Legion::Logging.debug "[cognitive_zeitgeist] report signals=#{report[:signal_count]} " \
+                                      "mood=#{report[:mood_label]} convergence=#{report[:convergence_label]} " \
+                                      "momentum=#{report[:momentum_label]}"
+                { success: true }.merge(report)
+              end
+
+              def collective_mood(engine: nil, **)
+                eng   = engine || default_engine
+                mood  = eng.collective_mood
+                label = Helpers::Constants.label_for(Helpers::Constants::MOOD_LABELS, normalize_mood(mood))
+                Legion::Logging.debug "[cognitive_zeitgeist] mood value=#{mood.round(2)} label=#{label}"
+                { success: true, mood: mood, mood_label: label }
+              end
+
+              def cognitive_convergence(engine: nil, **)
+                eng   = engine || default_engine
+                conv  = eng.cognitive_convergence
+                label = Helpers::Constants.label_for(Helpers::Constants::CONVERGENCE_LABELS, conv)
+                alert = eng.divergence_alert?
+                Legion::Logging.debug "[cognitive_zeitgeist] convergence value=#{conv.round(2)} label=#{label} " \
+                                      "alert=#{alert}"
+                { success: true, convergence: conv, convergence_label: label, divergence_alert: alert }
+              end
+
+              def dominant_themes(limit: 5, engine: nil, **)
+                eng    = engine || default_engine
+                themes = eng.dominant_themes(limit: limit)
+                Legion::Logging.debug "[cognitive_zeitgeist] dominant_themes count=#{themes.size}"
+                { success: true, themes: themes, count: themes.size }
+              end
+
+              def rising_domains(engine: nil, **)
+                eng     = engine || default_engine
+                domains = eng.rising_domains
+                Legion::Logging.debug "[cognitive_zeitgeist] rising count=#{domains.size}"
+                { success: true, domains: domains, count: domains.size }
+              end
+
+              def falling_domains(engine: nil, **)
+                eng     = engine || default_engine
+                domains = eng.falling_domains
+                Legion::Logging.debug "[cognitive_zeitgeist] falling count=#{domains.size}"
+                { success: true, domains: domains, count: domains.size }
+              end
+
+              def trend_window_status(engine: nil, **)
+                eng    = engine || default_engine
+                window = eng.trend_window.to_h
+                mom_label = Helpers::Constants.label_for(Helpers::Constants::MOMENTUM_LABELS, window[:momentum])
+                Legion::Logging.debug "[cognitive_zeitgeist] trend_window size=#{window[:size]} " \
+                                      "momentum=#{mom_label}"
+                { success: true, trend_window: window, momentum_label: mom_label }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::ZeitgeistEngine.new
+              end
+
+              def normalize_mood(mood_value)
+                ((mood_value + 1.0) / 2.0).clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'zeitgeist/version'
+require_relative 'zeitgeist/helpers/constants'
+require_relative 'zeitgeist/helpers/cognitive_signal'
+require_relative 'zeitgeist/helpers/trend_window'
+require_relative 'zeitgeist/helpers/zeitgeist_engine'
+require_relative 'zeitgeist/runners/cognitive_zeitgeist'
+require_relative 'zeitgeist/helpers/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'integration/version'
+require_relative 'integration/integration'
+require_relative 'integration/synthesis'
+require_relative 'integration/tapestry'
+require_relative 'integration/mosaic'
+require_relative 'integration/tessellation'
+require_relative 'integration/mycelium'
+require_relative 'integration/zeitgeist'
+require_relative 'integration/map'
+require_relative 'integration/labyrinth'
+require_relative 'integration/global_workspace'
+require_relative 'integration/phenomenal_binding'
+require_relative 'integration/gestalt'
+require_relative 'integration/distributed_cognition'
+require_relative 'integration/qualia'
+require_relative 'integration/context'
+require_relative 'integration/situation_model'
+require_relative 'integration/boundary'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+        def remote_invocable?
+          false
+        end
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/boundary/helpers/boundary_engine_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Boundary::Helpers::BoundaryEngine do
+  subject(:engine) { described_class.new }
+
+  let(:boundary) { engine.create_boundary(name: 'test') }
+
+  describe '#create_boundary' do
+    it 'returns a Boundary' do
+      expect(boundary).to be_a(Legion::Extensions::Agentic::Integration::Boundary::Helpers::Boundary)
+    end
+
+    it 'stores the boundary internally' do
+      boundary
+      expect(engine.to_h[:total_boundaries]).to eq(1)
+    end
+
+    it 'accepts type and permeability' do
+      b = engine.create_boundary(name: 'custom', boundary_type: :emotional, permeability: 0.8)
+      expect(b.boundary_type).to eq(:emotional)
+      expect(b.permeability).to eq(0.8)
+    end
+  end
+
+  describe '#open_boundary' do
+    it 'increases boundary permeability' do
+      original = boundary.permeability
+      engine.open_boundary(boundary_id: boundary.id)
+      expect(boundary.permeability).to be > original
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.open_boundary(boundary_id: 'fake')).to be_nil
+    end
+  end
+
+  describe '#close_boundary' do
+    it 'decreases boundary permeability' do
+      original = boundary.permeability
+      engine.close_boundary(boundary_id: boundary.id)
+      expect(boundary.permeability).to be < original
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.close_boundary(boundary_id: 'fake')).to be_nil
+    end
+  end
+
+  describe '#violate_boundary' do
+    it 'increments violations' do
+      engine.violate_boundary(boundary_id: boundary.id)
+      expect(boundary.violations).to eq(1)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.violate_boundary(boundary_id: 'fake')).to be_nil
+    end
+  end
+
+  describe '#repair_boundary' do
+    it 'decrements violations' do
+      2.times { engine.violate_boundary(boundary_id: boundary.id) }
+      engine.repair_boundary(boundary_id: boundary.id)
+      expect(boundary.violations).to eq(1)
+    end
+  end
+
+  describe '#seal_boundary' do
+    it 'sets permeability to 0' do
+      engine.seal_boundary(boundary_id: boundary.id)
+      expect(boundary.permeability).to eq(0.0)
+    end
+  end
+
+  describe '#breached_boundaries' do
+    it 'returns only breached boundaries' do
+      b = engine.create_boundary(name: 'fragile', permeability: 0.9)
+      expect(engine.breached_boundaries).to include(b)
+      expect(engine.breached_boundaries).not_to include(boundary)
+    end
+  end
+
+  describe '#boundaries_by_type' do
+    it 'filters by type' do
+      engine.create_boundary(name: 'emo', boundary_type: :emotional)
+      result = engine.boundaries_by_type(boundary_type: :emotional)
+      expect(result.size).to eq(1)
+      expect(result.first.boundary_type).to eq(:emotional)
+    end
+  end
+
+  describe '#most_violated' do
+    it 'sorts by violations descending' do
+      b1 = engine.create_boundary(name: 'b1')
+      b2 = engine.create_boundary(name: 'b2')
+      3.times { engine.violate_boundary(boundary_id: b1.id) }
+      engine.violate_boundary(boundary_id: b2.id)
+      most = engine.most_violated(limit: 2)
+      expect(most.first.id).to eq(b1.id)
+    end
+  end
+
+  describe '#overall_integrity' do
+    it 'returns 1.0 with no boundaries' do
+      fresh = described_class.new
+      expect(fresh.overall_integrity).to eq(1.0)
+    end
+
+    it 'averages across all boundaries' do
+      b1 = engine.create_boundary(name: 'a')
+      10.times { engine.violate_boundary(boundary_id: b1.id) }
+      engine.create_boundary(name: 'b')
+      expect(engine.overall_integrity).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#overall_permeability' do
+    it 'returns 0.5 with no boundaries' do
+      fresh = described_class.new
+      expect(fresh.overall_permeability).to eq(0.5)
+    end
+
+    it 'averages permeability across boundaries' do
+      engine.create_boundary(name: 'a', permeability: 0.2)
+      engine.create_boundary(name: 'b', permeability: 0.8)
+      expect(engine.overall_permeability).to eq(0.5)
+    end
+  end
+
+  describe '#boundary_report' do
+    it 'includes all report fields' do
+      boundary
+      report = engine.boundary_report
+      expect(report).to include(
+        :total_boundaries, :breached_count, :overall_integrity,
+        :overall_permeability, :most_violated
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_boundaries, :breached_count,
+        :overall_integrity, :overall_permeability
+      )
+    end
+  end
+
+  describe 'pruning' do
+    it 'prunes least violated when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Integration::Boundary::Helpers::Constants::MAX_BOUNDARIES', 3)
+      eng = described_class.new
+      eng.create_boundary(name: 'b1')
+      b2 = eng.create_boundary(name: 'b2')
+      eng.violate_boundary(boundary_id: b2.id)
+      b3 = eng.create_boundary(name: 'b3')
+      eng.violate_boundary(boundary_id: b3.id)
+      eng.violate_boundary(boundary_id: b3.id)
+      eng.create_boundary(name: 'b4')
+      expect(eng.to_h[:total_boundaries]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/boundary/helpers/boundary_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Boundary::Helpers::Boundary do
+  subject(:boundary) { described_class.new(name: 'test_boundary') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(boundary.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets name' do
+      expect(boundary.name).to eq('test_boundary')
+    end
+
+    it 'defaults to cognitive type' do
+      expect(boundary.boundary_type).to eq(:cognitive)
+    end
+
+    it 'defaults permeability to DEFAULT_PERMEABILITY' do
+      default = Legion::Extensions::Agentic::Integration::Boundary::Helpers::Constants::DEFAULT_PERMEABILITY
+      expect(boundary.permeability).to eq(default)
+    end
+
+    it 'starts with 0 violations' do
+      expect(boundary.violations).to eq(0)
+    end
+
+    it 'clamps permeability to 0..1' do
+      high = described_class.new(name: 'high', permeability: 5.0)
+      expect(high.permeability).to eq(1.0)
+
+      low = described_class.new(name: 'low', permeability: -1.0)
+      expect(low.permeability).to eq(0.0)
+    end
+
+    it 'converts boundary_type to symbol' do
+      b = described_class.new(name: 'b', boundary_type: 'emotional')
+      expect(b.boundary_type).to eq(:emotional)
+    end
+  end
+
+  describe '#integrity' do
+    it 'starts at 1.0 with no violations' do
+      expect(boundary.integrity).to eq(1.0)
+    end
+
+    it 'decreases with violations' do
+      5.times { boundary.violate! }
+      expect(boundary.integrity).to eq(0.75)
+    end
+
+    it 'floors at 0.0' do
+      25.times { boundary.violate! }
+      expect(boundary.integrity).to eq(0.0)
+    end
+  end
+
+  describe '#integrity_label' do
+    it 'returns :intact for full integrity' do
+      expect(boundary.integrity_label).to eq(:intact)
+    end
+
+    it 'returns :breached for very low integrity' do
+      20.times { boundary.violate! }
+      expect(boundary.integrity_label).to eq(:breached)
+    end
+  end
+
+  describe '#permeability_label' do
+    it 'returns a symbol' do
+      expect(boundary.permeability_label).to be_a(Symbol)
+    end
+
+    it 'returns :sealed for 0.0 permeability' do
+      boundary.seal!
+      expect(boundary.permeability_label).to eq(:sealed)
+    end
+  end
+
+  describe '#breached?' do
+    it 'is false when healthy' do
+      expect(boundary.breached?).to be false
+    end
+
+    it 'is true when permeability exceeds threshold' do
+      b = described_class.new(name: 'open', permeability: 0.9)
+      expect(b.breached?).to be true
+    end
+
+    it 'is true when integrity drops below 0.2' do
+      17.times { boundary.violate! }
+      expect(boundary.breached?).to be true
+    end
+  end
+
+  describe '#open!' do
+    it 'increases permeability' do
+      original = boundary.permeability
+      boundary.open!
+      expect(boundary.permeability).to be > original
+    end
+
+    it 'clamps at 1.0' do
+      b = described_class.new(name: 'high', permeability: 0.99)
+      b.open!(amount: 0.5)
+      expect(b.permeability).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(boundary.open!).to eq(boundary)
+    end
+  end
+
+  describe '#close!' do
+    it 'decreases permeability' do
+      original = boundary.permeability
+      boundary.close!
+      expect(boundary.permeability).to be < original
+    end
+
+    it 'clamps at 0.0' do
+      b = described_class.new(name: 'low', permeability: 0.01)
+      b.close!(amount: 0.5)
+      expect(b.permeability).to eq(0.0)
+    end
+  end
+
+  describe '#violate!' do
+    it 'increments violation count' do
+      boundary.violate!
+      expect(boundary.violations).to eq(1)
+    end
+
+    it 'returns self' do
+      expect(boundary.violate!).to eq(boundary)
+    end
+  end
+
+  describe '#repair!' do
+    it 'decrements violation count' do
+      3.times { boundary.violate! }
+      boundary.repair!
+      expect(boundary.violations).to eq(2)
+    end
+
+    it 'floors at 0' do
+      boundary.repair!
+      expect(boundary.violations).to eq(0)
+    end
+  end
+
+  describe '#seal!' do
+    it 'sets permeability to 0.0' do
+      boundary.seal!
+      expect(boundary.permeability).to eq(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = boundary.to_h
+      expect(hash).to include(
+        :id, :name, :boundary_type, :permeability, :permeability_label,
+        :integrity, :integrity_label, :breached, :violations, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/boundary/helpers/constants_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Boundary::Helpers::Constants do
+  let(:klass) { Class.new { include Legion::Extensions::Agentic::Integration::Boundary::Helpers::Constants } }
+
+  describe 'DEFAULT_PERMEABILITY' do
+    it 'is a float between 0 and 1' do
+      expect(klass::DEFAULT_PERMEABILITY).to be_a(Float)
+      expect(klass::DEFAULT_PERMEABILITY).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe 'PERMEABILITY_BOOST' do
+    it 'is a small positive float' do
+      expect(klass::PERMEABILITY_BOOST).to be_a(Float)
+      expect(klass::PERMEABILITY_BOOST).to be > 0
+      expect(klass::PERMEABILITY_BOOST).to be < 0.5
+    end
+  end
+
+  describe 'BREACH_THRESHOLD' do
+    it 'is a float between 0 and 1' do
+      expect(klass::BREACH_THRESHOLD).to be_a(Float)
+      expect(klass::BREACH_THRESHOLD).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe 'PERMEABILITY_LABELS' do
+    it 'is a frozen hash' do
+      expect(klass::PERMEABILITY_LABELS).to be_a(Hash).and be_frozen
+    end
+
+    it 'covers the full 0..1 range' do
+      labels = klass::PERMEABILITY_LABELS
+      [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0].each do |val|
+        match = labels.find { |range, _| range.cover?(val) }
+        expect(match).not_to be_nil, "no label for #{val}"
+      end
+    end
+  end
+
+  describe 'INTEGRITY_LABELS' do
+    it 'is a frozen hash' do
+      expect(klass::INTEGRITY_LABELS).to be_a(Hash).and be_frozen
+    end
+  end
+
+  describe 'BOUNDARY_TYPES' do
+    it 'is a frozen array of symbols' do
+      expect(klass::BOUNDARY_TYPES).to be_a(Array).and be_frozen
+      expect(klass::BOUNDARY_TYPES).to all(be_a(Symbol))
+    end
+
+    it 'includes cognitive and emotional' do
+      expect(klass::BOUNDARY_TYPES).to include(:cognitive, :emotional)
+    end
+  end
+
+  describe 'MAX_BOUNDARIES' do
+    it 'is a positive integer' do
+      expect(klass::MAX_BOUNDARIES).to be_a(Integer)
+      expect(klass::MAX_BOUNDARIES).to be > 0
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/boundary/runners/cognitive_boundary_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Boundary::Runners::CognitiveBoundary do
+  let(:client) { Legion::Extensions::Agentic::Integration::Boundary::Client.new }
+
+  describe '#create_boundary' do
+    it 'returns success with boundary hash' do
+      result = client.create_boundary(name: 'test')
+      expect(result[:success]).to be true
+      expect(result[:boundary]).to include(:id, :name, :permeability, :integrity)
+    end
+  end
+
+  describe '#open_boundary' do
+    it 'increases permeability' do
+      b = client.create_boundary(name: 'test')
+      bid = b[:boundary][:id]
+      result = client.open_boundary(boundary_id: bid)
+      expect(result[:success]).to be true
+      expect(result[:boundary][:permeability]).to be > 0.5
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.open_boundary(boundary_id: 'fake')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#close_boundary' do
+    it 'decreases permeability' do
+      b = client.create_boundary(name: 'test')
+      bid = b[:boundary][:id]
+      result = client.close_boundary(boundary_id: bid)
+      expect(result[:success]).to be true
+      expect(result[:boundary][:permeability]).to be < 0.5
+    end
+  end
+
+  describe '#violate_boundary' do
+    it 'increments violations' do
+      b = client.create_boundary(name: 'test')
+      bid = b[:boundary][:id]
+      result = client.violate_boundary(boundary_id: bid)
+      expect(result[:success]).to be true
+      expect(result[:boundary][:violations]).to eq(1)
+    end
+  end
+
+  describe '#repair_boundary' do
+    it 'decrements violations' do
+      b = client.create_boundary(name: 'test')
+      bid = b[:boundary][:id]
+      client.violate_boundary(boundary_id: bid)
+      result = client.repair_boundary(boundary_id: bid)
+      expect(result[:success]).to be true
+      expect(result[:boundary][:violations]).to eq(0)
+    end
+  end
+
+  describe '#seal_boundary' do
+    it 'sets permeability to 0' do
+      b = client.create_boundary(name: 'test')
+      bid = b[:boundary][:id]
+      result = client.seal_boundary(boundary_id: bid)
+      expect(result[:success]).to be true
+      expect(result[:boundary][:permeability]).to eq(0.0)
+    end
+  end
+
+  describe '#breached_boundaries' do
+    it 'returns breached boundaries' do
+      client.create_boundary(name: 'open', permeability: 0.9)
+      result = client.breached_boundaries
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#boundaries_by_type' do
+    it 'filters by type' do
+      client.create_boundary(name: 'emo', boundary_type: :emotional)
+      result = client.boundaries_by_type(boundary_type: :emotional)
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#overall_integrity' do
+    it 'returns integrity score' do
+      result = client.overall_integrity
+      expect(result[:success]).to be true
+      expect(result[:integrity]).to be_a(Numeric)
+    end
+  end
+
+  describe '#overall_permeability' do
+    it 'returns permeability score' do
+      result = client.overall_permeability
+      expect(result[:success]).to be true
+      expect(result[:permeability]).to be_a(Numeric)
+    end
+  end
+
+  describe '#boundary_report' do
+    it 'returns a full report' do
+      result = client.boundary_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_boundaries, :overall_integrity)
+    end
+  end
+end