lex-apollo 0.4.30 → 0.4.44

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

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'legion/json'
 require_relative '../helpers/confidence'
 require_relative '../helpers/data_models'
 require_relative '../helpers/similarity'
+require_relative '../helpers/graph_query'
 
 module Legion
   module Extensions
@@ -10,15 +12,67 @@ module Legion
       module Runners
         module Maintenance
           def force_decay(factor: Legion::Extensions::Apollo.settings[:maintenance][:force_decay_factor], **)
-            { action: :force_decay, factor: factor }
+            return { action: :force_decay, factor: factor } unless Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry_available?
+            return { success: false, error: 'invalid_factor' } unless factor.is_a?(Numeric) && factor.real? && factor.finite? && factor.between?(0.0, 1.0)
+
+            decayed = Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry
+                                                                     .exclude(status: 'archived')
+                                                                     .update(confidence: Sequel[:confidence] * factor)
+            { success: true, decayed: decayed, factor: factor }
+          rescue Sequel::Error => e
+            handle_exception(e, level: :error, operation: 'apollo.maintenance.force_decay')
+            { success: false, decayed: 0, error: e.message }
           end
 
           def archive_stale(days: Helpers::Confidence.stale_days, **)
-            { action: :archive_stale, days: days }
+            return { action: :archive_stale, days: days } unless Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry_available?
+            return { success: false, error: 'invalid_days' } unless days.is_a?(Numeric) && days.real? && days.finite? && days >= 0
+
+            now = Time.now
+            cutoff = now - (days * 86_400)
+            archived = Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry
+                                                                      .exclude(status: 'archived')
+                                                                      .where(Sequel.function(:coalesce, :updated_at, :created_at) < cutoff)
+                                                                      .update(status: 'archived', updated_at: now)
+            { success: true, archived: archived, days: days }
+          rescue Sequel::Error => e
+            handle_exception(e, level: :error, operation: 'apollo.maintenance.archive_stale')
+            { success: false, archived: 0, error: e.message }
           end
 
           def resolve_dispute(entry_id:, resolution:, **)
-            { action: :resolve_dispute, entry_id: entry_id, resolution: resolution }
+            unless Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry_available?
+              return { action: :resolve_dispute, entry_id: entry_id, resolution: resolution }
+            end
+
+            target_status = case resolution.to_s
+                            when 'accept', 'keep' then 'confirmed'
+                            when 'reject' then 'archived'
+                            end
+            return { success: false, error: 'invalid_resolution', entry_id: entry_id } unless target_status
+
+            entry_model = Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry
+            entry_model.db.transaction do
+              entry = entry_model.for_update.with_pk(entry_id)
+              next({ success: false, error: 'entry_not_found', entry_id: entry_id }) unless entry
+              next({ success: false, error: 'entry_not_disputed', entry_id: entry.id, status: entry.status }) unless entry.status == 'disputed'
+
+              context = entry[:source_context]
+              context = Legion::JSON.load(context) if context.is_a?(String)
+              context ||= {}
+              raise Sequel::Error, 'invalid_source_context' unless context.respond_to?(:transform_keys)
+
+              context = context.transform_keys(&:to_sym)
+              now = Time.now
+              updates = { status: target_status, updated_at: now,
+                          source_context: Legion::JSON.dump(context.merge(dispute_resolution: resolution.to_s)) }
+              updates[:confirmed_at] = now if target_status == 'confirmed'
+              entry.update(updates)
+              { success: true, entry_id: entry.id, status: target_status, resolution: resolution }
+            end
+          rescue Sequel::Error, Legion::JSON::ParseError => e
+            handle_exception(e, level: :error, operation: 'apollo.maintenance.resolve_dispute')
+            { success: false, error: e.message, entry_id: entry_id }
           end
 
           def run_decay_cycle(alpha: nil, min_confidence: nil, **)
@@ -66,46 +120,35 @@ module Legion
             { decayed: 0, archived: 0, error: e.message }
           end
 
-          def check_corroboration(**) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-            unless Helpers::DataModels.apollo_entry_available?
-              log.warn('Apollo Maintenance.check_corroboration skipped: apollo_data_not_available')
+          def check_corroboration(**)
+            unless Helpers::DataModels.apollo_entry_available? && Helpers::DataModels.apollo_relation_available?
+              missing = []
+              missing << 'entry' unless Helpers::DataModels.apollo_entry_available?
+              missing << 'relation' unless Helpers::DataModels.apollo_relation_available?
+              log.warn("Apollo Maintenance.check_corroboration skipped: apollo_data_not_available missing=#{missing.join(',')}")
               return { success: false, error: 'apollo_data_not_available' }
             end
 
-            candidates = Helpers::DataModels.apollo_entry.where(status: 'candidate').exclude(embedding: nil).limit(100).all
-            confirmed = Helpers::DataModels.apollo_entry.where(status: 'confirmed').exclude(embedding: nil).limit(500).all
-            log.debug("Apollo Maintenance.check_corroboration candidates=#{candidates.size} confirmed=#{confirmed.size}")
+            entry_model = Helpers::DataModels.apollo_entry
+            candidates = entry_model.where(status: 'candidate').exclude(embedding: nil).order(:id).limit(100).all
+            confirmed_ids = entry_model.where(status: 'confirmed').select_map(:id)
+            log.debug("Apollo Maintenance.check_corroboration candidates=#{candidates.size} confirmed=#{confirmed_ids.size}")
 
             promoted = 0
-
-            candidates.each do |candidate|
-              match = confirmed.find do |conf|
-                next unless conf.content_type == candidate.content_type
-
-                sim = Helpers::Similarity.cosine_similarity(
-                  vec_a: candidate.embedding, vec_b: conf.embedding
-                )
-                Helpers::Similarity.above_corroboration_threshold?(similarity: sim)
-              end
-
+            candidates.each_with_index do |candidate, index|
+              match = corroboration_match_for(candidate: candidate, evidence_ids: confirmed_ids) ||
+                      bootstrap_match_for(candidate: candidate, candidates: candidates, candidate_index: index)
               next unless match
 
-              candidate_provider = candidate.respond_to?(:source_provider) ? candidate.source_provider : nil
-              match_provider     = match.respond_to?(:source_provider) ? match.source_provider : nil
-              both_known = known_provider?(candidate_provider) && known_provider?(match_provider)
-              next if both_known && candidate_provider == match_provider
-
-              candidate_channel = candidate.respond_to?(:source_channel) ? candidate.source_channel : nil
-              match_channel = match.respond_to?(:source_channel) ? match.source_channel : nil
-              next if candidate_channel && match_channel && candidate_channel == match_channel
-
-              candidate.update(
+              bootstrap = !confirmed_ids.include?(match.id)
+              updates = {
                 status:       'confirmed',
                 confirmed_at: Time.now,
                 confidence:   Helpers::Confidence.apply_corroboration_boost(confidence: candidate.confidence),
                 updated_at:   Time.now
-              )
-
+              }
+              updates[:source_context] = bootstrap_confirmation_context(candidate) if bootstrap
+              candidate.update(updates)
               Helpers::DataModels.apollo_relation.create(
                 from_entry_id: candidate.id,
                 to_entry_id:   match.id,
@@ -113,19 +156,75 @@ module Legion
                 source_agent:  'system:corroboration',
                 weight:        Legion::Extensions::Apollo.settings[:corroboration][:relation_weight]
               )
-
               promoted += 1
             end
 
             { success: true, promoted: promoted, scanned: candidates.size }
               .tap { |result| log.info("Apollo Maintenance.check_corroboration scanned=#{result[:scanned]} promoted=#{result[:promoted]}") }
-          rescue Sequel::Error => e
+          rescue Sequel::Error, Legion::JSON::ParseError => e
             handle_exception(e, level: :error, operation: 'apollo.maintenance.check_corroboration')
             { success: false, error: e.message }
           end
 
           private
 
+          def corroboration_match_for(candidate:, evidence_ids:)
+            return nil if evidence_ids.empty?
+
+            scope = candidate.access_scope || 'global'
+            return nil if scope != 'global' && candidate.identity_principal_id.nil?
+
+            evidence = Helpers::DataModels.apollo_entry
+                                          .where(id: evidence_ids, content_type: candidate.content_type,
+                                                 knowledge_domain: candidate.knowledge_domain, access_scope: scope)
+                                          .exclude(embedding: nil)
+            if scope != 'global'
+              evidence = evidence.where(
+                Sequel.lit(Legion::Extensions::Apollo::Helpers::GraphQuery.access_scope_sql,
+                           requesting_principal_id: candidate.identity_principal_id)
+              )
+            end
+
+            evidence.limit(500).find { |entry| corroborates?(candidate: candidate, entry: entry) }
+          end
+
+          def bootstrap_match_for(candidate:, candidates:, candidate_index:)
+            evidence_ids = candidates.drop(candidate_index + 1).map(&:id)
+            corroboration_match_for(candidate: candidate, evidence_ids: evidence_ids)
+          end
+
+          def corroborates?(candidate:, entry:)
+            return false if candidate.id == entry.id
+            return false if bootstrap_confirmation?(entry)
+
+            both_known = known_provider?(candidate.source_provider) && known_provider?(entry.source_provider)
+            return false if both_known && candidate.source_provider == entry.source_provider
+            return false if candidate.source_channel && candidate.source_channel == entry.source_channel
+
+            similarity = Helpers::Similarity.cosine_similarity(vec_a: candidate.embedding, vec_b: entry.embedding)
+            Helpers::Similarity.above_corroboration_threshold?(similarity: similarity)
+          end
+
+          def bootstrap_confirmation_context(entry)
+            context = entry[:source_context]
+            context = Legion::JSON.load(context) if context.is_a?(String)
+            context ||= {}
+            raise Sequel::Error, 'invalid_source_context' unless context.respond_to?(:transform_keys)
+
+            Legion::JSON.dump(context.transform_keys(&:to_sym).merge(corroboration_mode: 'bootstrap'))
+          end
+
+          def bootstrap_confirmation?(entry)
+            return false unless entry.status == 'confirmed'
+
+            context = entry[:source_context]
+            context = Legion::JSON.load(context) if context.is_a?(String)
+            context.respond_to?(:[]) && (context[:corroboration_mode] || context['corroboration_mode']) == 'bootstrap'
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :warn, operation: 'apollo.maintenance.bootstrap_confirmation')
+            true
+          end
+
           def known_provider?(provider)
             !provider.nil? && !provider.to_s.empty? && provider.to_s != 'unknown'
           end

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

@@ -8,6 +8,7 @@ module Legion
       module Runners
         module Request
           include Legion::Logging::Helper
+          include Legion::Transport::Helper if defined?(Legion::Transport::Helper)
           extend Legion::Logging::Helper
           extend self
 
@@ -76,13 +77,11 @@ module Legion
           end
 
           def transport_available?
-            Legion.const_defined?(:Transport, false) &&
-              Legion::Transport.respond_to?(:connected?) &&
-              Legion::Transport.connected?
+            defined?(Legion::Transport::Connection) && transport_session_open?
           end
 
           def publish_query(**payload)
-            Transport::Messages::Query.new(payload).publish
+            Transport::Messages::Query.new(**payload).publish
             { success: true, dispatched: :transport, payload: payload }
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.request.publish_query')
@@ -90,7 +89,7 @@ module Legion
           end
 
           def publish_ingest(**payload)
-            Transport::Messages::Ingest.new(payload).publish
+            Transport::Messages::Ingest.new(**payload).publish
             { success: true, dispatched: :transport, payload: payload }
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.request.publish_ingest')

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

@@ -5,6 +5,26 @@ module Legion
     module Apollo
       module Transport
         extend Legion::Extensions::Transport
+
+        def self.additional_e_to_q
+          [
+            { from:        Legion::Extensions::Apollo::Transport::Exchanges::Apollo,
+              to:          Legion::Extensions::Apollo::Transport::Queues::Ingest,
+              routing_key: 'legion.apollo.ingest' },
+            { from:        Legion::Extensions::Apollo::Transport::Exchanges::Apollo,
+              to:          Legion::Extensions::Apollo::Transport::Queues::QueryResponder,
+              routing_key: 'legion.apollo.query' },
+            { from:        Legion::Extensions::Apollo::Transport::Exchanges::Apollo,
+              to:          Legion::Extensions::Apollo::Transport::Queues::WritebackStore,
+              routing_key: 'legion.apollo.writeback.store' },
+            { from:        Legion::Extensions::Apollo::Transport::Exchanges::Apollo,
+              to:          Legion::Extensions::Apollo::Transport::Queues::WritebackVectorize,
+              routing_key: 'legion.apollo.writeback.vectorize' },
+            { from:        Legion::Extensions::Apollo::Transport::Exchanges::LlmAudit,
+              to:          Legion::Extensions::Apollo::Transport::Queues::GasSubscriber,
+              routing_key: 'llm.audit.complete' }
+          ]
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.30'
+      VERSION = '0.4.44'
     end
   end
 end

data/spec/legion/extensions/apollo/actors/contradiction_scanner_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+$LOADED_FEATURES << 'legion/extensions/actors/every' unless $LOADED_FEATURES.include?('legion/extensions/actors/every')
+require 'legion/extensions/apollo/actors/contradiction_scanner'
+
+RSpec.describe Legion::Extensions::Apollo::Actor::ContradictionScanner do
+  subject(:scanner) { described_class.new }
+
+  before { described_class.drain }
+  after { described_class.drain }
+
+  it 'processes queued work through the actual private detector' do
+    described_class.enqueue(entry_id: 'no-vector', embedding: nil, content: 'No vector is available.')
+
+    expect(scanner.scan_pending_contradictions).to eq(processed: 1, failed: 0)
+    expect(described_class.pending_count).to eq(0)
+  end
+
+  it 'retains a failed item, processes later work, and succeeds when the database recovers' do
+    entry_model = double('ApolloEntry')
+    stub_const('Legion::Data::Model::ApolloEntry', entry_model)
+    allow(entry_model).to receive(:db).and_raise(Sequel::Error, 'database unavailable')
+    described_class.enqueue(entry_id: 'retry-me', embedding: [1.0], content: 'Retry this item.')
+    described_class.enqueue(entry_id: 'completed', embedding: nil, content: 'This item needs no vector scan.')
+
+    expect(scanner.scan_pending_contradictions).to eq(processed: 1, failed: 1)
+    expect(described_class.pending_count).to eq(1)
+    retained = described_class.queue.pop(true)
+    expect(retained[:entry_id]).to eq('retry-me')
+    described_class.enqueue(**retained)
+
+    allow(entry_model).to receive(:db).and_return(double('database', fetch: double(all: [])))
+    expect(scanner.scan_pending_contradictions).to eq(processed: 1, failed: 0)
+    expect(described_class.pending_count).to eq(0)
+  end
+end

data/spec/legion/extensions/apollo/actors/gas_subscriber_spec.rb

@@ -13,26 +13,16 @@ unless defined?(Legion::Extensions::Actors::Subscription)
 end
 $LOADED_FEATURES << 'legion/extensions/actors/subscription' unless $LOADED_FEATURES.include?('legion/extensions/actors/subscription')
 
-require 'legion/extensions/apollo/runners/gas'
 require 'legion/extensions/apollo/actors/gas_subscriber'
 
 RSpec.describe Legion::Extensions::Apollo::Actor::GasSubscriber do
   subject(:actor) { described_class.new }
 
-  it 'uses Gas runner_class as string' do
-    expect(actor.runner_class).to eq('Legion::Extensions::Apollo::Runners::Gas')
-  end
-
-  it 'runs process function' do
-    expect(actor.runner_function).to eq('process')
-  end
-
-  it 'does not generate tasks' do
-    expect(actor.generate_task?).to be false
-  end
+  it 'dispatches an audit event through the subscription receiver contract' do
+    result = actor.runner_class.public_send(actor.runner_function, messages: [], response_content: nil)
 
-  it 'does not check subtasks' do
-    expect(actor.check_subtask?).to be false
+    expect(result).to include(phases_completed: 0)
+    expect(result).not_to have_key(:error)
   end
 
   describe '#enabled?' do

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

@@ -1,31 +1,11 @@
 # frozen_string_literal: true
 
-# Stub Sinatra before requiring api.rb so the guard `unless defined?(Sinatra)` fires.
-# This avoids a LoadError when sinatra is not in the bundle.
-unless defined?(Sinatra)
-  module Sinatra
-    class Base
-      class << self
-        def set(*, **); end
-        def before(*, &); end
-        def helpers(*, &); end
-        def get(*, &); end
-        def post(*, &); end
-        def put(*, &); end
-        def delete(*, &); end
-      end
-    end
-  end
-end
+require 'sinatra/base'
 
 require 'spec_helper'
 require 'legion/extensions/apollo/api'
 
 RSpec.describe Legion::Extensions::Apollo::Api do
-  it 'is defined as a Sinatra app' do
-    expect(described_class.superclass).to eq(Sinatra::Base)
-  end
-
   describe '.stats_payload' do
     let(:entry_model) { class_double('Legion::Data::Model::ApolloEntry') }
     let(:relation_model) { class_double('Legion::Data::Model::ApolloRelation', count: 4) }
@@ -83,6 +63,16 @@ RSpec.describe Legion::Extensions::Apollo::Api do
       )
     end
 
+    it 'keeps entry statistics available when the optional relation model is absent' do
+      hide_const('Legion::Data::Model::ApolloRelation') if defined?(Legion::Data::Model::ApolloRelation)
+      hide_const('Legion::Data::Model::Apollo::Relation') if defined?(Legion::Data::Model::Apollo::Relation)
+
+      payload = described_class.stats_payload(now: Time.utc(2026, 4, 28, 12, 0, 0))
+
+      expect(payload).to include(total_entries: 6, recent_24h: 2, avg_confidence: 0.812)
+      expect(payload).not_to have_key(:total_relations)
+    end
+
     context 'when legion-data exposes namespaced Apollo models' do
       before do
         hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry)

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

@@ -53,15 +53,6 @@ RSpec.describe 'Apollo Contradiction Detection' do
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
       end
 
-      it 'queries with ORDER BY embedding distance' do
-        allow(mock_db).to receive(:fetch).and_return(double(all: []))
-        knowledge.send(:detect_contradictions, 'uuid-1', embedding, 'test')
-        expect(mock_db).to have_received(:fetch).with(
-          a_string_including('ORDER BY embedding <=> :embedding'),
-          hash_including(:entry_id, :embedding)
-        )
-      end
-
       it 'returns empty when no similar entries found' do
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
         result = knowledge.send(:detect_contradictions, 'uuid-1', embedding, 'test')

data/spec/legion/extensions/apollo/helpers/capability_spec.rb

@@ -18,9 +18,9 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Capability do
   end
 
   describe '.can_embed?' do
-    it 'returns true when LLM is started and Ollama has a model' do
+    it 'returns true when LLM is started and SSOT has an embedding lane' do
       allow(Legion::LLM).to receive(:started?).and_return(true)
-      allow(described_class).to receive(:ollama_embedding_available?).and_return(true)
+      allow(Legion::LLM).to receive(:can_embed?).and_return(true)
       expect(described_class.can_embed?).to be true
     end
 

data/spec/legion/extensions/apollo/helpers/writeback_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Writeback do
     end
 
     it 'returns true when research tools were used' do
-      enrichments = { 'tool_calls' => [{ name: 'read_file' }] }
+      enrichments = {}
       long_response = double('Response',
                              message:    { content: 'x' * 100 },
                              model:      'claude-sonnet-4-6',
@@ -45,6 +45,34 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Writeback do
       long_response = double('Response', message: { content: 'x' * 100 }, tool_calls: [])
       expect(described_class.should_capture?(base_request, long_response, enrichments)).to be false
     end
+
+    it 'recognizes canonical research tools represented by typed objects or either hash key style' do
+      response_type = Data.define(:message, :tools)
+      tool_type = Data.define(:name)
+      tools = [{ name: 'read_file' }, { 'name' => 'search_files' },
+               tool_type.new(name: 'search_content'), tool_type.new(name: 'run_command')]
+      decisions = tools.map do |tool|
+        response = response_type.new(message: { content: 'Independent research findings. ' * 4 }, tools: [tool])
+        described_class.should_capture?(base_request, response, {})
+      end
+
+      expect(decisions).to all(be true)
+    end
+
+    it 'does not mistake a non-research canonical tool for new evidence' do
+      response = Data.define(:message, :tools).new(
+        message: { content: 'An answer based only on existing Apollo knowledge. ' * 4 },
+        tools:   [Data.define(:name).new(name: 'apollo_query')]
+      )
+
+      expect(described_class.should_capture?(base_request, response, { 'rag_context:apollo_results' => { count: 3 } })).to be false
+    end
+
+    it 'retains research evidence supplied through enrichments when the final response has no tools' do
+      response = Data.define(:message, :tools).new(message: { content: 'Completed research findings. ' * 4 }, tools: [])
+
+      expect(described_class.should_capture?(base_request, response, { 'tool_calls' => [{ 'name' => 'read_file' }] })).to be true
+    end
   end
 
   describe '.build_payload' do