lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/phenomenal_binding/runners/phenomenal_binding_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/phenomenal_binding/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::PhenomenalBinding::Runners::PhenomenalBinding do
+  let(:client) { Legion::Extensions::Agentic::Integration::PhenomenalBinding::Client.new }
+
+  describe '#register_stream' do
+    it 'returns a registered status' do
+      result = client.register_stream(stream_type: :perception, content: 'red circle')
+      expect(result[:status]).to eq(:registered)
+    end
+
+    it 'returns a stream hash' do
+      result = client.register_stream(stream_type: :thought, content: 'abstract idea')
+      expect(result[:stream]).to be_a(Hash)
+      expect(result[:stream][:id]).to be_a(String)
+    end
+
+    it 'uses the given stream_type' do
+      result = client.register_stream(stream_type: :emotion, content: 'joy')
+      expect(result[:stream][:stream_type]).to eq(:emotion)
+    end
+
+    it 'accepts custom salience' do
+      result = client.register_stream(stream_type: :memory, content: 'vivid', salience: 0.9)
+      expect(result[:stream][:salience]).to eq(0.9)
+    end
+  end
+
+  describe '#create_binding' do
+    it 'returns a bound status' do
+      s = client.register_stream(stream_type: :perception, content: 'a')
+      result = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :perceptual)
+      expect(result[:status]).to eq(:bound)
+    end
+
+    it 'returns a binding hash' do
+      s = client.register_stream(stream_type: :thought, content: 'concept')
+      result = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :conceptual)
+      expect(result[:binding]).to be_a(Hash)
+      expect(result[:binding][:binding_type]).to eq(:conceptual)
+    end
+
+    it 'coherence reflects stream saliences' do
+      s = client.register_stream(stream_type: :perception, content: 'bright', salience: 0.8)
+      result = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :perceptual)
+      expect(result[:binding][:coherence]).to be_within(0.001).of(0.8)
+    end
+  end
+
+  describe '#reinforce_binding' do
+    it 'returns reinforced status for valid binding' do
+      s = client.register_stream(stream_type: :intention, content: 'goal')
+      b = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :narrative)
+      result = client.reinforce_binding(binding_id: b[:binding][:id])
+      expect(result[:status]).to eq(:reinforced)
+    end
+
+    it 'returns not_found for unknown binding' do
+      result = client.reinforce_binding(binding_id: 'bogus')
+      expect(result[:status]).to eq(:not_found)
+    end
+  end
+
+  describe '#dissolve_binding' do
+    it 'returns dissolved status for valid binding' do
+      s = client.register_stream(stream_type: :memory, content: 'past')
+      b = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :temporal)
+      result = client.dissolve_binding(binding_id: b[:binding][:id])
+      expect(result[:status]).to eq(:dissolved)
+    end
+
+    it 'returns not_found for unknown binding' do
+      result = client.dissolve_binding(binding_id: 'ghost')
+      expect(result[:status]).to eq(:not_found)
+    end
+  end
+
+  describe '#unified_experience' do
+    it 'returns nil unified_experience when no coherent bindings' do
+      result = client.unified_experience
+      expect(result[:unified_experience]).to be_nil
+    end
+
+    it 'returns a binding hash when coherent binding exists' do
+      s = client.register_stream(stream_type: :perception, content: 'vivid', salience: 0.9)
+      client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :perceptual)
+      result = client.unified_experience
+      expect(result[:unified_experience]).to be_a(Hash)
+    end
+  end
+
+  describe '#fragmentation_index' do
+    it 'returns fragmentation_index key' do
+      result = client.fragmentation_index
+      expect(result).to have_key(:fragmentation_index)
+    end
+
+    it 'returns 0.0 when no streams exist' do
+      expect(client.fragmentation_index[:fragmentation_index]).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all streams are unbound' do
+      client.register_stream(stream_type: :thought, content: 'loose')
+      expect(client.fragmentation_index[:fragmentation_index]).to eq(1.0)
+    end
+  end
+
+  describe '#binding_by_type' do
+    it 'returns bindings of the requested type' do
+      s = client.register_stream(stream_type: :prediction, content: 'forecast')
+      client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :temporal)
+      result = client.binding_by_type(binding_type: :temporal)
+      expect(result[:binding_type]).to eq(:temporal)
+      expect(result[:bindings].size).to eq(1)
+    end
+
+    it 'returns empty array for absent type' do
+      result = client.binding_by_type(binding_type: :narrative)
+      expect(result[:bindings]).to be_empty
+    end
+  end
+
+  describe '#streams_for_binding' do
+    it 'returns streams belonging to the binding' do
+      s = client.register_stream(stream_type: :emotion, content: 'warmth')
+      b = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :emotional)
+      result = client.streams_for_binding(binding_id: b[:binding][:id])
+      expect(result[:streams].size).to eq(1)
+      expect(result[:streams].first[:id]).to eq(s[:stream][:id])
+    end
+  end
+
+  describe '#unbound_streams' do
+    it 'returns all streams when nothing is bound' do
+      client.register_stream(stream_type: :intention, content: 'plan')
+      result = client.unbound_streams
+      expect(result[:unbound_streams].size).to eq(1)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns decayed status' do
+      result = client.decay_all
+      expect(result[:status]).to eq(:decayed)
+    end
+  end
+
+  describe '#prune_incoherent' do
+    it 'returns pruned status' do
+      result = client.prune_incoherent
+      expect(result[:status]).to eq(:pruned)
+    end
+  end
+
+  describe '#consciousness_report' do
+    it 'returns all expected report keys' do
+      report = client.consciousness_report
+      expect(report.keys).to include(
+        :unified_experience, :fragmentation_index,
+        :coherence_distribution, :stream_count, :binding_count, :unbound_count
+      )
+    end
+  end
+
+  describe '#engine_stats' do
+    it 'returns engine stats hash' do
+      stats = client.engine_stats
+      expect(stats[:stream_count]).to eq(0)
+      expect(stats[:binding_count]).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Qualia::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_quale, :fade_all, :qualia_status)
+  end
+
+  it 'runs a full qualia lifecycle' do
+    result = client.create_quale(content: 'sharp insight', modality: :emotional,
+                                 quality: :sharp, texture: :crystalline, vividness: 0.8)
+    quale_id = result[:quale][:id]
+
+    client.intensify_quale(quale_id: quale_id)
+    client.fade_all
+
+    status = client.qualia_status
+    expect(status[:total_experiences]).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/integration/qualia/helpers/quale_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Qualia::Helpers::Quale do
+  subject(:quale) { described_class.new(content: 'warmth of recognition') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(quale.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(quale.content).to eq('warmth of recognition')
+    end
+
+    it 'defaults modality to :abstract' do
+      expect(quale.modality).to eq(:abstract)
+    end
+
+    it 'defaults quality to :smooth' do
+      expect(quale.quality).to eq(:smooth)
+    end
+
+    it 'defaults texture to :fluid' do
+      expect(quale.texture).to eq(:fluid)
+    end
+
+    it 'defaults vividness' do
+      expect(quale.vividness).to eq(0.5)
+    end
+
+    it 'defaults valence to 0.0' do
+      expect(quale.valence).to eq(0.0)
+    end
+
+    it 'clamps vividness' do
+      high = described_class.new(content: 'x', vividness: 5.0)
+      expect(high.vividness).to eq(1.0)
+    end
+
+    it 'clamps valence' do
+      extreme = described_class.new(content: 'x', valence: -5.0)
+      expect(extreme.valence).to eq(-1.0)
+    end
+
+    it 'validates modality' do
+      bad = described_class.new(content: 'x', modality: :nonexistent)
+      expect(bad.modality).to eq(:abstract)
+    end
+
+    it 'validates quality' do
+      bad = described_class.new(content: 'x', quality: :nonexistent)
+      expect(bad.quality).to eq(:smooth)
+    end
+
+    it 'validates texture' do
+      bad = described_class.new(content: 'x', texture: :nonexistent)
+      expect(bad.texture).to eq(:fluid)
+    end
+  end
+
+  describe '#intensify!' do
+    it 'increases vividness' do
+      original = quale.vividness
+      quale.intensify!
+      expect(quale.vividness).to be > original
+    end
+
+    it 'clamps at 1.0' do
+      20.times { quale.intensify! }
+      expect(quale.vividness).to eq(1.0)
+    end
+  end
+
+  describe '#fade!' do
+    it 'decreases vividness' do
+      original = quale.vividness
+      quale.fade!
+      expect(quale.vividness).to be < original
+    end
+
+    it 'clamps at 0.0' do
+      50.times { quale.fade! }
+      expect(quale.vividness).to eq(0.0)
+    end
+  end
+
+  describe '#vivid?' do
+    it 'is false at default vividness' do
+      expect(quale.vivid?).to be false
+    end
+
+    it 'is true when vivid' do
+      vivid = described_class.new(content: 'x', vividness: 0.8)
+      expect(vivid.vivid?).to be true
+    end
+  end
+
+  describe '#faint?' do
+    it 'is false at default vividness' do
+      expect(quale.faint?).to be false
+    end
+
+    it 'is true when faint' do
+      faint = described_class.new(content: 'x', vividness: 0.1)
+      expect(faint.faint?).to be true
+    end
+  end
+
+  describe '#intense?' do
+    it 'is true when very vivid' do
+      intense = described_class.new(content: 'x', vividness: 0.9)
+      expect(intense.intense?).to be true
+    end
+  end
+
+  describe '#pleasant?' do
+    it 'is true for positive valence' do
+      pleasant = described_class.new(content: 'x', valence: 0.5)
+      expect(pleasant.pleasant?).to be true
+    end
+
+    it 'is false for negative valence' do
+      expect(quale.pleasant?).to be false
+    end
+  end
+
+  describe '#unpleasant?' do
+    it 'is true for negative valence' do
+      unpleasant = described_class.new(content: 'x', valence: -0.5)
+      expect(unpleasant.unpleasant?).to be true
+    end
+  end
+
+  describe '#neutral_valence?' do
+    it 'is true at default valence' do
+      expect(quale.neutral_valence?).to be true
+    end
+  end
+
+  describe '#phenomenal_richness' do
+    it 'returns a value between 0 and 1' do
+      expect(quale.phenomenal_richness).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#persistence' do
+    it 'is 1.0 initially' do
+      expect(quale.persistence).to eq(1.0)
+    end
+
+    it 'decreases after fading' do
+      quale.fade!
+      expect(quale.persistence).to be < 1.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = quale.to_h
+      expect(hash).to include(
+        :id, :content, :modality, :quality, :texture, :vividness,
+        :original_vividness, :valence, :phenomenal_richness,
+        :vivid, :faint, :intense, :vividness_label, :valence_label,
+        :persistence, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/qualia/helpers/qualia_engine_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Qualia::Helpers::QualiaEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_quale' do
+    it 'creates and stores a quale' do
+      quale = engine.create_quale(content: 'sharpness of insight')
+      expect(quale.content).to eq('sharpness of insight')
+    end
+  end
+
+  describe '#intensify' do
+    it 'increases vividness' do
+      quale = engine.create_quale(content: 'test')
+      original = quale.vividness
+      engine.intensify(quale_id: quale.id)
+      expect(quale.vividness).to be > original
+    end
+
+    it 'returns nil for unknown quale' do
+      expect(engine.intensify(quale_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#fade_all!' do
+    it 'fades all qualia' do
+      quale = engine.create_quale(content: 'test')
+      original = quale.vividness
+      engine.fade_all!
+      expect(quale.vividness).to be < original
+    end
+  end
+
+  describe '#vivid_experiences' do
+    it 'returns vivid qualia' do
+      engine.create_quale(content: 'vivid', vividness: 0.8)
+      engine.create_quale(content: 'faint', vividness: 0.2)
+      expect(engine.vivid_experiences.size).to eq(1)
+    end
+  end
+
+  describe '#faint_experiences' do
+    it 'returns faint qualia' do
+      engine.create_quale(content: 'faint', vividness: 0.1)
+      expect(engine.faint_experiences.size).to eq(1)
+    end
+  end
+
+  describe '#by_modality' do
+    it 'filters by modality' do
+      engine.create_quale(content: 'a', modality: :visual)
+      engine.create_quale(content: 'b', modality: :auditory)
+      expect(engine.by_modality(modality: :visual).size).to eq(1)
+    end
+  end
+
+  describe '#by_quality' do
+    it 'filters by quality' do
+      engine.create_quale(content: 'a', quality: :sharp)
+      engine.create_quale(content: 'b', quality: :warm)
+      expect(engine.by_quality(quality: :sharp).size).to eq(1)
+    end
+  end
+
+  describe '#by_texture' do
+    it 'filters by texture' do
+      engine.create_quale(content: 'a', texture: :metallic)
+      engine.create_quale(content: 'b', texture: :velvet)
+      expect(engine.by_texture(texture: :metallic).size).to eq(1)
+    end
+  end
+
+  describe '#pleasant_experiences' do
+    it 'returns pleasant qualia' do
+      engine.create_quale(content: 'nice', valence: 0.5)
+      engine.create_quale(content: 'bad', valence: -0.5)
+      expect(engine.pleasant_experiences.size).to eq(1)
+    end
+  end
+
+  describe '#unpleasant_experiences' do
+    it 'returns unpleasant qualia' do
+      engine.create_quale(content: 'bad', valence: -0.5)
+      expect(engine.unpleasant_experiences.size).to eq(1)
+    end
+  end
+
+  describe '#most_vivid' do
+    it 'returns sorted by vividness descending' do
+      engine.create_quale(content: 'dim', vividness: 0.3)
+      bright = engine.create_quale(content: 'bright', vividness: 0.9)
+      expect(engine.most_vivid(limit: 1).first.id).to eq(bright.id)
+    end
+  end
+
+  describe '#average_vividness' do
+    it 'returns 0.0 with no qualia' do
+      expect(engine.average_vividness).to eq(0.0)
+    end
+
+    it 'computes average' do
+      engine.create_quale(content: 'a', vividness: 0.4)
+      engine.create_quale(content: 'b', vividness: 0.6)
+      expect(engine.average_vividness).to eq(0.5)
+    end
+  end
+
+  describe '#average_valence' do
+    it 'returns 0.0 with no qualia' do
+      expect(engine.average_valence).to eq(0.0)
+    end
+  end
+
+  describe '#phenomenal_richness' do
+    it 'returns 0.0 with no qualia' do
+      expect(engine.phenomenal_richness).to eq(0.0)
+    end
+
+    it 'returns positive with qualia' do
+      engine.create_quale(content: 'test', vividness: 0.8)
+      expect(engine.phenomenal_richness).to be > 0.0
+    end
+  end
+
+  describe '#modality_distribution' do
+    it 'returns counts per modality' do
+      engine.create_quale(content: 'a', modality: :visual)
+      dist = engine.modality_distribution
+      expect(dist[:visual]).to eq(1)
+      expect(dist[:auditory]).to eq(0)
+    end
+  end
+
+  describe '#experiential_diversity' do
+    it 'returns 0.0 with no qualia' do
+      expect(engine.experiential_diversity).to eq(0.0)
+    end
+
+    it 'increases with diverse modalities' do
+      engine.create_quale(content: 'a', modality: :visual)
+      engine.create_quale(content: 'b', modality: :auditory)
+      expect(engine.experiential_diversity).to be > 0.0
+    end
+  end
+
+  describe '#quality_palette' do
+    it 'returns quality frequencies' do
+      engine.create_quale(content: 'a', quality: :sharp)
+      engine.create_quale(content: 'b', quality: :sharp)
+      palette = engine.quality_palette
+      expect(palette[:sharp]).to eq(2)
+    end
+  end
+
+  describe '#qualia_report' do
+    it 'includes all report fields' do
+      report = engine.qualia_report
+      expect(report).to include(
+        :total_experiences, :vivid_count, :faint_count,
+        :pleasant_count, :unpleasant_count, :average_vividness,
+        :average_valence, :phenomenal_richness, :experiential_diversity,
+        :richness_label, :most_vivid
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(:total_experiences, :vivid, :avg_vividness, :avg_valence, :richness)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/qualia/qualia_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Qualia do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Integration::Qualia::VERSION).to eq('0.1.0')
+  end
+end

data/spec/legion/extensions/agentic/integration/qualia/runners_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Qualia::Runners::Qualia do
+  let(:engine) { Legion::Extensions::Agentic::Integration::Qualia::Helpers::QualiaEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@default_engine, engine)
+    obj
+  end
+
+  describe '#create_quale' do
+    it 'returns success with quale hash' do
+      result = runner.create_quale(content: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:quale][:content]).to eq('test')
+    end
+  end
+
+  describe '#intensify_quale' do
+    it 'returns success for known quale' do
+      quale = engine.create_quale(content: 'test')
+      result = runner.intensify_quale(quale_id: quale.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown quale' do
+      result = runner.intensify_quale(quale_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#fade_all' do
+    it 'returns success' do
+      result = runner.fade_all(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#vivid_experiences' do
+    it 'returns vivid list' do
+      engine.create_quale(content: 'vivid', vividness: 0.8)
+      result = runner.vivid_experiences(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#by_modality' do
+    it 'filters by modality' do
+      engine.create_quale(content: 'a', modality: :visual)
+      result = runner.by_modality(modality: :visual, engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#phenomenal_richness' do
+    it 'returns richness level' do
+      result = runner.phenomenal_richness(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#qualia_status' do
+    it 'returns comprehensive status' do
+      result = runner.qualia_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result).to include(:total_experiences, :phenomenal_richness)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/situation_model/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::SituationModel::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    %i[
+      create_situation_model
+      add_situation_event
+      situation_model_coherence
+      find_situation_boundaries
+      situation_dimension_trajectory
+      most_coherent_situations
+      situations_by_label
+      update_situation_models
+      situation_model_stats
+    ].each do |method_name|
+      expect(client).to respond_to(method_name)
+    end
+  end
+
+  it 'round-trips a full situation model lifecycle' do
+    created  = client.create_situation_model(label: 'round_trip')
+    model_id = created[:model][:id]
+
+    client.add_situation_event(model_id: model_id, content: 'scene 1',
+                               space: 0.8, time: 0.8, causation: 0.8, intentionality: 0.7, protagonist: 0.9)
+    client.add_situation_event(model_id: model_id, content: 'scene 2',
+                               space: 0.7, time: 0.9, causation: 0.8, intentionality: 0.7, protagonist: 0.8)
+
+    coh = client.situation_model_coherence(model_id: model_id)
+    expect(coh[:success]).to be(true)
+    expect(coh[:coherence]).to be > 0.7
+
+    traj = client.situation_dimension_trajectory(model_id: model_id, dimension: :time)
+    expect(traj[:trajectory]).to eq([0.8, 0.9])
+
+    stats = client.situation_model_stats
+    expect(stats[:model_count]).to be >= 1
+  end
+
+  it 'maintains separate engine state per instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.create_situation_model(label: 'only_c1')
+    expect(c1.situation_model_stats[:model_count]).to eq(1)
+    expect(c2.situation_model_stats[:model_count]).to eq(0)
+  end
+end