lex-apollo 0.4.28 → 0.4.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d25745968940593d7d1ac3fba3f1ccd1b5d7ce553cca28c1a1fdfa4d3104af11
-  data.tar.gz: 96ecdae2a460625d95cbe0e4605f2c60778d035ea3c3f93e19d6560df0a40e70
+  metadata.gz: facad4c6e5cf4da1497d5d6de01daa13310bc8762274e227e9ff7ead72c761a6
+  data.tar.gz: 37a7098b002770c827173135a5510eeb7651f0705ef6f80ded0f8433a012bee1
 SHA512:
-  metadata.gz: c788a0ab4bd58e70ef2be2b7be88101bcccf4880fecd0ee4b8cd7a1be05cbe9b9e157c99fc7f5724a62a4d6fcdacf6278e8c902368fcc60324d966b204698b48
-  data.tar.gz: 1a51dc48ec715adc969325e82f1c7bd81e23b35f716c0ee6c3ded05a9d38eb0b57261121892658fb8715a969f7ab22f1a06664af17aa990dc0e708272229039e
+  metadata.gz: 6f45fbaf1de91fd1676d94063f6b8d34663207d0f81de84805eca6203789f6864fe48f54137a0cd73178fc7972f309dec9a3ef8bc956070ec09fd5bbac74c4e9
+  data.tar.gz: ff8f92d7ffe8f69d040d00237227c14696453abe76b3bdd90163ae2ffdc681bd0059ca119c6216a2f454f862fdd4db80196c2befa8c1e07b0c73a430fee5a06e

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.4.30] - 2026-07-31
+
+### Removed
+- **`apollo_setting` wrapper method deleted.** All 40 call sites across 10 files converted to direct bracket access against registered defaults in `default_settings`. Single source of truth for all Apollo configuration per standards section 3.
+
+### Changed
+- **Contradiction detection moved off the synchronous write path.** `handle_ingest` no longer blocks on `detect_contradictions`. When enabled, contradiction work is enqueued to the new `ContradictionScanner` interval actor (10-minute cadence, configurable via `apollo.actors.contradiction_interval`). The return payload retains a stable `contradictions: []` key.
+- New setting `apollo.contradiction.enabled` (default: `false`) controls whether contradiction detection runs at all. When false, no LLM calls or vector scans are performed for contradiction purposes.
+- Corrected CLAUDE.md backing store description from Azure to self-hosted PostgreSQL + pgvector.
+- All helpers, runners, and actors now read settings via bracket access (`settings[:namespace][:key]`) instead of the removed `apollo_setting(*keys, default:)` proxy.
+
+### Added
+- `Actor::ContradictionScanner` — interval actor that drains a thread-safe queue of pending entries and runs `detect_contradictions` out-of-band from the write path.
+- `contradiction_interval` setting under `apollo.actors` (default: 600 seconds).
+
 ## [0.4.27] - 2026-05-15
 
 ### Added

data/lib/legion/extensions/apollo/actors/contradiction_scanner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+require_relative '../runners/knowledge'
+
+module Legion
+  module Extensions
+    module Apollo
+      module Actor
+        class ContradictionScanner < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+          include Legion::Logging::Helper
+
+          @queue = Queue.new
+          @mutex = Mutex.new
+
+          class << self
+            attr_reader :queue, :mutex
+
+            def enqueue(entry_id:, embedding:, content:)
+              queue.push({ entry_id: entry_id, embedding: embedding, content: content })
+            end
+
+            def pending_count
+              queue.size
+            end
+
+            def drain
+              items = []
+              items << queue.pop until queue.empty?
+              items
+            end
+          end
+
+          def runner_class    = Legion::Extensions::Apollo::Runners::Knowledge
+          def runner_function = 'scan_pending_contradictions'
+          def time            = settings[:actors][:contradiction_interval]
+          def run_now?        = false
+          def use_runner?     = false
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def every
+            items = self.class.drain
+            return if items.empty?
+
+            log.debug("Apollo ContradictionScanner.every processing=#{items.size}")
+            runner = Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge)
+            items.each do |item|
+              runner.detect_contradictions(item[:entry_id], item[:embedding], item[:content])
+            end
+            log.info("Apollo ContradictionScanner.every completed=#{items.size}")
+          rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'apollo.actor.contradiction_scanner')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/apollo/actors/entity_watchdog.rb

@@ -89,7 +89,7 @@ module Legion
             result = retrieve_relevant(
               query:          entity[:name].to_s,
               limit:          1,
-              min_confidence: Helpers::Confidence.apollo_setting(:entity_watchdog, :exists_min_confidence, default: 0.1),
+              min_confidence: settings[:entity_watchdog][:exists_min_confidence],
               tags:           [entity[:type].to_s]
             )
             return false unless result[:success] && result[:count].positive?

data/lib/legion/extensions/apollo/helpers/confidence.rb

@@ -24,25 +24,18 @@ module Legion
 
           module_function
 
-          def apollo_setting(*keys, default:)
-            settings.dig(*keys)
-          rescue StandardError => e
-            handle_exception(e, level: :warn, operation: 'apollo.confidence.apollo_setting', keys: keys)
-            default
-          end
-
-          def initial_confidence     = apollo_setting(:confidence, :initial, default: INITIAL_CONFIDENCE)
-          def corroboration_boost    = apollo_setting(:confidence, :corroboration_boost, default: CORROBORATION_BOOST)
-          def retrieval_boost        = apollo_setting(:confidence, :retrieval_boost, default: RETRIEVAL_BOOST)
-          def power_law_alpha        = apollo_setting(:power_law_alpha, default: POWER_LAW_ALPHA)
-          def decay_threshold        = apollo_setting(:decay_threshold, default: DECAY_THRESHOLD)
-          def write_confidence_gate  = apollo_setting(:confidence, :write_gate, default: WRITE_CONFIDENCE_GATE)
-          def write_novelty_gate     = apollo_setting(:confidence, :novelty_gate, default: WRITE_NOVELTY_GATE)
-          def stale_days             = apollo_setting(:stale_days, default: STALE_DAYS)
-          def decay_min_age_hours    = apollo_setting(:decay_min_age_hours, default: DECAY_MIN_AGE_HOURS)
+          def initial_confidence     = settings[:confidence][:initial]
+          def corroboration_boost    = settings[:confidence][:corroboration_boost]
+          def retrieval_boost        = settings[:confidence][:retrieval_boost]
+          def power_law_alpha        = settings[:power_law_alpha]
+          def decay_threshold        = settings[:decay_threshold]
+          def write_confidence_gate  = settings[:confidence][:write_gate]
+          def write_novelty_gate     = settings[:confidence][:novelty_gate]
+          def stale_days             = settings[:stale_days]
+          def decay_min_age_hours    = settings[:decay_min_age_hours]
 
           def corroboration_similarity_threshold
-            apollo_setting(:confidence, :corroboration_similarity, default: CORROBORATION_SIMILARITY_THRESHOLD)
+            settings[:confidence][:corroboration_similarity]
           end
 
           def apply_decay(confidence:, age_hours: nil, alpha: power_law_alpha, **)

data/lib/legion/extensions/apollo/helpers/entity_watchdog.rb

@@ -28,7 +28,7 @@ module Legion
 
                 text.scan(pattern).each do |match|
                   entities << { type: entity_type, value: match.strip,
-confidence: Confidence.apollo_setting(:entity_watchdog, :detect_confidence, default: 0.5) }
+confidence: settings[:entity_watchdog][:detect_confidence] }
                 end
               end
 

data/lib/legion/extensions/apollo/helpers/graph_query.rb

@@ -5,18 +5,20 @@ module Legion
     module Apollo
       module Helpers
         module GraphQuery
+          extend Legion::Settings::Helper
+
           SPREAD_FACTOR = 0.6
           DEFAULT_DEPTH = 2
           MIN_ACTIVATION = 0.1
 
           module_function
 
-          def spread_factor  = Confidence.apollo_setting(:graph, :spread_factor, default: SPREAD_FACTOR)
-          def default_depth  = Confidence.apollo_setting(:graph, :default_depth, default: DEFAULT_DEPTH)
-          def min_activation = Confidence.apollo_setting(:graph, :min_activation, default: MIN_ACTIVATION)
+          def spread_factor  = settings[:graph][:spread_factor]
+          def default_depth  = settings[:graph][:default_depth]
+          def min_activation = settings[:graph][:min_activation]
 
-          def default_query_limit          = Confidence.apollo_setting(:query, :default_limit, default: 10)
-          def default_query_min_confidence = Confidence.apollo_setting(:query, :default_min_confidence, default: 0.3)
+          def default_query_limit          = settings[:query][:default_limit]
+          def default_query_min_confidence = settings[:query][:default_min_confidence]
 
           def build_traversal_sql(depth: default_depth, relation_types: nil, min_activation: self.min_activation, **)
             sf = spread_factor

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

@@ -8,7 +8,7 @@ module Legion
           DEFAULT_ENTITY_TYPES = %w[person service repository concept].freeze
           DEFAULT_MIN_CONFIDENCE = 0.7
 
-          def extract_entities(text:, entity_types: nil, min_confidence: Helpers::Confidence.apollo_setting(:entity_extractor, :min_confidence, default: DEFAULT_MIN_CONFIDENCE), **) # rubocop:disable Layout/LineLength
+          def extract_entities(text:, entity_types: nil, min_confidence: Legion::Extensions::Apollo.settings[:entity_extractor][:min_confidence], **)
             if text.to_s.strip.empty?
               log.debug('Apollo EntityExtractor.extract_entities skipped reason=empty_text')
               return { success: true, entities: [], source: :empty }

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

@@ -7,11 +7,11 @@ module Legion
     module Apollo
       module Runners
         module Expertise
-          def get_expertise(domain:, min_proficiency: Helpers::Confidence.apollo_setting(:expertise, :initial_proficiency, default: 0.0), **)
+          def get_expertise(domain:, min_proficiency: Legion::Extensions::Apollo.settings[:expertise][:initial_proficiency], **)
             { action: :expertise_query, domain: domain, min_proficiency: min_proficiency }
           end
 
-          def domains_at_risk(min_agents: Helpers::Confidence.apollo_setting(:expertise, :min_agents_at_risk, default: 2), **)
+          def domains_at_risk(min_agents: Legion::Extensions::Apollo.settings[:expertise][:min_agents_at_risk], **)
             { action: :domains_at_risk, min_agents: min_agents }
           end
 
@@ -75,7 +75,7 @@ module Legion
 
           def expertise_proficiency(confidences)
             avg = confidences.sum / confidences.size
-            cap = Helpers::Confidence.apollo_setting(:expertise, :proficiency_cap, default: 1.0)
+            cap = Legion::Extensions::Apollo.settings[:expertise][:proficiency_cap]
             [avg * Math.log2(confidences.size + 1), cap].min
           end
 

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

@@ -27,11 +27,11 @@ module Legion
             json_parse(str)
           end
 
-          def relate_confidence_gate = Helpers::Confidence.apollo_setting(:gas, :relate_confidence_gate, default: RELATE_CONFIDENCE_GATE)
-          def synthesis_confidence_cap = Helpers::Confidence.apollo_setting(:gas, :synthesis_confidence_cap, default: SYNTHESIS_CONFIDENCE_CAP)
-          def max_anticipations       = Helpers::Confidence.apollo_setting(:gas, :max_anticipations, default: MAX_ANTICIPATIONS)
-          def similar_entries_limit   = Helpers::Confidence.apollo_setting(:gas, :similar_entries_limit, default: 3)
-          def fallback_confidence     = Helpers::Confidence.apollo_setting(:gas, :fallback_confidence, default: 0.5)
+          def relate_confidence_gate = Legion::Extensions::Apollo.settings[:gas][:relate_confidence_gate]
+          def synthesis_confidence_cap = Legion::Extensions::Apollo.settings[:gas][:synthesis_confidence_cap]
+          def max_anticipations       = Legion::Extensions::Apollo.settings[:gas][:max_anticipations]
+          def similar_entries_limit   = Legion::Extensions::Apollo.settings[:gas][:similar_entries_limit]
+          def fallback_confidence     = Legion::Extensions::Apollo.settings[:gas][:fallback_confidence]
 
           def process(audit_event)
             unless processable?(audit_event)

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

@@ -132,11 +132,11 @@ module Legion
               entry_id: existing_id, agent_id: metadata[:source_agent], action: 'ingest'
             )
 
-            contradictions = detect_contradictions(existing_id, embedding, content)
-            log.debug("Apollo Knowledge.handle_ingest complete entry_id=#{existing_id} corroborated=#{corroborated} contradictions=#{contradictions.size}")
+            schedule_contradiction_detection(entry_id: existing_id, embedding: embedding, content: content)
+            log.debug("Apollo Knowledge.handle_ingest complete entry_id=#{existing_id} corroborated=#{corroborated}")
 
             { success: true, entry_id: existing_id, status: corroborated ? 'corroborated' : 'candidate',
-              corroborated: corroborated, contradictions: contradictions }
+              corroborated: corroborated, contradictions: [] }
           rescue Sequel::Error => e
             handle_exception(e, level: :error, operation: 'apollo.knowledge.handle_ingest')
             { success: false, error: e.message }
@@ -232,7 +232,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def redistribute_knowledge(agent_id:, min_confidence: Helpers::Confidence.apollo_setting(:query, :redistribute_min_confidence, default: 0.5), **)
+          def redistribute_knowledge(agent_id:, min_confidence: settings[:query][:redistribute_min_confidence], **)
             return { success: false, error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
             log.debug("Apollo Knowledge.redistribute_knowledge agent_id=#{agent_id} min_confidence=#{min_confidence}")
@@ -267,7 +267,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def retrieve_relevant(query: nil, limit: Helpers::Confidence.apollo_setting(:query, :retrieval_limit, default: 5),
+          def retrieve_relevant(query: nil, limit: settings[:query][:retrieval_limit],
                                 min_confidence: Helpers::GraphQuery.default_query_min_confidence,
                                 tags: nil, domain: nil, skip: false, requesting_principal_id: nil, **)
             return { status: :skipped } if skip
@@ -316,7 +316,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def prepare_mesh_export(target_domain:, min_confidence: Helpers::Confidence.apollo_setting(:query, :mesh_export_min_confidence, default: 0.5), limit: Helpers::Confidence.apollo_setting(:query, :mesh_export_limit, default: 100), **) # rubocop:disable Layout/LineLength
+          def prepare_mesh_export(target_domain:, min_confidence: settings[:query][:mesh_export_min_confidence], limit: settings[:query][:mesh_export_limit], **) # rubocop:disable Layout/LineLength
             unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
               return { success: false, error: 'apollo_data_not_available' }
             end
@@ -596,12 +596,28 @@ module Legion
             Array(allowed)
           end
 
+          def contradiction_detection_enabled?
+            settings[:contradiction][:enabled] == true
+          end
+
+          def schedule_contradiction_detection(entry_id:, embedding:, content:)
+            return unless contradiction_detection_enabled?
+            return unless embedding && Helpers::DataModels.apollo_entry_available?
+
+            Legion::Extensions::Apollo::Actor::ContradictionScanner.enqueue(
+              entry_id: entry_id, embedding: embedding, content: content
+            )
+            log.debug("Apollo Knowledge.schedule_contradiction_detection enqueued entry_id=#{entry_id}")
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'apollo.knowledge.schedule_contradiction_detection')
+          end
+
           def detect_contradictions(entry_id, embedding, content)
             return [] unless embedding && Helpers::DataModels.apollo_entry_available?
 
-            sim_limit = Helpers::Confidence.apollo_setting(:contradiction, :similar_limit, default: 10)
-            sim_threshold = Helpers::Confidence.apollo_setting(:contradiction, :similarity_threshold, default: 0.7)
-            rel_weight = Helpers::Confidence.apollo_setting(:contradiction, :relation_weight, default: 0.8)
+            sim_limit = settings[:contradiction][:similar_limit]
+            sim_threshold = settings[:contradiction][:similarity_threshold]
+            rel_weight = settings[:contradiction][:relation_weight]
 
             db = Helpers::DataModels.apollo_entry.db
             log.debug("Apollo Knowledge.detect_contradictions entry_id=#{entry_id} similar_limit=#{sim_limit} threshold=#{sim_threshold}")
@@ -658,7 +674,7 @@ module Legion
           def find_corroboration(embedding, content_type_sym, source_agent, source_channel = nil)
             return [false, nil] unless embedding
 
-            scan_limit = Helpers::Confidence.apollo_setting(:corroboration, :scan_limit, default: 50)
+            scan_limit = settings[:corroboration][:scan_limit]
             log.debug("Apollo Knowledge.find_corroboration content_type=#{content_type_sym} source_agent=#{source_agent} source_channel=#{source_channel || 'nil'} scan_limit=#{scan_limit}") # rubocop:disable Layout/LineLength
             existing = Helpers::DataModels.apollo_entry
                                           .where(content_type: content_type_sym)
@@ -671,7 +687,7 @@ module Legion
               sim = Helpers::Similarity.cosine_similarity(vec_a: embedding, vec_b: entry.embedding)
               next unless Helpers::Similarity.above_corroboration_threshold?(similarity: sim)
 
-              same_provider_wt = Helpers::Confidence.apollo_setting(:corroboration, :same_provider_weight, default: 0.5)
+              same_provider_wt = settings[:corroboration][:same_provider_weight]
               weight = same_source_provider?(source_agent, entry) ? same_provider_wt : 1.0
 
               # Reject corroboration entirely if same channel (same data source)
@@ -716,7 +732,7 @@ module Legion
             else
               Helpers::DataModels.apollo_expertise.create(
                 agent_id: source_agent, domain: domain,
-                proficiency: Helpers::Confidence.apollo_setting(:expertise, :initial_proficiency, default: 0.0),
+                proficiency: settings[:expertise][:initial_proficiency],
                 entry_count: 1, last_active_at: Time.now
               )
             end

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

@@ -9,7 +9,7 @@ module Legion
     module Apollo
       module Runners
         module Maintenance
-          def force_decay(factor: Helpers::Confidence.apollo_setting(:maintenance, :force_decay_factor, default: 0.5), **)
+          def force_decay(factor: Legion::Extensions::Apollo.settings[:maintenance][:force_decay_factor], **)
             { action: :force_decay, factor: factor }
           end
 
@@ -66,7 +66,7 @@ module Legion
             { decayed: 0, archived: 0, error: e.message }
           end
 
-          def check_corroboration(**) # rubocop:disable Metrics/CyclomaticComplexity
+          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')
               return { success: false, error: 'apollo_data_not_available' }
@@ -111,7 +111,7 @@ module Legion
                 to_entry_id:   match.id,
                 relation_type: 'similar_to',
                 source_agent:  'system:corroboration',
-                weight:        Helpers::Confidence.apollo_setting(:corroboration, :relation_weight, default: 1.0)
+                weight:        Legion::Extensions::Apollo.settings[:corroboration][:relation_weight]
               )
 
               promoted += 1

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

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

data/lib/legion/extensions/apollo.rb

@@ -82,6 +82,7 @@ module Legion
             force_decay_factor: 0.5
           },
           contradiction:       {
+            enabled:              false,
             similar_limit:        10,
             similarity_threshold: 0.7,
             relation_weight:      0.8
@@ -129,6 +130,7 @@ module Legion
             decay_interval:           3600,
             expertise_interval:       1800,
             corroboration_interval:   900,
+            contradiction_interval:   600,
             entity_watchdog_interval: 120
           }
         }

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

@@ -7,7 +7,7 @@ unless defined?(Legion::Extensions::Actors::Every)
     module Extensions
       module Actors
         class Every
-          def initialize(**_opts); end
+          def initialize(**); end
         end
       end
     end

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

@@ -102,7 +102,7 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Writeback do
       end
 
       it 'does not call Runners::Knowledge.handle_ingest directly' do
-        knowledge_mod = Module.new { def self.handle_ingest(**_); end }
+        knowledge_mod = Module.new { def self.handle_ingest(**); end }
         stub_const('Legion::Extensions::Apollo::Runners', Module.new)
         stub_const('Legion::Extensions::Apollo::Runners::Knowledge', knowledge_mod)
         allow(knowledge_mod).to receive(:handle_ingest)
@@ -112,7 +112,7 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Writeback do
     end
 
     context 'when Legion::Apollo is not defined' do
-      let(:knowledge_mod) { Module.new { def self.handle_ingest(**_); end } }
+      let(:knowledge_mod) { Module.new { def self.handle_ingest(**); end } }
 
       before do
         hide_const('Legion::Apollo') if defined?(Legion::Apollo)

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

@@ -42,7 +42,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::EntityExtractor do
         stub_const('Legion::LLM', Module.new do
           def self.started? = true
 
-          def self.structured(**_opts) = { data: { entities: [] } }
+          def self.structured(**) = { data: { entities: [] } }
         end)
         allow(Legion::LLM).to receive(:structured).and_return(llm_result)
       end
@@ -77,7 +77,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::EntityExtractor do
         stub_const('Legion::LLM', Module.new do
           def self.started? = true
 
-          def self.structured(**_opts) = raise(StandardError, 'timeout')
+          def self.structured(**) = raise(StandardError, 'timeout')
         end)
       end
 

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

@@ -492,6 +492,88 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         end
       end
     end
+
+    context 'contradiction detection flag' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_relation_class) { double('ApolloRelation') }
+      let(:mock_expertise_class) { double('ApolloExpertise') }
+      let(:mock_access_log_class) { double('ApolloAccessLog') }
+      let(:mock_entry) { double('entry', id: 'uuid-new', embedding: nil) }
+      let(:empty_dataset) { double('dataset', each: nil) }
+      let(:mock_db) { double('db') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
+        stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
+        stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
+        dedup_chain = double('dedup_chain')
+        allow(mock_entry_class).to receive(:where).with(content_hash: anything).and_return(dedup_chain)
+        allow(dedup_chain).to receive(:exclude).with(status: 'archived').and_return(double(first: nil))
+        allow(mock_entry_class).to receive(:db).and_return(mock_db)
+        allow(mock_db).to receive(:fetch).and_return(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)
+        allow(mock_access_log_class).to receive(:create)
+      end
+
+      it 'defaults contradiction detection to disabled' do
+        expect(Legion::Extensions::Apollo.settings[:contradiction][:enabled]).to be false
+      end
+
+      it 'does not call detect_contradictions when flag is false' do
+        expect(host).not_to receive(:detect_contradictions)
+        result = host.handle_ingest(content: 'test fact', content_type: 'fact', source_agent: 'agent-1')
+        expect(result[:success]).to be true
+        expect(result[:contradictions]).to eq([])
+      end
+
+      it 'returns stable contradictions key as empty array when disabled' do
+        result = host.handle_ingest(content: 'test content', content_type: 'fact', source_agent: 'agent-1')
+        expect(result).to have_key(:contradictions)
+        expect(result[:contradictions]).to eq([])
+      end
+
+      context 'when enabled' do
+        before do
+          Legion::Settings[:extensions][:apollo][:contradiction][:enabled] = true
+          stub_const('Legion::Extensions::Apollo::Actor::ContradictionScanner',
+                     Class.new do
+                       @queue = Queue.new
+                       class << self
+                         attr_reader :queue
+
+                         def enqueue(entry_id:, embedding:, content:)
+                           queue.push({ entry_id: entry_id, embedding: embedding, content: content })
+                         end
+
+                         def pending_count = queue.size
+
+                         def drain
+                           items = []
+                           items << queue.pop until queue.empty?
+                           items
+                         end
+                       end
+                     end)
+        end
+
+        after do
+          Legion::Settings[:extensions][:apollo][:contradiction][:enabled] = false
+        end
+
+        it 'enqueues contradiction work to the actor instead of running inline' do
+          result = host.handle_ingest(content: 'enabled test', content_type: 'fact', source_agent: 'agent-1')
+          expect(result[:success]).to be true
+          expect(result[:contradictions]).to eq([])
+          expect(Legion::Extensions::Apollo::Actor::ContradictionScanner.pending_count).to eq(1)
+        end
+      end
+    end
   end
 
   describe '#handle_query' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.28
+  version: 0.4.30
 platform: ruby
 authors:
 - Esity
@@ -160,6 +160,7 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/legion/extensions/apollo.rb
+- lib/legion/extensions/apollo/actors/contradiction_scanner.rb
 - lib/legion/extensions/apollo/actors/corroboration_checker.rb
 - lib/legion/extensions/apollo/actors/decay.rb
 - lib/legion/extensions/apollo/actors/entity_watchdog.rb