lex-apollo 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcb22d66eb9b08e01ececa39900c455be2aa64f358a2976878c0b2934b71670a
-  data.tar.gz: 1d2d41cf8835c04e14827e22caaed2a848d0c8fc4c41cef3aeecc927041849b3
+  metadata.gz: 1478924cdbe16dac455d02313dd3de7b42bb0d022da411213b537f44527d14c0
+  data.tar.gz: 2e72cfa6dab1b790b1fe904ea23fe55ae093e0c6570a3b2790c8b7c0930b64cb
 SHA512:
-  metadata.gz: 6bff39d97c42ca8085b7937066e38d52c50fe302cd1d04e80d8a4aca6762eb5c28b33eb05a0ea16adf391b86bffa3d0936f3d83caf3d936d5703e8c08bd0140c
-  data.tar.gz: 694442a97667f0355bba359938c7bd9317f9d2308a6ef169a54c59bc63e097c7786625a525b33defe44581bc20593cba259ff68be019c6c55708b6ad7f31e43a
+  metadata.gz: a8aafbcf43d73647b48c27a8e400de209a723591b59b15f92f3144fd73ea4ff374a735cc4aa4720ffa48560461fe6951da231a0dc0114064f38d1f9b4cc170a6
+  data.tar.gz: d5d04a370239f53a7ab891a957ace9f52b3d9a459c93494892134a4658153cc13e629de766aaf84f4598b9b0d3c2406df316869156592e778eb46ea89848ce83

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.1] - 2026-03-17
+
+### Added
+- `Apollo::Transport` module now extends `Legion::Extensions::Transport` to provide the `build` method expected by LegionIO's `build_transport` call
+
+## [0.3.0] - 2026-03-17
+
+### Added
+- Contradiction detection: LLM-based conflict analysis during knowledge ingest via structured output
+- `detect_contradictions`: finds similar entries and checks for semantic conflicts, creates `contradicts` relations
+- `run_decay_cycle`: hourly confidence reduction with configurable rate (0.998 default) and archival threshold (0.1)
+- `GaiaIntegration.publish_insight`: auto-publish high-confidence insights from cognitive reflection phase
+- `GaiaIntegration.handle_mesh_departure`: knowledge vulnerability detection when agents leave the mesh
+
 ## [0.2.0] - 2026-03-16
 
 ### Added

data/lib/legion/extensions/apollo/gaia_integration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module GaiaIntegration
+        PUBLISH_CONFIDENCE_THRESHOLD = 0.6
+        PUBLISH_NOVELTY_THRESHOLD = 0.3
+
+        class << self
+          def publish_insight(insight, agent_id:)
+            return nil unless publishable?(insight)
+            return nil unless defined?(Legion::Extensions::Apollo::Client)
+
+            client = Legion::Extensions::Apollo::Client.new(agent_id: agent_id)
+            client.store_knowledge(
+              content:      insight[:content],
+              content_type: insight[:domain] || 'general',
+              source_agent: agent_id,
+              tags:         Array(insight[:tags])
+            )
+          end
+
+          def publishable?(insight)
+            (insight[:confidence] || 0) > PUBLISH_CONFIDENCE_THRESHOLD &&
+              (insight[:novelty] || 0) > PUBLISH_NOVELTY_THRESHOLD
+          end
+
+          def handle_mesh_departure(agent_id:)
+            return nil unless defined?(Legion::Data::Model::ApolloExpertise)
+
+            sole_expert_domains = Legion::Data::Model::ApolloExpertise
+                                  .where(agent_id: agent_id)
+                                  .all
+                                  .select { |e| sole_expert?(e.domain, agent_id) }
+                                  .map(&:domain)
+
+            return nil if sole_expert_domains.empty?
+
+            {
+              event:           'knowledge_vulnerability',
+              agent_id:        agent_id,
+              domains_at_risk: sole_expert_domains,
+              severity:        sole_expert_domains.size > 3 ? :critical : :warning
+            }
+          end
+
+          private
+
+          def sole_expert?(domain, agent_id)
+            return false unless defined?(Legion::Data::Model::ApolloExpertise)
+
+            count = Legion::Data::Model::ApolloExpertise
+                    .where(domain: domain)
+                    .exclude(agent_id: agent_id)
+                    .count
+            count.zero?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/apollo/runners/knowledge.rb

@@ -82,8 +82,10 @@ module Legion
               entry_id: existing_id, agent_id: source_agent, action: 'ingest'
             )
 
+            contradictions = detect_contradictions(existing_id, embedding, content)
+
             { success: true, entry_id: existing_id, status: corroborated ? 'corroborated' : 'candidate',
-              corroborated: corroborated }
+              corroborated: corroborated, contradictions: contradictions }
           rescue Sequel::Error => e
             { success: false, error: e.message }
           end
@@ -163,6 +165,49 @@ module Legion
 
           private
 
+          def detect_contradictions(entry_id, embedding, content)
+            return [] unless embedding && defined?(Legion::Data::Model::ApolloEntry)
+
+            similar = Legion::Data::Model::ApolloEntry
+                      .exclude(id: entry_id)
+                      .exclude(embedding: nil)
+                      .limit(10).all
+
+            contradictions = []
+            similar.each do |existing|
+              sim = Helpers::Similarity.cosine_similarity(vec_a: embedding, vec_b: existing.embedding)
+              next unless sim > 0.7
+              next unless llm_detects_conflict?(content, existing.content)
+
+              Legion::Data::Model::ApolloRelation.create(
+                from_entry_id: entry_id, to_entry_id: existing.id,
+                relation_type: 'contradicts', source_agent: 'system:contradiction',
+                weight: 0.8
+              )
+
+              Legion::Data::Model::ApolloEntry.where(id: [entry_id, existing.id]).update(status: 'disputed')
+              contradictions << existing.id
+            end
+            contradictions
+          rescue Sequel::Error
+            []
+          end
+
+          def llm_detects_conflict?(content_a, content_b)
+            return false unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:structured)
+
+            result = Legion::LLM.structured(
+              messages: [
+                { role: 'system', content: 'Do these two statements contradict each other? Return JSON.' },
+                { role: 'user', content: "A: #{content_a}\n\nB: #{content_b}" }
+              ],
+              schema:   { type: 'object', properties: { contradicts: { type: 'boolean' } } }
+            )
+            result[:data]&.dig(:contradicts) == true
+          rescue StandardError
+            false
+          end
+
           def find_corroboration(embedding, content_type_sym, source_agent)
             existing = Legion::Data::Model::ApolloEntry
                        .where(content_type: content_type_sym)

data/lib/legion/extensions/apollo/runners/maintenance.rb

@@ -21,6 +21,27 @@ module Legion
             { action: :resolve_dispute, entry_id: entry_id, resolution: resolution }
           end
 
+          def run_decay_cycle(rate: nil, min_confidence: nil, **)
+            rate ||= decay_rate
+            min_confidence ||= decay_threshold
+
+            return { decayed: 0, archived: 0 } unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
+
+            conn = Legion::Data.connection
+            decayed = conn[:apollo_entries]
+                      .exclude(status: 'archived')
+                      .update(confidence: Sequel[:confidence] * rate)
+
+            archived = conn[:apollo_entries]
+                       .where { confidence < min_confidence }
+                       .exclude(status: 'archived')
+                       .update(status: 'archived')
+
+            { decayed: decayed, archived: archived, rate: rate, threshold: min_confidence }
+          rescue Sequel::Error => e
+            { decayed: 0, archived: 0, error: e.message }
+          end
+
           def check_corroboration(**)
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
@@ -64,6 +85,16 @@ module Legion
             { success: false, error: e.message }
           end
 
+          private
+
+          def decay_rate
+            (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :decay_rate)) || 0.998
+          end
+
+          def decay_threshold
+            (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :decay_threshold)) || 0.1
+          end
+
           include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
         end
       end

data/lib/legion/extensions/apollo/transport.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Transport
+        extend Legion::Extensions::Transport
+      end
+    end
+  end
+end

data/lib/legion/extensions/apollo/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.2.0'
+      VERSION = '0.3.1'
     end
   end
 end

data/spec/legion/extensions/apollo/contradiction_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Apollo Contradiction Detection' do
+  let(:knowledge) { Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge) }
+
+  describe '#llm_detects_conflict?' do
+    it 'returns false when LLM unavailable' do
+      expect(knowledge.send(:llm_detects_conflict?, 'sky is blue', 'sky is red')).to be false
+    end
+  end
+
+  describe '#detect_contradictions' do
+    it 'returns empty when ApolloEntry model unavailable' do
+      expect(knowledge.send(:detect_contradictions, 1, nil, 'test')).to eq([])
+    end
+  end
+end

data/spec/legion/extensions/apollo/gaia_integration_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/gaia_integration'
+
+RSpec.describe Legion::Extensions::Apollo::GaiaIntegration do
+  describe '.publishable?' do
+    it 'returns true when above thresholds' do
+      expect(described_class.publishable?({ confidence: 0.8, novelty: 0.5 })).to be true
+    end
+
+    it 'returns false when below confidence' do
+      expect(described_class.publishable?({ confidence: 0.3, novelty: 0.5 })).to be false
+    end
+
+    it 'returns false when below novelty' do
+      expect(described_class.publishable?({ confidence: 0.8, novelty: 0.1 })).to be false
+    end
+
+    it 'returns false with empty hash' do
+      expect(described_class.publishable?({})).to be false
+    end
+  end
+
+  describe '.handle_mesh_departure' do
+    it 'returns nil when ApolloExpertise unavailable' do
+      expect(described_class.handle_mesh_departure(agent_id: 'test')).to be_nil
+    end
+  end
+
+  describe '.publish_insight' do
+    it 'returns nil when not publishable' do
+      expect(described_class.publish_insight({ confidence: 0.1, novelty: 0.1 }, agent_id: 'test')).to be_nil
+    end
+
+    it 'calls client when publishable and client available' do
+      client_double = instance_double(Legion::Extensions::Apollo::Client)
+      allow(Legion::Extensions::Apollo::Client).to receive(:new).and_return(client_double)
+      allow(client_double).to receive(:store_knowledge).and_return({ success: true })
+
+      result = described_class.publish_insight(
+        { confidence: 0.9, novelty: 0.5, content: 'test insight', domain: 'fact' },
+        agent_id: 'test-agent'
+      )
+      expect(result).to eq({ success: true })
+    end
+  end
+end

data/spec/legion/extensions/apollo/runners/decay_cycle_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Apollo Decay Cycle' do
+  let(:maintenance) { Object.new.extend(Legion::Extensions::Apollo::Runners::Maintenance) }
+
+  describe '#run_decay_cycle' do
+    it 'returns zeros when db unavailable' do
+      result = maintenance.run_decay_cycle
+      expect(result).to eq({ decayed: 0, archived: 0 })
+    end
+  end
+
+  describe '#decay_rate' do
+    it 'returns default rate when settings unavailable' do
+      expect(maintenance.send(:decay_rate)).to eq(0.998)
+    end
+  end
+
+  describe '#decay_threshold' do
+    it 'returns default threshold when settings unavailable' do
+      expect(maintenance.send(:decay_threshold)).to eq(0.1)
+    end
+  end
+end

data/spec/legion/extensions/apollo/runners/knowledge_spec.rb

@@ -119,6 +119,8 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
           .and_return(Array.new(1536, 0.0))
 
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
+        allow(mock_entry_class).to receive(:exclude)
+          .and_return(double(exclude: double(limit: double(all: []))))
         allow(mock_entry_class).to receive(:create).and_return(mock_entry)
         allow(mock_expertise_class).to receive(:where).and_return(double(first: nil))
         allow(mock_expertise_class).to receive(:create)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Esity
@@ -54,6 +54,7 @@ files:
 - lib/legion/extensions/apollo/actors/ingest.rb
 - lib/legion/extensions/apollo/actors/query_responder.rb
 - lib/legion/extensions/apollo/client.rb
+- lib/legion/extensions/apollo/gaia_integration.rb
 - lib/legion/extensions/apollo/helpers/confidence.rb
 - lib/legion/extensions/apollo/helpers/embedding.rb
 - lib/legion/extensions/apollo/helpers/graph_query.rb
@@ -61,6 +62,7 @@ files:
 - lib/legion/extensions/apollo/runners/expertise.rb
 - lib/legion/extensions/apollo/runners/knowledge.rb
 - lib/legion/extensions/apollo/runners/maintenance.rb
+- lib/legion/extensions/apollo/transport.rb
 - lib/legion/extensions/apollo/transport/exchanges/apollo.rb
 - lib/legion/extensions/apollo/transport/messages/ingest.rb
 - lib/legion/extensions/apollo/transport/messages/query.rb
@@ -71,10 +73,13 @@ files:
 - spec/legion/extensions/apollo/actors/expertise_aggregator_spec.rb
 - spec/legion/extensions/apollo/actors/ingest_spec.rb
 - spec/legion/extensions/apollo/client_spec.rb
+- spec/legion/extensions/apollo/contradiction_spec.rb
+- spec/legion/extensions/apollo/gaia_integration_spec.rb
 - spec/legion/extensions/apollo/helpers/confidence_spec.rb
 - spec/legion/extensions/apollo/helpers/embedding_spec.rb
 - spec/legion/extensions/apollo/helpers/graph_query_spec.rb
 - spec/legion/extensions/apollo/helpers/similarity_spec.rb
+- spec/legion/extensions/apollo/runners/decay_cycle_spec.rb
 - spec/legion/extensions/apollo/runners/expertise_spec.rb
 - spec/legion/extensions/apollo/runners/knowledge_spec.rb
 - spec/legion/extensions/apollo/runners/maintenance_spec.rb