lex-apollo 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37b431f37cdc8eb57e8a6ebdd1961a73e8259c2dff9f3cbb8c62f00d468b7355
-  data.tar.gz: ebc63f21a7076df86cc10b6e68bda68fa0bbfa661fa242eb09dddb2f7502f431
+  metadata.gz: 98c5141f161198efe7dbdd37179e46bf36ec1c58404efa645897bc256975d3f8
+  data.tar.gz: c2ac6728af5ada2ab45eb8fff0a0e80d6bceac5464305bca18bd836c81fc0ffb
 SHA512:
-  metadata.gz: 3945caccdf6763705e4f0bd9064b638a8c10920a5c802b2dfe3fde93822569af6fd70bd32097987a60a81f209ad844bc0248f92fbc096f68a30857eeee999cf6
-  data.tar.gz: cc44d3e686c933d4d662ce2c03e2ccb2a1b10a58992e354d94bd5f805d99f676abafdcca047539b22505cf35ccb85306b785e56c65f9aca19e8548a8492b8b87
+  metadata.gz: 45328d181484cabb6a17aceb9d6d1a816a623fbe1dc8f5c80972b9151a2250f244d88ba88551cf0cecac70229732546a35abe32189a2ff75a4026010279a810e
+  data.tar.gz: 1eab2286abce601fe8a95b75c0da2edb0017bebb39e09abe05a1c7dbf72658e7955147b2ab1e1b6ed743788ed61a86c4871919e7ab53762ef3e2e40906eea00f

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.4.4] - 2026-03-24
+
+### Changed
+- All ~35 hardcoded numeric thresholds, limits, intervals, and confidence values are now configurable via `Legion::Settings[:apollo]`
+- `Helpers::Confidence` gains `apollo_setting(*keys, default:)` lookup helper and accessor methods for every constant (initial_confidence, corroboration_boost, retrieval_boost, power_law_alpha, decay_threshold, write gates, stale_days)
+- `Helpers::GraphQuery` gains `spread_factor`, `default_depth`, `min_activation`, `default_query_limit`, `default_query_min_confidence` settings-aware accessors
+- `Runners::Gas` gains `relate_confidence_gate`, `synthesis_confidence_cap`, `max_anticipations`, `similar_entries_limit`, `fallback_confidence` settings-aware accessors
+- `Runners::Knowledge` method defaults (query limits, min_confidence, contradiction/corroboration params) now read from Settings
+- `Runners::Maintenance` removed duplicate private helpers, delegates to `Helpers::Confidence` methods
+- `Runners::Expertise` proficiency cap and min_agents_at_risk configurable
+- Actor intervals (Decay, ExpertiseAggregator, CorroborationChecker, EntityWatchdog) configurable via `apollo.actors.*_interval`
+- EntityWatchdog lookback_seconds, log_limit, exists_min_confidence configurable
+- EntityExtractor min_confidence configurable via `apollo.entity_extractor.min_confidence`
+- Helpers::EntityWatchdog detect_confidence configurable
+
 ## [0.4.3] - 2026-03-24
 
 ### Fixed

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

@@ -10,7 +10,7 @@ module Legion
         class CorroborationChecker < Legion::Extensions::Actors::Every
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'check_corroboration'
-          def time            = 900
+          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :corroboration_interval)) || 900
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

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

@@ -10,7 +10,7 @@ module Legion
         class Decay < Legion::Extensions::Actors::Every
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'run_decay_cycle'
-          def time            = 3600
+          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :decay_interval)) || 3600
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

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

@@ -18,7 +18,7 @@ module Legion
 
           def runner_class    = self.class
           def runner_function = 'scan_and_ingest'
-          def time            = 120
+          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :entity_watchdog_interval)) || 120
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false
@@ -62,11 +62,13 @@ module Legion
           def recent_task_log_texts
             return [] unless defined?(Legion::Data) && defined?(Legion::Data::Model::TaskLog)
 
-            cutoff = Time.now - TASK_LOG_LOOKBACK_SECONDS
+            lookback = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :lookback_seconds)) || TASK_LOG_LOOKBACK_SECONDS
+            log_limit = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :log_limit)) || TASK_LOG_LIMIT
+            cutoff = Time.now - lookback
             logs = Legion::Data::Model::TaskLog
                    .where { created_at >= cutoff }
                    .order(Sequel.desc(:created_at))
-                   .limit(TASK_LOG_LIMIT)
+                   .limit(log_limit)
                    .select_map(:message)
             logs.map(&:to_s).reject(&:empty?).uniq
           rescue StandardError
@@ -77,7 +79,7 @@ module Legion
             result = retrieve_relevant(
               query:          entity[:name].to_s,
               limit:          1,
-              min_confidence: 0.1,
+              min_confidence: Helpers::Confidence.apollo_setting(:entity_watchdog, :exists_min_confidence, default: 0.1),
               tags:           [entity[:type].to_s]
             )
             return false unless result[:success] && result[:count].positive?

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

@@ -10,7 +10,7 @@ module Legion
         class ExpertiseAggregator < Legion::Extensions::Actors::Every
           def runner_class    = Legion::Extensions::Apollo::Runners::Expertise
           def runner_function = 'aggregate'
-          def time            = 1800
+          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :expertise_interval)) || 1800
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

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

@@ -20,7 +20,28 @@ module Legion
 
           module_function
 
-          def apply_decay(confidence:, age_hours: nil, alpha: POWER_LAW_ALPHA, **)
+          def apollo_setting(*keys, default:)
+            return default unless defined?(Legion::Settings) && !Legion::Settings[:apollo].nil?
+
+            Legion::Settings[:apollo].dig(*keys) || default
+          rescue StandardError
+            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 corroboration_similarity_threshold
+            apollo_setting(:confidence, :corroboration_similarity, default: CORROBORATION_SIMILARITY_THRESHOLD)
+          end
+
+          def apply_decay(confidence:, age_hours: nil, alpha: power_law_alpha, **)
             if age_hours
               [confidence * ((age_hours.clamp(0, Float::INFINITY) + 2.0)**(-alpha)) / ((age_hours.clamp(0, Float::INFINITY) + 1.0)**(-alpha)), 0.0].max
             else
@@ -30,19 +51,19 @@ module Legion
           end
 
           def apply_retrieval_boost(confidence:, **)
-            [confidence + RETRIEVAL_BOOST, 1.0].min
+            [confidence + retrieval_boost, 1.0].min
           end
 
           def apply_corroboration_boost(confidence:, weight: 1.0, **)
-            [confidence + (CORROBORATION_BOOST * weight), 1.0].min
+            [confidence + (corroboration_boost * weight), 1.0].min
           end
 
           def decayed?(confidence:, **)
-            confidence < DECAY_THRESHOLD
+            confidence < decay_threshold
           end
 
           def meets_write_gate?(confidence:, novelty:, **)
-            confidence > WRITE_CONFIDENCE_GATE && novelty > WRITE_NOVELTY_GATE
+            confidence > write_confidence_gate && novelty > write_novelty_gate
           end
         end
       end

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

@@ -23,7 +23,7 @@ module Legion
                 next unless pattern
 
                 text.scan(pattern).each do |match|
-                  entities << { type: type_sym, value: match.strip, confidence: 0.5 }
+                  entities << { type: type_sym, value: match.strip, confidence: Confidence.apollo_setting(:entity_watchdog, :detect_confidence, default: 0.5) }
                 end
               end
 

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

@@ -11,7 +11,15 @@ module Legion
 
           module_function
 
-          def build_traversal_sql(depth: DEFAULT_DEPTH, relation_types: nil, min_activation: MIN_ACTIVATION, **)
+          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 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 build_traversal_sql(depth: default_depth, relation_types: nil, min_activation: self.min_activation, **)
+            sf = spread_factor
             type_filter = if relation_types&.any?
                             types = relation_types.map { |t| "'#{t}'" }.join(', ')
                             "AND r.relation_type IN (#{types})"
@@ -30,12 +38,12 @@ module Legion
 
                 SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
                        g.depth + 1,
-                       (g.activation * #{SPREAD_FACTOR} * r.weight)::float
+                       (g.activation * #{sf} * r.weight)::float
                 FROM graph g
                 JOIN apollo_relations r ON r.from_entry_id = g.id #{type_filter}
                 JOIN apollo_entries e ON e.id = r.to_entry_id
                 WHERE g.depth < #{depth}
-                  AND g.activation * #{SPREAD_FACTOR} * r.weight > #{min_activation}
+                  AND g.activation * #{sf} * r.weight > #{min_activation}
               )
               SELECT DISTINCT ON (id) id, content, content_type, confidence, tags, source_agent,
                      depth, activation
@@ -44,7 +52,7 @@ module Legion
             SQL
           end
 
-          def build_semantic_search_sql(limit: 10, min_confidence: 0.3, statuses: nil, tags: nil, domain: nil, **)
+          def build_semantic_search_sql(limit: default_query_limit, min_confidence: default_query_min_confidence, statuses: nil, tags: nil, domain: nil, **)
             conditions = ["e.confidence >= #{min_confidence}"]
 
             if statuses&.any?

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: DEFAULT_MIN_CONFIDENCE, **)
+          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
             return { success: true, entities: [], source: :empty } if text.to_s.strip.empty?
 
             return { success: true, entities: [], source: :unavailable } unless defined?(Legion::LLM) && Legion::LLM.started?

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

@@ -5,11 +5,11 @@ module Legion
     module Apollo
       module Runners
         module Expertise
-          def get_expertise(domain:, min_proficiency: 0.0, **)
+          def get_expertise(domain:, min_proficiency: Helpers::Confidence.apollo_setting(:expertise, :initial_proficiency, default: 0.0), **)
             { action: :expertise_query, domain: domain, min_proficiency: min_proficiency }
           end
 
-          def domains_at_risk(min_agents: 2, **)
+          def domains_at_risk(min_agents: Helpers::Confidence.apollo_setting(:expertise, :min_agents_at_risk, default: 2), **)
             { action: :domains_at_risk, min_agents: min_agents }
           end
 
@@ -40,7 +40,8 @@ module Legion
             groups.each_value do |group|
               avg = group[:confidences].sum / group[:confidences].size
               count = group[:confidences].size
-              proficiency = [avg * Math.log2(count + 1), 1.0].min
+              cap = Helpers::Confidence.apollo_setting(:expertise, :proficiency_cap, default: 1.0)
+              proficiency = [avg * Math.log2(count + 1), cap].min
 
               existing = Legion::Data::Model::ApolloExpertise
                          .where(agent_id: group[:agent_id], domain: group[:domain]).first

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

@@ -5,8 +5,23 @@ module Legion
     module Apollo
       module Runners
         module Gas
+          RELATION_TYPES = %w[
+            similar_to contradicts depends_on causes
+            part_of supersedes supports_by extends
+          ].freeze
+
+          RELATE_CONFIDENCE_GATE = 0.7
+          SYNTHESIS_CONFIDENCE_CAP = 0.7
+          MAX_ANTICIPATIONS = 3
+
           module_function
 
+          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 process(audit_event)
             return { phases_completed: 0, reason: 'no content' } unless processable?(audit_event)
 
@@ -57,13 +72,6 @@ module Legion
             []
           end
 
-          RELATION_TYPES = %w[
-            similar_to contradicts depends_on causes
-            part_of supersedes supports_by extends
-          ].freeze
-
-          RELATE_CONFIDENCE_GATE = 0.7
-
           # Phase 3: Relate - classify relationships between new and existing entries
           def phase_relate(facts, _entities)
             return [] unless defined?(Runners::Knowledge)
@@ -81,8 +89,6 @@ module Legion
             relations
           end
 
-          SYNTHESIS_CONFIDENCE_CAP = 0.7
-
           # Phase 4: Synthesize - generate derivative knowledge
           def phase_synthesize(facts, _relations)
             return [] if facts.length < 2
@@ -115,8 +121,6 @@ module Legion
             { deposited: deposited }
           end
 
-          MAX_ANTICIPATIONS = 3
-
           # Phase 6: Anticipate - pre-cache likely follow-up questions
           def phase_anticipate(facts, _synthesis)
             return [] if facts.empty?
@@ -128,9 +132,11 @@ module Legion
           end
 
           def fetch_similar_entries(facts)
+            lim = similar_entries_limit
+            min_conf = Helpers::GraphQuery.default_query_min_confidence
             entries = []
             facts.each do |fact|
-              result = Runners::Knowledge.retrieve_relevant(query: fact[:content], limit: 3, min_confidence: 0.3)
+              result = Runners::Knowledge.retrieve_relevant(query: fact[:content], limit: lim, min_confidence: min_conf)
               entries.concat(result[:entries]) if result[:success] && result[:entries]&.any?
             rescue StandardError
               next
@@ -139,13 +145,14 @@ module Legion
           end
 
           def classify_relation(fact, entry)
+            fb_conf = fallback_confidence
             if llm_available?
               llm_classify_relation(fact, entry)
             else
-              { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: 0.5 }
+              { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fb_conf }
             end
           rescue StandardError
-            { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: 0.5 }
+            { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fb_conf }
           end
 
           def llm_classify_relation(fact, entry)
@@ -190,7 +197,7 @@ module Legion
 
             conf = best[:confidence] || best['confidence'] || 0
             rtype = best[:relation_type] || best['relation_type']
-            return fallback_relation(fact, entry) if conf < RELATE_CONFIDENCE_GATE || !RELATION_TYPES.include?(rtype)
+            return fallback_relation(fact, entry) if conf < relate_confidence_gate || !RELATION_TYPES.include?(rtype)
 
             { from_content: fact[:content], to_id: entry[:id], relation_type: rtype, confidence: conf }
           rescue StandardError
@@ -198,7 +205,7 @@ module Legion
           end
 
           def fallback_relation(fact, entry)
-            { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: 0.5 }
+            { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fallback_confidence }
           end
 
           def llm_synthesize(facts)
@@ -249,13 +256,14 @@ module Legion
           def build_synthesis_entry(item, facts)
             source_indices = item[:source_indices] || item['source_indices'] || []
             source_confs = source_indices.filter_map { |i| facts[i]&.dig(:confidence) }
-            geo_mean = source_confs.empty? ? 0.5 : geometric_mean(source_confs)
+            fb = fallback_confidence
+            geo_mean = source_confs.empty? ? fb : geometric_mean(source_confs)
 
             {
               content:        item[:content] || item['content'],
               content_type:   (item[:content_type] || item['content_type'] || 'inference').to_sym,
               status:         :candidate,
-              confidence:     [geo_mean, SYNTHESIS_CONFIDENCE_CAP].min,
+              confidence:     [geo_mean, synthesis_confidence_cap].min,
               source_indices: source_indices
             }
           end
@@ -294,7 +302,7 @@ module Legion
             content = result.respond_to?(:message) ? result.message[:content] : result.to_s
             parsed = Legion::JSON.load(content)
             questions = parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
-            questions = questions.first(MAX_ANTICIPATIONS)
+            questions = questions.first(max_anticipations)
 
             questions.map do |q|
               promote_to_pattern_store(question: q, facts: facts)
@@ -310,7 +318,7 @@ module Legion
             Legion::Extensions::Agentic::TBI::PatternStore.promote_candidate(
               intent:     question,
               resolution: { source: 'gas_anticipate', facts: facts.map { |f| f[:content] } },
-              confidence: 0.5
+              confidence: fallback_confidence
             )
           rescue StandardError
             nil

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

@@ -31,7 +31,7 @@ module Legion
             }
           end
 
-          def query_knowledge(query:, limit: 10, min_confidence: 0.3, status: [:confirmed], tags: nil, **)
+          def query_knowledge(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: [:confirmed], tags: nil, **) # rubocop:disable Layout/LineLength
             {
               action:         :query,
               query:          query,
@@ -42,7 +42,7 @@ module Legion
             }
           end
 
-          def related_entries(entry_id:, relation_types: nil, depth: 2, **)
+          def related_entries(entry_id:, relation_types: nil, depth: Helpers::GraphQuery.default_depth, **)
             {
               action:         :traverse,
               entry_id:       entry_id,
@@ -73,7 +73,7 @@ module Legion
               new_entry = Legion::Data::Model::ApolloEntry.create(
                 content:          content,
                 content_type:     content_type_sym,
-                confidence:       Helpers::Confidence::INITIAL_CONFIDENCE,
+                confidence:       Helpers::Confidence.initial_confidence,
                 source_agent:     source_agent,
                 source_provider:  source_provider || derive_provider_from_agent(source_agent),
                 source_channel:   source_channel,
@@ -100,7 +100,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_query(query:, limit: 10, min_confidence: 0.3, status: [:confirmed], tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Metrics/ParameterLists
+          def handle_query(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: [:confirmed], tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
             embedding = Helpers::Embedding.generate(text: query)
@@ -140,7 +140,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def redistribute_knowledge(agent_id:, min_confidence: 0.5, **)
+          def redistribute_knowledge(agent_id:, min_confidence: Helpers::Confidence.apollo_setting(:query, :redistribute_min_confidence, default: 0.5), **)
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
             entries = Legion::Data::Model::ApolloEntry
@@ -173,7 +173,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def retrieve_relevant(query: nil, limit: 5, min_confidence: 0.3, tags: nil, domain: nil, skip: false, **) # rubocop:disable Metrics/ParameterLists
+          def retrieve_relevant(query: nil, limit: Helpers::Confidence.apollo_setting(:query, :retrieval_limit, default: 5), min_confidence: Helpers::GraphQuery.default_query_min_confidence, tags: nil, domain: nil, skip: false, **) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
             return { status: :skipped } if skip
 
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
@@ -208,7 +208,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def prepare_mesh_export(target_domain:, min_confidence: 0.5, limit: 100, **)
+          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
             unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
               return { success: false, error: 'apollo_data_not_available' }
             end
@@ -277,21 +277,25 @@ module Legion
           def detect_contradictions(entry_id, embedding, content)
             return [] unless embedding && defined?(Legion::Data::Model::ApolloEntry)
 
+            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)
+
             similar = Legion::Data::Model::ApolloEntry
                       .exclude(id: entry_id)
                       .exclude(embedding: nil)
-                      .limit(10).all
+                      .limit(sim_limit).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 sim > sim_threshold
               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
+                weight: rel_weight
               )
 
               Legion::Data::Model::ApolloEntry.where(id: [entry_id, existing.id]).update(status: 'disputed')
@@ -319,10 +323,11 @@ module Legion
           end
 
           def find_corroboration(embedding, content_type_sym, source_agent, source_channel = nil)
+            scan_limit = Helpers::Confidence.apollo_setting(:corroboration, :scan_limit, default: 50)
             existing = Legion::Data::Model::ApolloEntry
                        .where(content_type: content_type_sym)
                        .exclude(embedding: nil)
-                       .limit(50)
+                       .limit(scan_limit)
 
             existing.each do |entry|
               next unless entry.embedding
@@ -330,7 +335,8 @@ module Legion
               sim = Helpers::Similarity.cosine_similarity(vec_a: embedding, vec_b: entry.embedding)
               next unless Helpers::Similarity.above_corroboration_threshold?(similarity: sim)
 
-              weight = same_source_provider?(source_agent, entry) ? 0.5 : 1.0
+              same_provider_wt = Helpers::Confidence.apollo_setting(:corroboration, :same_provider_weight, default: 0.5)
+              weight = same_source_provider?(source_agent, entry) ? same_provider_wt : 1.0
 
               # Reject corroboration entirely if same channel (same data source)
               if source_channel && entry.respond_to?(:source_channel)
@@ -377,7 +383,8 @@ module Legion
               expertise.update(entry_count: expertise.entry_count + 1, last_active_at: Time.now)
             else
               Legion::Data::Model::ApolloExpertise.create(
-                agent_id: source_agent, domain: domain, proficiency: 0.0,
+                agent_id: source_agent, domain: domain,
+                proficiency: Helpers::Confidence.apollo_setting(:expertise, :initial_proficiency, default: 0.0),
                 entry_count: 1, last_active_at: Time.now
               )
             end

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

@@ -9,11 +9,11 @@ module Legion
     module Apollo
       module Runners
         module Maintenance
-          def force_decay(factor: 0.5, **)
+          def force_decay(factor: Helpers::Confidence.apollo_setting(:maintenance, :force_decay_factor, default: 0.5), **)
             { action: :force_decay, factor: factor }
           end
 
-          def archive_stale(days: 90, **)
+          def archive_stale(days: Helpers::Confidence.stale_days, **)
             { action: :archive_stale, days: days }
           end
 
@@ -22,17 +22,13 @@ module Legion
           end
 
           def run_decay_cycle(alpha: nil, min_confidence: nil, **)
-            alpha ||= decay_alpha
-            min_confidence ||= decay_threshold
+            alpha ||= Helpers::Confidence.power_law_alpha
+            min_confidence ||= Helpers::Confidence.decay_threshold
 
             return { decayed: 0, archived: 0 } unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
 
             conn = Legion::Data.connection
 
-            # Power-law: per-cycle decay factor decreases as entries age
-            # Factor = (hours_old / (hours_old + 1)) ^ alpha
-            # Recent entries (small hours_old) get a factor closer to 0 (more decay)
-            # Old entries (large hours_old) get a factor closer to 1 (less decay)
             hours_expr = Sequel.lit(
               'GREATEST(EXTRACT(EPOCH FROM (NOW() - COALESCE(updated_at, created_at))) / 3600.0, 1.0)'
             )
@@ -79,7 +75,6 @@ module Legion
               both_known = known_provider?(candidate_provider) && known_provider?(match_provider)
               next if both_known && candidate_provider == match_provider
 
-              # Also reject if same source_channel (same data pipeline)
               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
@@ -96,7 +91,7 @@ module Legion
                 to_entry_id:   match.id,
                 relation_type: 'similar_to',
                 source_agent:  'system:corroboration',
-                weight:        1.0
+                weight:        Helpers::Confidence.apollo_setting(:corroboration, :relation_weight, default: 1.0)
               )
 
               promoted += 1
@@ -109,19 +104,10 @@ module Legion
 
           private
 
-          def decay_alpha
-            (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :power_law_alpha)) ||
-              Helpers::Confidence::POWER_LAW_ALPHA
-          end
-
           def known_provider?(provider)
             !provider.nil? && !provider.to_s.empty? && provider.to_s != 'unknown'
           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/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.3'
+      VERSION = '0.4.4'
     end
   end
 end

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

@@ -12,15 +12,13 @@ RSpec.describe 'Apollo Decay Cycle' do
     end
   end
 
-  describe '#decay_alpha' do
-    it 'returns POWER_LAW_ALPHA when settings unavailable' do
-      expect(maintenance.send(:decay_alpha)).to eq(0.5)
+  describe 'configurable decay parameters' do
+    it 'returns POWER_LAW_ALPHA as default' do
+      expect(Legion::Extensions::Apollo::Helpers::Confidence.power_law_alpha).to eq(0.5)
     end
-  end
 
-  describe '#decay_threshold' do
-    it 'returns default threshold when settings unavailable' do
-      expect(maintenance.send(:decay_threshold)).to eq(0.1)
+    it 'returns default decay threshold' do
+      expect(Legion::Extensions::Apollo::Helpers::Confidence.decay_threshold).to eq(0.1)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Esity