lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/situation_model/runners/situation_model_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/situation_model/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::SituationModel::Runners::SituationModel do
+  let(:client) { Legion::Extensions::Agentic::Integration::SituationModel::Client.new }
+
+  def create_model(label: 'test')
+    client.create_situation_model(label: label)
+  end
+
+  def add_event(model_id, content: 'test event', **dims)
+    defaults = { space: 0.5, time: 0.5, causation: 0.5, intentionality: 0.5, protagonist: 0.5 }
+    client.add_situation_event(model_id: model_id, content: content, **defaults.merge(dims))
+  end
+
+  describe '#create_situation_model' do
+    it 'returns success: true' do
+      result = create_model
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns a model hash with id and label' do
+      result = create_model(label: 'story')
+      expect(result[:model][:label]).to eq('story')
+      expect(result[:model][:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#add_situation_event' do
+    it 'returns success: true for known model' do
+      model_id = create_model[:model][:id]
+      result   = add_event(model_id)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns success: false for unknown model' do
+      result = add_event('nonexistent')
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to eq('model not found')
+    end
+
+    it 'returns coherence after adding event' do
+      model_id = create_model[:model][:id]
+      result   = add_event(model_id)
+      expect(result[:coherence]).to be_a(Float)
+    end
+
+    it 'accepts custom dimension values' do
+      model_id = create_model[:model][:id]
+      result   = client.add_situation_event(model_id: model_id, content: 'scene',
+                                            space: 0.9, time: 0.1,
+                                            causation: 0.5, intentionality: 0.5, protagonist: 0.5)
+      expect(result[:success]).to be(true)
+      expect(result[:event][:dimension_values][:space]).to be_within(0.001).of(0.9)
+    end
+  end
+
+  describe '#situation_model_coherence' do
+    it 'returns success: true for known model' do
+      model_id = create_model[:model][:id]
+      result   = client.situation_model_coherence(model_id: model_id)
+      expect(result[:success]).to be(true)
+      expect(result[:coherence]).to be_a(Float)
+    end
+
+    it 'returns success: false for unknown model' do
+      result = client.situation_model_coherence(model_id: 'bad')
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '#find_situation_boundaries' do
+    it 'returns success: true for known model' do
+      model_id = create_model[:model][:id]
+      add_event(model_id)
+      result = client.find_situation_boundaries(model_id: model_id)
+      expect(result[:success]).to be(true)
+      expect(result[:boundaries]).to be_an(Array)
+    end
+
+    it 'returns success: false for unknown model' do
+      result = client.find_situation_boundaries(model_id: 'bad')
+      expect(result[:success]).to be(false)
+    end
+
+    it 'uses custom threshold' do
+      model_id = create_model[:model][:id]
+      result   = client.find_situation_boundaries(model_id: model_id, threshold: 0.5)
+      expect(result[:threshold]).to eq(0.5)
+    end
+
+    it 'detects discontinuity boundary' do
+      model_id = create_model[:model][:id]
+      client.add_situation_event(model_id: model_id, content: 'high',
+                                 space: 0.9, time: 0.9, causation: 0.9, intentionality: 0.9, protagonist: 0.9)
+      client.add_situation_event(model_id: model_id, content: 'low',
+                                 space: 0.0, time: 0.0, causation: 0.0, intentionality: 0.0, protagonist: 0.0)
+      result = client.find_situation_boundaries(model_id: model_id, threshold: 0.3)
+      expect(result[:boundaries]).to include(1)
+    end
+  end
+
+  describe '#situation_dimension_trajectory' do
+    it 'returns success: true for known model and dimension' do
+      model_id = create_model[:model][:id]
+      add_event(model_id, space: 0.7)
+      result = client.situation_dimension_trajectory(model_id: model_id, dimension: :space)
+      expect(result[:success]).to be(true)
+      expect(result[:trajectory]).to be_an(Array)
+    end
+
+    it 'accepts string dimensions (converts to symbol)' do
+      model_id = create_model[:model][:id]
+      add_event(model_id)
+      result = client.situation_dimension_trajectory(model_id: model_id, dimension: 'time')
+      expect(result[:success]).to be(true)
+      expect(result[:dimension]).to eq(:time)
+    end
+
+    it 'returns success: false for unknown model' do
+      result = client.situation_dimension_trajectory(model_id: 'bad', dimension: :space)
+      expect(result[:success]).to be(false)
+    end
+
+    it 'tracks trajectory over multiple events' do
+      model_id = create_model[:model][:id]
+      client.add_situation_event(model_id: model_id, content: 'a',
+                                 space: 0.2, time: 0.5, causation: 0.5, intentionality: 0.5, protagonist: 0.5)
+      client.add_situation_event(model_id: model_id, content: 'b',
+                                 space: 0.8, time: 0.5, causation: 0.5, intentionality: 0.5, protagonist: 0.5)
+      result = client.situation_dimension_trajectory(model_id: model_id, dimension: :space)
+      expect(result[:trajectory]).to eq([0.2, 0.8])
+    end
+  end
+
+  describe '#most_coherent_situations' do
+    it 'returns success: true' do
+      result = client.most_coherent_situations
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns models array' do
+      create_model(label: 'a')
+      create_model(label: 'b')
+      result = client.most_coherent_situations(limit: 2)
+      expect(result[:models]).to be_an(Array)
+      expect(result[:count]).to be <= 2
+    end
+
+    it 'respects limit' do
+      5.times { |i| create_model(label: "m#{i}") }
+      result = client.most_coherent_situations(limit: 3)
+      expect(result[:models].size).to be <= 3
+    end
+  end
+
+  describe '#situations_by_label' do
+    it 'returns models with matching label' do
+      create_model(label: 'target')
+      create_model(label: 'target')
+      create_model(label: 'other')
+      result = client.situations_by_label(label: 'target')
+      expect(result[:success]).to be(true)
+      expect(result[:count]).to eq(2)
+      expect(result[:models].all? { |m| m[:label] == 'target' }).to be(true)
+    end
+
+    it 'returns empty for unknown label' do
+      result = client.situations_by_label(label: 'unknown')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#update_situation_models' do
+    it 'returns success: true' do
+      result = client.update_situation_models
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns pruned_count' do
+      result = client.update_situation_models
+      expect(result[:pruned_count]).to be_a(Integer)
+    end
+  end
+
+  describe '#situation_model_stats' do
+    it 'returns success: true' do
+      result = client.situation_model_stats
+      expect(result[:success]).to be(true)
+    end
+
+    it 'includes model_count' do
+      create_model
+      result = client.situation_model_stats
+      expect(result[:model_count]).to be >= 1
+    end
+
+    it 'includes models array' do
+      result = client.situation_model_stats
+      expect(result[:models]).to be_an(Array)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/synthesis/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    %i[add_stream remove_stream synthesize decay_streams check_conflict
+       dominant_stream synthesis_history average_coherence status].each do |method|
+      expect(client).to respond_to(method)
+    end
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Integration::Synthesis::Helpers::SynthesisEngine.new
+    client = described_class.new(engine: engine)
+    client.add_stream(stream_type: :emotional, content: {})
+    expect(engine.streams.size).to eq(1)
+  end
+
+  it 'creates its own engine when none injected' do
+    client = described_class.new
+    result = client.add_stream(stream_type: :emotional, content: {})
+    expect(result[:success]).to be true
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::Helpers::Constants do
+  subject(:mod) { described_class }
+
+  describe 'MAX_STREAMS' do
+    it 'is 50' do
+      expect(mod::MAX_STREAMS).to eq(50)
+    end
+  end
+
+  describe 'MAX_SYNTHESES' do
+    it 'is 200' do
+      expect(mod::MAX_SYNTHESES).to eq(200)
+    end
+  end
+
+  describe 'DEFAULT_WEIGHT' do
+    it 'is 0.5' do
+      expect(mod::DEFAULT_WEIGHT).to eq(0.5)
+    end
+  end
+
+  describe 'COHERENCE_THRESHOLD' do
+    it 'is 0.6' do
+      expect(mod::COHERENCE_THRESHOLD).to eq(0.6)
+    end
+  end
+
+  describe 'NOVELTY_THRESHOLD' do
+    it 'is 0.7' do
+      expect(mod::NOVELTY_THRESHOLD).to eq(0.7)
+    end
+  end
+
+  describe 'FRESHNESS_DECAY' do
+    it 'is 0.02' do
+      expect(mod::FRESHNESS_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'MIN_STREAMS_FOR_SYNTHESIS' do
+    it 'is 2' do
+      expect(mod::MIN_STREAMS_FOR_SYNTHESIS).to eq(2)
+    end
+  end
+
+  describe 'STREAM_TYPES' do
+    it 'includes all expected types' do
+      expect(mod::STREAM_TYPES).to include(:emotional, :perceptual, :memorial, :predictive,
+                                           :reasoning, :social, :identity, :motor)
+    end
+
+    it 'is frozen' do
+      expect(mod::STREAM_TYPES).to be_frozen
+    end
+  end
+
+  describe 'COHERENCE_LABELS' do
+    it 'maps high values to :unified' do
+      label = mod::COHERENCE_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:unified)
+    end
+
+    it 'maps low values to :chaotic' do
+      label = mod::COHERENCE_LABELS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:chaotic)
+    end
+
+    it 'maps mid values to :coherent' do
+      label = mod::COHERENCE_LABELS.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:coherent)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    it 'maps high values to :certain' do
+      label = mod::CONFIDENCE_LABELS.find { |range, _| range.cover?(0.95) }&.last
+      expect(label).to eq(:certain)
+    end
+
+    it 'maps low values to :guessing' do
+      label = mod::CONFIDENCE_LABELS.find { |range, _| range.cover?(0.05) }&.last
+      expect(label).to eq(:guessing)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/synthesis/helpers/synthesis_engine_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::Helpers::SynthesisEngine do
+  subject(:engine) { described_class.new }
+
+  def add_stream(type: :emotional, content: { value: 1 }, weight: 0.7, confidence: 0.8)
+    engine.add_stream(stream_type: type, content: content, weight: weight, confidence: confidence)
+  end
+
+  describe '#add_stream' do
+    it 'returns success with stream_id' do
+      result = add_stream
+      expect(result[:success]).to be true
+      expect(result[:stream_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores stream in @streams' do
+      add_stream
+      expect(engine.streams.size).to eq(1)
+    end
+
+    it 'rejects invalid stream_type' do
+      result = engine.add_stream(stream_type: :invalid, content: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_stream_type)
+    end
+
+    it 'accepts all valid stream types' do
+      %i[emotional perceptual memorial predictive reasoning social identity motor].each do |type|
+        result = engine.add_stream(stream_type: type, content: {})
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'prunes when exceeding MAX_STREAMS' do
+      51.times { add_stream }
+      expect(engine.streams.size).to eq(50)
+    end
+  end
+
+  describe '#remove_stream' do
+    it 'removes an existing stream' do
+      result = add_stream
+      remove = engine.remove_stream(stream_id: result[:stream_id])
+      expect(remove[:success]).to be true
+      expect(engine.streams).to be_empty
+    end
+
+    it 'returns not_found for missing stream' do
+      result = engine.remove_stream(stream_id: 'nonexistent')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#synthesize!' do
+    it 'fails with fewer than MIN_STREAMS_FOR_SYNTHESIS active streams' do
+      add_stream
+      result = engine.synthesize!
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:insufficient_streams)
+    end
+
+    it 'succeeds with enough streams' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:success]).to be true
+      expect(result[:synthesis]).to have_key(:id)
+    end
+
+    it 'stores synthesis in history' do
+      2.times { add_stream }
+      engine.synthesize!
+      expect(engine.syntheses.size).to eq(1)
+    end
+
+    it 'includes coherence in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:coherence]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes novelty in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:novelty]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes confidence in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:confidence]).to be_between(0.0, 1.0)
+    end
+
+    it 'marks first synthesis as maximally novel (no prior)' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:novelty]).to eq(1.0)
+    end
+
+    it 'caps syntheses at MAX_SYNTHESES' do
+      2.times { add_stream }
+      201.times { engine.synthesize! }
+      expect(engine.syntheses.size).to eq(200)
+    end
+
+    it 'returns content with dominant_type' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:content]).to have_key(:dominant_type)
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'returns success' do
+      result = engine.decay_all!
+      expect(result[:success]).to be true
+    end
+
+    it 'reduces freshness on all streams' do
+      add_stream
+      stream = engine.streams.values.first
+      before = stream.freshness
+      engine.decay_all!
+      expect(stream.freshness).to be < before
+    end
+
+    it 'removes stale streams' do
+      add_stream
+      stream = engine.streams.values.first
+      46.times { stream.decay_freshness! }
+      engine.decay_all!
+      expect(engine.streams).to be_empty
+    end
+
+    it 'reports removed and remaining counts' do
+      2.times { add_stream }
+      result = engine.decay_all!
+      expect(result).to have_key(:streams_removed)
+      expect(result).to have_key(:streams_remaining)
+    end
+  end
+
+  describe '#stream_conflict?' do
+    let(:id_a) { add_stream(weight: 0.9, content: { signal: :danger })[:stream_id] }
+    let(:id_b) { add_stream(weight: 0.1, content: { signal: :safe })[:stream_id] }
+
+    it 'detects weight opposition' do
+      result = engine.stream_conflict?(stream_id_a: id_a, stream_id_b: id_b)
+      expect(result[:success]).to be true
+      expect(result[:weight_opposition]).to be true
+    end
+
+    it 'detects content conflict on shared keys' do
+      result = engine.stream_conflict?(stream_id_a: id_a, stream_id_b: id_b)
+      expect(result[:content_conflict]).to be true
+    end
+
+    it 'reports no conflict for compatible streams' do
+      a = add_stream(weight: 0.6, content: { value: 1 })[:stream_id]
+      b = add_stream(weight: 0.7, content: { value: 1 })[:stream_id]
+      result = engine.stream_conflict?(stream_id_a: a, stream_id_b: b)
+      expect(result[:conflict]).to be false
+    end
+
+    it 'returns not_found for missing stream' do
+      result = engine.stream_conflict?(stream_id_a: 'x', stream_id_b: 'y')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:stream_not_found)
+    end
+  end
+
+  describe '#dominant_stream' do
+    it 'returns no_streams error when empty' do
+      result = engine.dominant_stream
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:no_streams)
+    end
+
+    it 'returns the stream with highest effective_weight' do
+      add_stream(weight: 0.3, confidence: 0.3)
+      id = add_stream(weight: 0.9, confidence: 0.95)[:stream_id]
+      result = engine.dominant_stream
+      expect(result[:success]).to be true
+      expect(result[:stream][:id]).to eq(id)
+    end
+  end
+
+  describe '#synthesis_history' do
+    it 'returns empty list when no syntheses' do
+      result = engine.synthesis_history
+      expect(result[:syntheses]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns last N syntheses' do
+      2.times { add_stream }
+      5.times { engine.synthesize! }
+      result = engine.synthesis_history(limit: 3)
+      expect(result[:count]).to eq(3)
+    end
+  end
+
+  describe '#average_coherence' do
+    it 'returns 0.0 when no syntheses' do
+      result = engine.average_coherence
+      expect(result[:average_coherence]).to eq(0.0)
+      expect(result[:sample_size]).to eq(0)
+    end
+
+    it 'computes average coherence over recent syntheses' do
+      2.times { add_stream }
+      3.times { engine.synthesize! }
+      result = engine.average_coherence
+      expect(result[:average_coherence]).to be_between(0.0, 1.0)
+      expect(result[:sample_size]).to eq(3)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats hash' do
+      add_stream(type: :emotional)
+      result = engine.to_h
+      expect(result).to include(:stream_count, :synthesis_count, :active_streams,
+                                :stale_streams, :average_coherence)
+    end
+
+    it 'reflects current stream count' do
+      3.times { add_stream }
+      expect(engine.to_h[:stream_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/synthesis/helpers/synthesis_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::Helpers::Synthesis do
+  subject(:synthesis) do
+    described_class.new(
+      streams:    %w[abc def],
+      coherence:  0.75,
+      novelty:    0.8,
+      confidence: 0.7,
+      content:    { dominant_type: :emotional, stream_count: 2 }
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(synthesis.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores stream ids' do
+      expect(synthesis.streams).to eq(%w[abc def])
+    end
+
+    it 'clamps coherence to 0-1' do
+      s = described_class.new(streams: [], coherence: 1.5, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.coherence).to eq(1.0)
+    end
+
+    it 'clamps novelty to 0-1' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: -0.5, confidence: 0.5, content: {})
+      expect(s.novelty).to eq(0.0)
+    end
+
+    it 'clamps confidence to 0-1' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: 0.5, confidence: 2.0, content: {})
+      expect(s.confidence).to eq(1.0)
+    end
+
+    it 'sets created_at as UTC time' do
+      expect(synthesis.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#fragmented?' do
+    it 'returns false when coherence >= COHERENCE_THRESHOLD' do
+      expect(synthesis.fragmented?).to be false
+    end
+
+    it 'returns true when coherence < COHERENCE_THRESHOLD' do
+      s = described_class.new(streams: [], coherence: 0.4, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.fragmented?).to be true
+    end
+  end
+
+  describe '#novel?' do
+    it 'returns true when novelty > NOVELTY_THRESHOLD' do
+      expect(synthesis.novel?).to be true
+    end
+
+    it 'returns false when novelty <= NOVELTY_THRESHOLD' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.novel?).to be false
+    end
+  end
+
+  describe '#coherence_label' do
+    it 'returns :coherent for coherence 0.75' do
+      expect(synthesis.coherence_label).to eq(:coherent)
+    end
+
+    it 'returns :unified for coherence 0.9' do
+      s = described_class.new(streams: [], coherence: 0.9, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.coherence_label).to eq(:unified)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :confident for confidence 0.7' do
+      expect(synthesis.confidence_label).to eq(:confident)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { synthesis.to_h }
+
+    it 'includes all expected keys' do
+      %i[id streams coherence novelty confidence content fragmented novel
+         coherence_label confidence_label created_at].each do |key|
+        expect(hash).to have_key(key)
+      end
+    end
+
+    it 'reflects fragmented state' do
+      s = described_class.new(streams: [], coherence: 0.3, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.to_h[:fragmented]).to be true
+    end
+
+    it 'reflects novel state' do
+      expect(hash[:novel]).to be true
+    end
+  end
+end