lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/global_workspace/runners/global_workspace_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::GlobalWorkspace::Runners::GlobalWorkspace do
+  let(:client) { Legion::Extensions::Agentic::Integration::GlobalWorkspace::Client.new }
+
+  describe '#submit_for_broadcast' do
+    it 'submits content for competition' do
+      result = client.submit_for_broadcast(content: 'idea', source: :cortex, domain: :cognition, salience: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:effective_salience]).to be > 0
+    end
+
+    it 'rejects below-threshold content' do
+      result = client.submit_for_broadcast(content: 'weak', source: :s, domain: :d, salience: 0.1)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:below_threshold)
+    end
+  end
+
+  describe '#run_competition' do
+    it 'broadcasts winning content' do
+      client.submit_for_broadcast(content: 'strong', source: :emotion, domain: :safety, salience: 0.9)
+      result = client.run_competition
+      expect(result[:success]).to be true
+      expect(result[:broadcast][:content]).to eq('strong')
+    end
+
+    it 'returns no_winner when no competitors' do
+      result = client.run_competition
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:no_winner)
+    end
+  end
+
+  describe '#register_subscriber / #unregister_subscriber' do
+    it 'registers a subscriber' do
+      result = client.register_subscriber(id: :memory, name: 'lex-memory', domains: [:all])
+      expect(result[:success]).to be true
+      expect(result[:subscriber_count]).to eq(1)
+    end
+
+    it 'unregisters a subscriber' do
+      client.register_subscriber(id: :memory, name: 'lex-memory')
+      result = client.unregister_subscriber(id: :memory)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#acknowledge_broadcast' do
+    it 'acknowledges active broadcast' do
+      client.submit_for_broadcast(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      client.run_competition
+      result = client.acknowledge_broadcast(subscriber_id: :memory)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns false when no broadcast' do
+      result = client.acknowledge_broadcast(subscriber_id: :memory)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#query_consciousness' do
+    it 'returns conscious: true for broadcasted content' do
+      client.submit_for_broadcast(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      client.run_competition
+      result = client.query_consciousness(content: 'idea')
+      expect(result[:conscious]).to be true
+    end
+
+    it 'returns conscious: false for non-broadcasted content' do
+      result = client.query_consciousness(content: 'nothing')
+      expect(result[:conscious]).to be false
+    end
+  end
+
+  describe '#current_broadcast' do
+    it 'returns broadcast when active' do
+      client.submit_for_broadcast(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      client.run_competition
+      result = client.current_broadcast
+      expect(result[:broadcast]).not_to be_nil
+      expect(result[:broadcast][:content]).to eq('idea')
+    end
+
+    it 'returns nil when no active broadcast' do
+      result = client.current_broadcast
+      expect(result[:broadcast]).to be_nil
+    end
+  end
+
+  describe '#broadcast_history' do
+    it 'returns history' do
+      client.submit_for_broadcast(content: 'idea', source: :s, domain: :d, salience: 0.9)
+      client.run_competition
+      result = client.broadcast_history(limit: 5)
+      expect(result[:success]).to be true
+      expect(result[:history].size).to eq(1)
+    end
+  end
+
+  describe '#update_global_workspace' do
+    it 'runs tick maintenance' do
+      result = client.update_global_workspace
+      expect(result[:success]).to be true
+      expect(result).to have_key(:state)
+      expect(result).to have_key(:utilization)
+    end
+  end
+
+  describe '#workspace_stats' do
+    it 'returns stats' do
+      result = client.workspace_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:state, :subscribers, :competitors, :utilization)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/integration/cognitive_integration_spec.rb

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

data/spec/legion/extensions/agentic/integration/integration/helpers/integrated_representation_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Integration::Helpers::IntegratedRepresentation do
+  let(:visual) do
+    Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal.new(
+      modality: :visual, content: 'face', confidence: 0.8, salience: 0.7
+    )
+  end
+  let(:auditory) do
+    Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal.new(
+      modality: :auditory, content: 'voice', confidence: 0.7, salience: 0.6
+    )
+  end
+  let(:emotional) do
+    Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal.new(
+      modality: :emotional, content: 'warmth', confidence: 0.9, salience: 0.8
+    )
+  end
+
+  subject(:rep) { described_class.new(signals: [visual, auditory]) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(rep.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'captures signal ids' do
+      expect(rep.signal_ids).to contain_exactly(visual.id, auditory.id)
+    end
+
+    it 'captures unique modalities' do
+      expect(rep.modalities).to contain_exactly(:visual, :auditory)
+    end
+
+    it 'computes initial binding strength' do
+      expect(rep.binding_strength).to be_between(0.0, 1.0)
+    end
+
+    it 'computes initial coherence' do
+      expect(rep.coherence).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increases binding strength' do
+      original = rep.binding_strength
+      rep.reinforce!
+      expect(rep.binding_strength).to be > original
+    end
+
+    it 'returns self' do
+      expect(rep.reinforce!).to eq(rep)
+    end
+
+    it 'clamps at 1.0' do
+      15.times { rep.reinforce! }
+      expect(rep.binding_strength).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'decreases binding strength' do
+      original = rep.binding_strength
+      rep.decay!
+      expect(rep.binding_strength).to be < original
+    end
+  end
+
+  describe '#disrupt!' do
+    it 'decreases binding strength' do
+      original = rep.binding_strength
+      rep.disrupt!
+      expect(rep.binding_strength).to be < original
+    end
+
+    it 'decreases coherence' do
+      original = rep.coherence
+      rep.disrupt!
+      expect(rep.coherence).to be < original
+    end
+  end
+
+  describe '#multi_modal?' do
+    it 'is true for multiple modalities' do
+      expect(rep.multi_modal?).to be true
+    end
+
+    it 'is false for single modality' do
+      visual2 = Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal.new(
+        modality: :visual, content: 'color', confidence: 0.8
+      )
+      single = described_class.new(signals: [visual, visual2])
+      expect(single.multi_modal?).to be false
+    end
+  end
+
+  describe '#modal_count' do
+    it 'returns number of unique modalities' do
+      tri = described_class.new(signals: [visual, auditory, emotional])
+      expect(tri.modal_count).to eq(3)
+    end
+  end
+
+  describe '#coherent?' do
+    it 'returns boolean based on coherence threshold' do
+      expect(rep.coherent?).to be(true).or be(false)
+    end
+  end
+
+  describe '#fragmented?' do
+    it 'returns boolean' do
+      expect(rep.fragmented?).to be(true).or be(false)
+    end
+  end
+
+  describe '#binding_label' do
+    it 'returns a symbol' do
+      expect(rep.binding_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#quality_label' do
+    it 'returns a symbol' do
+      expect(rep.quality_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#quality_score' do
+    it 'is between 0 and 1' do
+      expect(rep.quality_score).to be_between(0.0, 1.0)
+    end
+
+    it 'combines binding and coherence' do
+      expect(rep.quality_score).to be > 0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = rep.to_h
+      expect(hash).to include(
+        :id, :signal_ids, :modalities, :modal_count, :multi_modal,
+        :binding_strength, :binding_label, :coherence, :coherent,
+        :fragmented, :quality_score, :quality_label,
+        :reinforcement_count, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/integration/helpers/integration_engine_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Integration::Helpers::IntegrationEngine do
+  subject(:engine) { described_class.new }
+
+  let(:visual) { engine.add_signal(modality: :visual, content: 'face', confidence: 0.8, salience: 0.7) }
+  let(:auditory) { engine.add_signal(modality: :auditory, content: 'voice', confidence: 0.7, salience: 0.6) }
+  let(:emotional) { engine.add_signal(modality: :emotional, content: 'warmth', confidence: 0.9, salience: 0.8) }
+
+  describe '#add_signal' do
+    it 'creates a modal signal' do
+      signal = engine.add_signal(modality: :visual, content: 'test')
+      expect(signal).to be_a(Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal)
+    end
+
+    it 'stores the signal' do
+      signal = engine.add_signal(modality: :visual, content: 'stored')
+      found = engine.signals_by_modality(modality: :visual)
+      expect(found.map(&:id)).to include(signal.id)
+    end
+  end
+
+  describe '#remove_signal' do
+    it 'removes existing signal' do
+      signal = engine.add_signal(modality: :visual, content: 'remove_me')
+      engine.remove_signal(signal_id: signal.id)
+      expect(engine.signals_by_modality(modality: :visual)).to be_empty
+    end
+
+    it 'returns nil for unknown signal' do
+      expect(engine.remove_signal(signal_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#integrate' do
+    it 'creates an integrated representation' do
+      rep = engine.integrate(signal_ids: [visual.id, auditory.id])
+      expect(rep).to be_a(Legion::Extensions::Agentic::Integration::Integration::Helpers::IntegratedRepresentation)
+    end
+
+    it 'returns nil with insufficient signals' do
+      expect(engine.integrate(signal_ids: [visual.id])).to be_nil
+    end
+
+    it 'returns nil with all invalid ids' do
+      expect(engine.integrate(signal_ids: %w[bad1 bad2])).to be_nil
+    end
+
+    it 'creates multi-modal representation' do
+      rep = engine.integrate(signal_ids: [visual.id, auditory.id, emotional.id])
+      expect(rep.multi_modal?).to be true
+      expect(rep.modal_count).to eq(3)
+    end
+  end
+
+  describe '#integrate_by_modalities' do
+    it 'integrates matching signals' do
+      visual
+      auditory
+      rep = engine.integrate_by_modalities(modalities: %i[visual auditory])
+      expect(rep).not_to be_nil
+      expect(rep.modalities).to contain_exactly(:visual, :auditory)
+    end
+
+    it 'returns nil with insufficient matching signals' do
+      visual
+      expect(engine.integrate_by_modalities(modalities: [:auditory])).to be_nil
+    end
+  end
+
+  describe '#integrate_all_salient' do
+    it 'integrates salient signals' do
+      visual
+      emotional
+      rep = engine.integrate_all_salient
+      expect(rep).not_to be_nil
+    end
+
+    it 'returns nil with no salient signals' do
+      engine.add_signal(modality: :visual, content: 'x', salience: 0.1)
+      expect(engine.integrate_all_salient).to be_nil
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases binding strength' do
+      rep = engine.integrate(signal_ids: [visual.id, auditory.id])
+      original = rep.binding_strength
+      engine.reinforce(representation_id: rep.id)
+      expect(rep.binding_strength).to be > original
+    end
+
+    it 'returns nil for unknown representation' do
+      expect(engine.reinforce(representation_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#disrupt' do
+    it 'decreases binding strength' do
+      rep = engine.integrate(signal_ids: [visual.id, auditory.id])
+      original = rep.binding_strength
+      engine.disrupt(representation_id: rep.id)
+      expect(rep.binding_strength).to be < original
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays all representations' do
+      rep = engine.integrate(signal_ids: [visual.id, auditory.id])
+      original = rep.binding_strength
+      engine.decay_all!
+      expect(rep.binding_strength).to be < original
+    end
+  end
+
+  describe '#signals_by_modality' do
+    it 'returns signals matching the modality' do
+      visual
+      auditory
+      found = engine.signals_by_modality(modality: :visual)
+      expect(found.size).to eq(1)
+      expect(found.first.modality).to eq(:visual)
+    end
+  end
+
+  describe '#multi_modal_representations' do
+    it 'returns only multi-modal representations' do
+      engine.integrate(signal_ids: [visual.id, auditory.id])
+      expect(engine.multi_modal_representations.size).to eq(1)
+    end
+  end
+
+  describe '#coherent_representations' do
+    it 'returns coherent representations' do
+      engine.integrate(signal_ids: [visual.id, auditory.id])
+      result = engine.coherent_representations
+      expect(result).to be_an(Array)
+    end
+  end
+
+  describe '#strongest_representations' do
+    it 'returns representations sorted by binding strength' do
+      rep1 = engine.integrate(signal_ids: [visual.id, auditory.id])
+      engine.reinforce(representation_id: rep1.id)
+      top = engine.strongest_representations(limit: 1)
+      expect(top.first.id).to eq(rep1.id)
+    end
+  end
+
+  describe '#average_binding_strength' do
+    it 'returns default with no representations' do
+      default = Legion::Extensions::Agentic::Integration::Integration::Helpers::Constants::DEFAULT_BINDING_STRENGTH
+      expect(engine.average_binding_strength).to eq(default)
+    end
+
+    it 'computes mean binding strength' do
+      engine.integrate(signal_ids: [visual.id, auditory.id])
+      expect(engine.average_binding_strength).to be > 0
+    end
+  end
+
+  describe '#modality_coverage' do
+    it 'returns unique modalities across all signals' do
+      visual
+      auditory
+      expect(engine.modality_coverage).to contain_exactly(:visual, :auditory)
+    end
+  end
+
+  describe '#integration_report' do
+    it 'returns comprehensive report' do
+      engine.integrate(signal_ids: [visual.id, auditory.id])
+      report = engine.integration_report
+      expect(report).to include(
+        :total_signals, :total_representations, :multi_modal_count,
+        :coherent_count, :fragmented_count, :average_binding_strength,
+        :average_coherence, :modality_coverage, :strongest
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_signals, :total_representations, :multi_modal_count,
+        :coherent_count, :average_binding_strength, :average_coherence
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/integration/helpers/modal_signal_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Integration::Helpers::ModalSignal do
+  subject(:signal) { described_class.new(modality: :visual, content: 'red circle') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(signal.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets modality' do
+      expect(signal.modality).to eq(:visual)
+    end
+
+    it 'sets content' do
+      expect(signal.content).to eq('red circle')
+    end
+
+    it 'defaults confidence to 0.5' do
+      expect(signal.confidence).to eq(0.5)
+    end
+
+    it 'defaults salience to 0.5' do
+      expect(signal.salience).to eq(0.5)
+    end
+
+    it 'clamps high confidence' do
+      high = described_class.new(modality: :visual, content: 'x', confidence: 2.0)
+      expect(high.confidence).to eq(1.0)
+    end
+  end
+
+  describe '#effective_weight' do
+    it 'multiplies confidence by salience' do
+      expect(signal.effective_weight).to eq(0.25)
+    end
+
+    it 'is higher with high confidence and salience' do
+      high = described_class.new(modality: :visual, content: 'x', confidence: 0.9, salience: 0.9)
+      expect(high.effective_weight).to eq(0.81)
+    end
+  end
+
+  describe '#salient?' do
+    it 'is false at default salience' do
+      expect(signal.salient?).to be false
+    end
+
+    it 'is true with high salience' do
+      high = described_class.new(modality: :visual, content: 'x', salience: 0.8)
+      expect(high.salient?).to be true
+    end
+  end
+
+  describe '#confident?' do
+    it 'is false at default confidence' do
+      expect(signal.confident?).to be false
+    end
+
+    it 'is true with high confidence' do
+      high = described_class.new(modality: :visual, content: 'x', confidence: 0.8)
+      expect(high.confident?).to be true
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns a symbol' do
+      expect(signal.confidence_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = signal.to_h
+      expect(hash).to include(
+        :id, :modality, :content, :confidence, :confidence_label,
+        :salience, :effective_weight, :salient, :created_at
+      )
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes the CognitiveLabyrinth runner' do
+    expect(client).to respond_to(:create_labyrinth)
+    expect(client).to respond_to(:add_node)
+    expect(client).to respond_to(:move)
+    expect(client).to respond_to(:backtrack)
+    expect(client).to respond_to(:follow_thread)
+    expect(client).to respond_to(:check_minotaur)
+    expect(client).to respond_to(:labyrinth_report)
+    expect(client).to respond_to(:list_labyrinths)
+    expect(client).to respond_to(:delete_labyrinth)
+  end
+
+  describe 'full labyrinth traversal scenario' do
+    it 'creates, traverses, and solves a simple labyrinth' do
+      # Create the labyrinth
+      create_result = client.create_labyrinth(name: 'Gauntlet', domain: :logic)
+      expect(create_result[:success]).to be(true)
+      lab_id = create_result[:labyrinth_id]
+
+      # Build the maze structure
+      client.add_node(labyrinth_id: lab_id, node_type: :entrance, node_id: 'start')
+      client.add_node(labyrinth_id: lab_id, node_type: :corridor, node_id: 'mid')
+      client.add_node(labyrinth_id: lab_id, node_type: :dead_end, node_id: 'dead', content: 'no way out')
+      client.add_node(labyrinth_id: lab_id, node_type: :minotaur_lair, node_id: 'lair', content: 'false dichotomy')
+      client.add_node(labyrinth_id: lab_id, node_type: :exit, node_id: 'goal')
+
+      # Wire connections
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'start', to_id: 'mid')
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'mid', to_id: 'dead', bidirectional: false)
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'mid', to_id: 'lair', bidirectional: false)
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'mid', to_id: 'goal')
+
+      # Move through the maze
+      move1 = client.move(labyrinth_id: lab_id, node_id: 'mid')
+      expect(move1[:success]).to be(true)
+      expect(move1[:solved]).to be(false)
+
+      # Check minotaur from current position (mid — safe)
+      minotaur = client.check_minotaur(labyrinth_id: lab_id)
+      expect(minotaur[:encountered]).to be(false)
+
+      # Move to exit
+      move2 = client.move(labyrinth_id: lab_id, node_id: 'goal')
+      expect(move2[:success]).to be(true)
+      expect(move2[:solved]).to be(true)
+
+      # Report
+      report = client.labyrinth_report(labyrinth_id: lab_id)
+      expect(report[:success]).to be(true)
+      expect(report[:node_count]).to eq(5)
+      expect(report[:nodes_by_type][:dead_end]).to eq(1)
+      expect(report[:nodes_by_type][:minotaur_lair]).to eq(1)
+    end
+
+    it 'follows Ariadne\'s thread through a maze' do
+      create_result = client.create_labyrinth(name: 'Thread Test')
+      lab_id = create_result[:labyrinth_id]
+
+      client.add_node(labyrinth_id: lab_id, node_type: :entrance, node_id: 'a')
+      client.add_node(labyrinth_id: lab_id, node_type: :corridor, node_id: 'b')
+      client.add_node(labyrinth_id: lab_id, node_type: :exit, node_id: 'c')
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'a', to_id: 'b')
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'b', to_id: 'c')
+
+      t1 = client.follow_thread(labyrinth_id: lab_id)
+      expect(t1[:success]).to be(true)
+      expect(t1[:node_id]).to eq('b')
+
+      t2 = client.follow_thread(labyrinth_id: lab_id)
+      expect(t2[:success]).to be(true)
+      expect(t2[:node_id]).to eq('c')
+      expect(t2[:solved]).to be(true)
+    end
+
+    it 'backtracks after a dead end' do
+      create_result = client.create_labyrinth(name: 'Backtrack Test')
+      lab_id = create_result[:labyrinth_id]
+
+      client.add_node(labyrinth_id: lab_id, node_type: :entrance, node_id: 'entry')
+      client.add_node(labyrinth_id: lab_id, node_type: :dead_end, node_id: 'dead')
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'entry', to_id: 'dead')
+
+      client.move(labyrinth_id: lab_id, node_id: 'dead')
+      back = client.backtrack(labyrinth_id: lab_id)
+      expect(back[:success]).to be(true)
+      expect(back[:node_id]).to eq('entry')
+    end
+
+    it 'detects minotaur when entering minotaur_lair' do
+      create_result = client.create_labyrinth(name: 'Lair Test')
+      lab_id = create_result[:labyrinth_id]
+
+      client.add_node(labyrinth_id: lab_id, node_type: :entrance, node_id: 'start')
+      client.add_node(labyrinth_id: lab_id, node_type: :minotaur_lair, node_id: 'lair', content: 'ad hominem')
+      client.connect_nodes(labyrinth_id: lab_id, from_id: 'start', to_id: 'lair')
+
+      move_result = client.move(labyrinth_id: lab_id, node_id: 'lair')
+      expect(move_result[:minotaur][:encountered]).to be(true)
+      expect(move_result[:minotaur][:misconception]).to eq('ad hominem')
+    end
+  end
+
+  describe '#list_labyrinths' do
+    it 'starts empty' do
+      fresh = described_class.new
+      result = fresh.list_labyrinths
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'counts created labyrinths' do
+      client.create_labyrinth(name: 'Alpha')
+      client.create_labyrinth(name: 'Beta')
+      result = client.list_labyrinths
+      expect(result[:count]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/labyrinth/cognitive_labyrinth_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth do
+  it 'has a VERSION constant' do
+    expect(described_class::VERSION).to match(/\A\d+\.\d+\.\d+\z/)
+  end
+
+  it 'exposes the Client class' do
+    expect(described_class::Client).to be_a(Class)
+  end
+
+  it 'exposes the Helpers namespace' do
+    expect(described_class::Helpers).to be_a(Module)
+  end
+
+  it 'exposes the Runners namespace' do
+    expect(described_class::Runners).to be_a(Module)
+  end
+end