lex-apollo 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37b431f37cdc8eb57e8a6ebdd1961a73e8259c2dff9f3cbb8c62f00d468b7355
-  data.tar.gz: ebc63f21a7076df86cc10b6e68bda68fa0bbfa661fa242eb09dddb2f7502f431
+  metadata.gz: 692cd508a98259d83ceaf2c6b752c7c87ddeb219145291bd568fa76430e41577
+  data.tar.gz: b02962423b3dff2950af8b51b0cf5035a8db72f6c2ef80c4f1e54f9f0989e25c
 SHA512:
-  metadata.gz: 3945caccdf6763705e4f0bd9064b638a8c10920a5c802b2dfe3fde93822569af6fd70bd32097987a60a81f209ad844bc0248f92fbc096f68a30857eeee999cf6
-  data.tar.gz: cc44d3e686c933d4d662ce2c03e2ccb2a1b10a58992e354d94bd5f805d99f676abafdcca047539b22505cf35ccb85306b785e56c65f9aca19e8548a8492b8b87
+  metadata.gz: 7c4989d252540ae09177a73f389a1f4d1a09c51aee09acdf88bdfbb9ffb3e5d7c6522e8cf0953117518011f199f97f1e76dacb6d88aa2f10a48ecfe1da064497
+  data.tar.gz: a806f1485d4f3ef587f2fbd015180c027934ac87b080c4e0264ccb12a478708d89d0aa313ac3c9b2f20ed3c64ec779e2468ec7b457967c7cb6c1ce780324a884

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [0.4.5] - 2026-03-25
+
+### Added
+- `handle_traverse` method in Knowledge runner: executes recursive CTE graph traversal SQL, returns formatted entries with depth and activation scores (closes #3)
+- `Runners::Request` client-tier runner with `data_required? false`: routes `query`, `retrieve`, `ingest`, `traverse` locally when DB is available or via transport when it isn't (closes #1)
+- REST API (`Api` Sinatra app) with 8 endpoints: health, query, ingest, traverse, retrieve, deprecate, expertise, stats (closes #5)
+- Conditional `require 'legion/extensions/apollo/api'` when Sinatra is available
+
+### Fixed
+- Contradiction detection now orders by embedding distance (`<=>` pgvector operator) before LIMIT, scanning the most semantically similar entries instead of arbitrary rows (closes #4)
+- Whitelisted `relation_types` in `handle_traverse` against `RELATION_TYPES` constant to prevent SQL injection
+
+### Changed
+- GAIA phase wiring updated: `knowledge_retrieval` now targets `Request#retrieve` instead of `Knowledge#retrieve_relevant` (in legion-gaia)
+
+## [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/api.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'sinatra/base' unless defined?(Sinatra)
+require 'json'
+
+module Legion
+  module Extensions
+    module Apollo
+      class Api < Sinatra::Base
+        set :host_authorization, permitted: :any
+
+        before do
+          content_type :json
+        end
+
+        helpers do
+          def json_body
+            body = request.body.read
+            return {} if body.empty?
+
+            ::JSON.parse(body, symbolize_names: true)
+          rescue ::JSON::ParserError
+            halt 400, { error: 'invalid JSON' }.to_json
+          end
+
+          def runner
+            @runner ||= begin
+              obj = Object.new
+              obj.extend(Runners::Knowledge)
+              obj
+            end
+          end
+
+          def expertise_runner
+            @expertise_runner ||= begin
+              obj = Object.new
+              obj.extend(Runners::Expertise)
+              obj
+            end
+          end
+        end
+
+        # Health check
+        get '/api/apollo/health' do
+          available = defined?(Legion::Data::Model::ApolloEntry) ? true : false
+          { status: available ? 'ok' : 'degraded', data_available: available }.to_json
+        end
+
+        # Query knowledge (semantic search)
+        post '/api/apollo/query' do
+          req = json_body
+          halt 400, { error: 'query is required' }.to_json unless req[:query]
+
+          result = runner.handle_query(
+            query:          req[:query],
+            limit:          req[:limit] || 10,
+            min_confidence: req[:min_confidence] || 0.3,
+            status:         req[:status] || [:confirmed],
+            tags:           req[:tags],
+            domain:         req[:domain],
+            agent_id:       req[:agent_id] || 'api'
+          )
+          status result[:success] ? 200 : 500
+          result.to_json
+        end
+
+        # Ingest knowledge
+        post '/api/apollo/ingest' do
+          req = json_body
+          halt 400, { error: 'content is required' }.to_json unless req[:content]
+          halt 400, { error: 'content_type is required' }.to_json unless req[:content_type]
+
+          result = runner.handle_ingest(
+            content:          req[:content],
+            content_type:     req[:content_type],
+            tags:             req[:tags] || [],
+            source_agent:     req[:source_agent] || 'api',
+            source_provider:  req[:source_provider],
+            source_channel:   req[:source_channel],
+            knowledge_domain: req[:knowledge_domain],
+            context:          req[:context] || {}
+          )
+          status result[:success] ? 201 : 500
+          result.to_json
+        end
+
+        # Graph traversal
+        post '/api/apollo/traverse' do
+          req = json_body
+          halt 400, { error: 'entry_id is required' }.to_json unless req[:entry_id]
+
+          result = runner.handle_traverse(
+            entry_id:       req[:entry_id],
+            depth:          req[:depth] || 2,
+            relation_types: req[:relation_types],
+            agent_id:       req[:agent_id] || 'api'
+          )
+          status result[:success] ? 200 : 500
+          result.to_json
+        end
+
+        # Retrieve relevant (GAIA-compatible)
+        post '/api/apollo/retrieve' do
+          req = json_body
+          halt 400, { error: 'query is required' }.to_json unless req[:query]
+
+          result = runner.retrieve_relevant(
+            query:          req[:query],
+            limit:          req[:limit] || 5,
+            min_confidence: req[:min_confidence] || 0.3,
+            tags:           req[:tags],
+            domain:         req[:domain]
+          )
+          status result[:success] ? 200 : 500
+          result.to_json
+        end
+
+        # Deprecate entry
+        post '/api/apollo/entries/:id/deprecate' do
+          result = runner.deprecate_entry(
+            entry_id: params[:id],
+            reason:   json_body[:reason] || 'deprecated via API'
+          )
+          result.to_json
+        end
+
+        # Domains at risk — must be declared before /:agent_id to avoid routing conflict
+        get '/api/apollo/expertise/at-risk' do
+          result = expertise_runner.domains_at_risk
+          result.to_json
+        end
+
+        # Expertise for an agent
+        get '/api/apollo/expertise/:agent_id' do
+          result = expertise_runner.agent_profile(agent_id: params[:agent_id])
+          result.to_json
+        end
+
+        # Statistics
+        get '/api/apollo/stats' do
+          stats = {}
+          if defined?(Legion::Data::Model::ApolloEntry)
+            stats[:total_entries] = Legion::Data::Model::ApolloEntry.count
+            stats[:by_status]     = Legion::Data::Model::ApolloEntry.group_and_count(:status).all
+                                                                    .to_h { |r| [r[:status], r[:count]] }
+            stats[:by_content_type] = Legion::Data::Model::ApolloEntry.group_and_count(:content_type).all
+                                                                      .to_h { |r| [r[:content_type], r[:count]] }
+            stats[:total_relations] = Legion::Data::Model::ApolloRelation.count if defined?(Legion::Data::Model::ApolloRelation)
+          else
+            stats[:error] = 'apollo_data_not_available'
+          end
+          stats.to_json
+        end
+      end
+    end
+  end
+end

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