lex-apollo 0.4.27 → 0.4.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85cccff520bb34332f705695f5193cd55e01bb94fb680bf0a51ad81a04ec3112
-  data.tar.gz: b3370806ab160e71f3f213fb4401a6a45aa650778a29574b1cc553a9ad34d167
+  metadata.gz: facad4c6e5cf4da1497d5d6de01daa13310bc8762274e227e9ff7ead72c761a6
+  data.tar.gz: 37a7098b002770c827173135a5510eeb7651f0705ef6f80ded0f8433a012bee1
 SHA512:
-  metadata.gz: d45dd95922afbff6cf87391eca84b658359fc3b329f80cfd9404054e2e5fc7cff5b398d2b065f407ab9bff3141ba87b9f3d30e0c980e6c4625231edbf591bc18
-  data.tar.gz: 47183b00644bae505cd55c1abad707c5c86d901a38472d186bb5601eb3ec4fa0d2452715a667b3f7ebd0081d00ccb3fc3d6d6fabab61e7d146fdb2890deca7f2
+  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

@@ -85,10 +85,10 @@ module Legion
           def handle_ingest(content: nil, content_type: nil, tags: [], source_agent: 'unknown', # rubocop:disable Metrics/ParameterLists
                             source_provider: nil, source_channel: nil, knowledge_domain: nil,
                             submitted_by: nil, submitted_from: nil, content_hash: nil, context: {},
-                            skip: false, access_scope: 'global', identity_principal_id: nil,
-                            identity_id: nil, identity_canonical_name: nil, **)
+                            skip: false, access_scope: 'global', **)
             return { status: :skipped } if skip
 
+            identity = resolve_process_identity
             content = normalize_text_input(content)
             content_type = normalize_content_type(content_type.nil? ? :observation : content_type)
             log.debug("Apollo Knowledge.handle_ingest content_length=#{content.length} content_type=#{content_type} tags=#{Array(tags).size} source_agent=#{source_agent} source_channel=#{source_channel || 'nil'}") # rubocop:disable Layout/LineLength
@@ -97,7 +97,7 @@ module Legion
 
             hash = content_hash || (defined?(Helpers::Writeback) ? Helpers::Writeback.content_hash(content) : nil)
             existing = active_duplicate_for_hash(hash, access_scope:          access_scope,
-                                                       identity_principal_id: identity_principal_id)
+                                                       identity_principal_id: identity[:principal_id])
             if existing
               log.info("Apollo Knowledge.handle_ingest deduped entry_id=#{existing.id} source_agent=#{source_agent}")
               return { success: true, entry_id: existing.id, deduped: true }
@@ -109,9 +109,9 @@ module Legion
                                        source_provider: source_provider, source_channel: source_channel,
                                        submitted_by: submitted_by, submitted_from: submitted_from,
                                        access_scope: access_scope,
-                                       identity_principal_id: identity_principal_id,
-                                       identity_id: identity_id,
-                                       identity_canonical_name: identity_canonical_name)
+                                       identity_principal_id: identity[:principal_id],
+                                       identity_id: identity[:identity_id],
+                                       identity_canonical_name: identity[:canonical_name])
 
             corroborated, existing_id = find_corroboration(
               embedding, content_type_sym, metadata[:source_agent], metadata[:source_channel]
@@ -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 }
@@ -148,6 +148,7 @@ module Legion
                            requesting_principal_id: nil, **)
             return { success: false, error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
+            requesting_principal_id = resolve_requesting_principal_id(requesting_principal_id)
             entry_model = Helpers::DataModels.apollo_entry
             query = normalize_text_input(query)
             status_defaulted = status.equal?(UNSET)
@@ -231,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}")
@@ -266,13 +267,14 @@ 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
 
             return { success: false, error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
+            requesting_principal_id = resolve_requesting_principal_id(requesting_principal_id)
             query = normalize_text_input(query)
             log.debug("Apollo Knowledge.retrieve_relevant query_length=#{query.length} limit=#{limit} min_confidence=#{min_confidence} tags=#{Array(tags).size} domain=#{domain || 'nil'}") # rubocop:disable Layout/LineLength
             return { success: true, entries: [], count: 0 } if query.nil? || query.to_s.strip.empty?
@@ -314,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
@@ -594,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}")
@@ -656,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)
@@ -669,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)
@@ -714,12 +732,35 @@ 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
           end
 
+          def resolve_process_identity
+            return { principal_id: nil, identity_id: nil, canonical_name: nil } unless defined?(Legion::Identity::Process)
+
+            {
+              principal_id:   Legion::Identity::Process.db_principal_id,
+              identity_id:    Legion::Identity::Process.db_identity_id,
+              canonical_name: Legion::Identity::Process.canonical_name
+            }
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'apollo.knowledge.resolve_process_identity')
+            { principal_id: nil, identity_id: nil, canonical_name: nil }
+          end
+
+          def resolve_requesting_principal_id(explicit_value)
+            return explicit_value if explicit_value
+            return nil unless defined?(Legion::Identity::Process)
+
+            Legion::Identity::Process.db_principal_id
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'apollo.knowledge.resolve_requesting_principal_id')
+            nil
+          end
+
           include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
           include Legion::JSON::Helper
           include Legion::Settings::Helper

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.27'
+      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

@@ -371,7 +371,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       end
     end
 
-    context 'identity kwargs persistence' do
+    context 'identity from Legion::Identity::Process' do
       let(:mock_entry_class2) { double('ApolloEntry2') }
       let(:mock_expertise_class2) { double('ApolloExpertise2') }
       let(:mock_access_log_class2) { double('ApolloAccessLog2') }
@@ -390,18 +390,20 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         allow(host).to receive(:embed_text).and_return(nil)
         allow(host).to receive(:find_corroboration).and_return([false, nil])
         allow(host).to receive(:detect_contradictions).and_return([])
+        stub_const('Legion::Identity::Process', double(
+                                                  db_principal_id: 42,
+                                                  db_identity_id:  7,
+                                                  canonical_name:  'alice'
+                                                ))
       end
 
-      it 'passes identity_principal_id and access_scope through to create_candidate_entry' do
+      it 'derives identity from Legion::Identity::Process and persists it' do
         expect(mock_entry_class2).to receive(:create).with(
-          hash_including(identity_principal_id: 42, access_scope: 'private')
+          hash_including(identity_principal_id: 42, identity_id: 7, identity_canonical_name: 'alice',
+                         access_scope: 'private')
         ).and_return(mock_entry2)
 
-        host.handle_ingest(
-          content: 'test fact', tags: [],
-          identity_principal_id: 42, identity_id: 7, identity_canonical_name: 'alice',
-          access_scope: 'private'
-        )
+        host.handle_ingest(content: 'test fact', tags: [], access_scope: 'private')
       end
 
       it 'defaults access_scope to global when not provided' do
@@ -412,14 +414,14 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         host.handle_ingest(content: 'test fact', tags: [])
       end
 
-      it 'persists identity_id and identity_canonical_name' do
+      it 'ignores identity kwargs passed by callers' do
         expect(mock_entry_class2).to receive(:create).with(
-          hash_including(identity_id: 7, identity_canonical_name: 'alice')
+          hash_including(identity_principal_id: 42, identity_id: 7, identity_canonical_name: 'alice')
         ).and_return(mock_entry2)
 
         host.handle_ingest(
           content: 'test fact', tags: [],
-          identity_principal_id: 42, identity_id: 7, identity_canonical_name: 'alice',
+          identity_principal_id: 999, identity_id: 888, identity_canonical_name: 'mallory',
           access_scope: 'private'
         )
       end
@@ -490,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.27
+  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