lex-apollo 0.4.17 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be66d0b628a4cb32bbc6c0b1c5bb31ee780ee22891713e860caddd324b61a507
-  data.tar.gz: a6355f876338f4a13ada80c6c9757e0b278d5060e3ef1fc1c4a3ca01005d120e
+  metadata.gz: 1bf0ca8790d13fc3d262ede810ce50a47146dc37743e8806696de970b8a0385a
+  data.tar.gz: 1f1a9115e1a1bb36423150a7290a82352f07aef7aa41f0b4b7da8e0ff5b76f94
 SHA512:
-  metadata.gz: a8f20b26534a6d71c82bdbc83a1e6cd0f9f6a058d938a488ea23185063d9f0f608e13df1751ac6c9f21bba744ff55607f658d152fe9aa77ead6d874cbc357920
-  data.tar.gz: dfa3e978328c63519a850aedaa66a9a45941755e70dfd9e903498469dac0d43fc436ed76c49721fa76cfd0a22831d96376f985f0365442d6aeb0ee21df73ff0b
+  metadata.gz: 3d92269898b53825fff831ef253fc44ac9e9a45602da25628f32fc95c1e6a53edfd86add2f02f7131c449cd1b940258d2c8fc4df3b90ca6306affbf8a76d4ccb
+  data.tar.gz: d6c98fc7a7f351dc929e2d2dac4c9d7d119e32328706c9880e19a6bc3edb53448b008d8a8fefd7f7e8b8a201084f4ec78006088954cb7e56ee72cb312f0d5ce6

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.4.19] - 2026-04-24
+
+### Fixed
+- `store_knowledge` no longer rejects LLM-provided content_type values — normalizes free-form strings (`"reasoning"`, `"text"`, `"text/plain"`, `":fact"`, `"inference"`) to valid symbols via alias map with `:observation` fallback
+- `GaiaIntegration.publish_insight` now passes `:observation` instead of the domain string as content_type (was sending `"general"` or domain names which failed validation)
+- `llm_detects_conflict?` truncates content to 4000 chars before sending to LLM to prevent context overflow errors (was passing full entry content, hitting 65536-token limit)
+
+## [0.4.18] - 2026-04-24
+
+### Fixed
+- `store_knowledge`, `query_knowledge`, `related_entries` now execute directly when PostgreSQL is available instead of returning unexecuted command hashes — MCP tool calls were returning dispatch payloads (`{action: :query, ...}`) as their result, making the knowledge base unsearchable via LLM tools
+- `query_knowledge` and `retrieve_relevant` now include `candidate` status in default search filters so newly stored entries are immediately retrievable (previously only `confirmed` entries were returned)
+
+### Changed
+- Reduce `POWER_LAW_ALPHA` from 0.5 to 0.05 — decay was compounding hourly and crushing entry confidence within a day
+- Reduce `DECAY_THRESHOLD` from 0.1 to 0.05 — entries were being archived too eagerly
+- Decay cycle now operates on age in **days** instead of hours, preventing aggressive per-cycle compounding
+- Add `DECAY_MIN_AGE_HOURS` (168h / 7 days) — entries younger than this are completely exempt from decay and archival
+- `apply_decay` Ruby helper matches the new SQL behavior (days-based, minimum age guard)
+
 ## [0.4.17] - 2026-04-03
 
 ### Changed

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

@@ -15,7 +15,7 @@ module Legion
             client = Legion::Extensions::Apollo::Client.new(agent_id: agent_id)
             client.store_knowledge(
               content:      insight[:content],
-              content_type: insight[:domain] || 'general',
+              content_type: :observation,
               source_agent: agent_id,
               tags:         Array(insight[:tags])
             )

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

@@ -8,12 +8,13 @@ module Legion
           INITIAL_CONFIDENCE = 0.5
           CORROBORATION_BOOST = 0.3
           RETRIEVAL_BOOST = 0.02
-          POWER_LAW_ALPHA = 0.5
-          DECAY_THRESHOLD = 0.1
+          POWER_LAW_ALPHA = 0.05
+          DECAY_THRESHOLD = 0.05
           CORROBORATION_SIMILARITY_THRESHOLD = 0.9
           WRITE_CONFIDENCE_GATE = 0.6
           WRITE_NOVELTY_GATE = 0.3
           STALE_DAYS = 90
+          DECAY_MIN_AGE_HOURS = 168
           CONTENT_TYPES = %i[fact concept procedure association observation].freeze
           STATUSES = %w[candidate confirmed disputed decayed archived].freeze
           RELATION_TYPES = %w[is_a has_a part_of causes similar_to contradicts supersedes depends_on].freeze
@@ -41,14 +42,18 @@ module Legion
           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 corroboration_similarity_threshold
             apollo_setting(:confidence, :corroboration_similarity, default: CORROBORATION_SIMILARITY_THRESHOLD)
           end
 
           def apply_decay(confidence:, age_hours: nil, alpha: power_law_alpha, **)
+            return confidence if age_hours && age_hours < decay_min_age_hours
+
             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
+              age_days = age_hours / 24.0
+              [confidence * ((age_days.clamp(1, Float::INFINITY) + 1.0)**(-alpha)) / (age_days.clamp(1, Float::INFINITY)**(-alpha)), 0.0].max
             else
               factor = 1.0 / (1.0 + alpha)
               [confidence * factor, 0.0].max

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

@@ -14,10 +14,20 @@ module Legion
             'general'             => :all
           }.freeze
 
+          CONTENT_TYPE_ALIASES = {
+            reasoning: :concept, analysis: :concept, explanation: :concept,
+            text: :observation, general: :observation, note: :observation, summary: :observation,
+            rule: :procedure, step: :procedure, instruction: :procedure,
+            link: :association, relation: :association, connection: :association,
+            inference: :association, implication: :association
+          }.freeze
+
           def store_knowledge(content:, content_type:, tags: [], source_agent: nil, context: {}, **)
-            content_type = content_type.to_sym
-            unless Helpers::Confidence::CONTENT_TYPES.include?(content_type)
-              raise ArgumentError, "invalid content_type: #{content_type}. Must be one of #{Helpers::Confidence::CONTENT_TYPES}"
+            content_type = normalize_content_type(content_type)
+
+            if defined?(Legion::Data::Model::ApolloEntry)
+              return handle_ingest(content: content, content_type: content_type,
+                                   tags: Array(tags), source_agent: source_agent, context: context, **)
             end
 
             {
@@ -30,7 +40,12 @@ module Legion
             }
           end
 
-          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
+          def query_knowledge(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: %i[confirmed candidate], tags: nil, **) # rubocop:disable Layout/LineLength
+            if defined?(Legion::Data::Model::ApolloEntry)
+              return handle_query(query: query, limit: limit, min_confidence: min_confidence,
+                                  status: status, tags: tags, **)
+            end
+
             {
               action:         :query,
               query:          query,
@@ -42,6 +57,8 @@ module Legion
           end
 
           def related_entries(entry_id:, relation_types: nil, depth: Helpers::GraphQuery.default_depth, **)
+            return handle_traverse(entry_id: entry_id, depth: depth, relation_types: relation_types, **) if defined?(Legion::Data::Model::ApolloEntry)
+
             {
               action:         :traverse,
               entry_id:       entry_id,
@@ -235,7 +252,7 @@ module Legion
             embedding = embed_text(query)
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
-              statuses: ['confirmed'], tags: tags, domain: domain
+              statuses: %w[confirmed candidate], tags: tags, domain: domain
             )
 
             db = Legion::Data::Model::ApolloEntry.db
@@ -312,8 +329,16 @@ module Legion
             { deleted: 0, redacted: 0, error: e.message }
           end
 
+          CONFLICT_CHECK_MAX_CHARS = 4000
+
           private
 
+          def normalize_content_type(raw)
+            sym = raw.to_s.delete_prefix(':').gsub(%r{[/\s]}, '_').strip.downcase.to_sym
+            sym = CONTENT_TYPE_ALIASES.fetch(sym, sym)
+            Helpers::Confidence::CONTENT_TYPES.include?(sym) ? sym : :observation
+          end
+
           def embed_text(text)
             text = normalize_text_input(text)
             result = Legion::LLM::Embeddings.generate(text: text)
@@ -387,10 +412,12 @@ module Legion
           def llm_detects_conflict?(content_a, content_b)
             return false unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:structured)
 
+            a = content_a.to_s[0, CONFLICT_CHECK_MAX_CHARS]
+            b = content_b.to_s[0, CONFLICT_CHECK_MAX_CHARS]
             result = Legion::LLM.structured(
               messages: [
                 { role: 'system', content: 'Do these two statements contradict each other? Return JSON.' },
-                { role: 'user', content: "A: #{content_a}\n\nB: #{content_b}" }
+                { role: 'user', content: "A: #{a}\n\nB: #{b}" }
               ],
               schema:   { type: 'object', properties: { contradicts: { type: 'boolean' } } },
               caller:   { extension: 'lex-apollo', runner: 'knowledge' }

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

@@ -23,28 +23,37 @@ module Legion
           def run_decay_cycle(alpha: nil, min_confidence: nil, **)
             alpha ||= Helpers::Confidence.power_law_alpha
             min_confidence ||= Helpers::Confidence.decay_threshold
+            min_age_hours = Helpers::Confidence.decay_min_age_hours
 
             return { decayed: 0, archived: 0 } unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
 
             conn = Legion::Data.connection
 
-            hours_expr = Sequel.lit(
-              'GREATEST(EXTRACT(EPOCH FROM (NOW() - COALESCE(updated_at, created_at))) / 3600.0, 1.0)'
+            age_days_expr = Sequel.lit(
+              'GREATEST(EXTRACT(EPOCH FROM (NOW() - COALESCE(updated_at, created_at))) / 86400.0, 1.0)'
             )
             decay_factor = Sequel.lit(
-              'POWER(CAST(? AS double precision) / (CAST(? AS double precision) + 1.0), ?)', hours_expr, hours_expr, alpha
+              'POWER(CAST(? AS double precision) / (CAST(? AS double precision) + 1.0), ?)',
+              age_days_expr, age_days_expr, alpha
+            )
+
+            min_age_filter = Sequel.lit(
+              "COALESCE(updated_at, created_at) < NOW() - INTERVAL '? hours'", min_age_hours
             )
 
             decayed = conn[:apollo_entries]
                       .exclude(status: 'archived')
+                      .where(min_age_filter)
                       .update(confidence: Sequel[:confidence] * decay_factor)
 
             archived = conn[:apollo_entries]
                        .where { confidence < min_confidence }
+                       .where(min_age_filter)
                        .exclude(status: 'archived')
                        .update(status: 'archived')
 
-            { decayed: decayed, archived: archived, alpha: alpha, threshold: min_confidence }
+            { decayed: decayed, archived: archived, alpha: alpha, threshold: min_confidence,
+              min_age_hours: min_age_hours }
           rescue Sequel::Error => e
             { decayed: 0, archived: 0, error: e.message }
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.17'
+      VERSION = '0.4.19'
     end
   end
 end

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

@@ -9,6 +9,27 @@ RSpec.describe 'Apollo Contradiction Detection' do
     it 'returns false when LLM unavailable' do
       expect(knowledge.send(:llm_detects_conflict?, 'sky is blue', 'sky is red')).to be false
     end
+
+    context 'when LLM is available' do
+      let(:llm_mod) do
+        Module.new do
+          def self.respond_to?(*) = true
+          def self.structured(**) = { data: { contradicts: true } }
+        end
+      end
+
+      before { stub_const('Legion::LLM', llm_mod) }
+
+      it 'truncates content longer than CONFLICT_CHECK_MAX_CHARS' do
+        long_text = 'x' * 10_000
+        allow(llm_mod).to receive(:structured).and_return({ data: { contradicts: false } })
+        knowledge.send(:llm_detects_conflict?, long_text, long_text)
+        expect(llm_mod).to have_received(:structured) do |**kwargs|
+          user_msg = kwargs[:messages].find { |m| m[:role] == 'user' }[:content]
+          expect(user_msg.length).to be < 10_000
+        end
+      end
+    end
   end
 
   describe '#detect_contradictions' do

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

@@ -44,6 +44,20 @@ RSpec.describe Legion::Extensions::Apollo::GaiaIntegration do
       )
       expect(result).to eq({ success: true })
     end
+
+    it 'passes :observation as content_type regardless of domain' do
+      client_double = instance_double(Legion::Extensions::Apollo::Client)
+      allow(Legion::Extensions::Apollo::Client).to receive(:new).and_return(client_double)
+      allow(client_double).to receive(:store_knowledge).and_return({ success: true })
+
+      described_class.publish_insight(
+        { confidence: 0.9, novelty: 0.5, content: 'insight', domain: 'clinical' },
+        agent_id: 'test-agent'
+      )
+      expect(client_double).to have_received(:store_knowledge).with(
+        hash_including(content_type: :observation)
+      )
+    end
   end
 
   describe 'entity watchdog phase handler' do

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

@@ -18,11 +18,15 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Confidence do
     end
 
     it 'defines POWER_LAW_ALPHA' do
-      expect(described_class::POWER_LAW_ALPHA).to eq(0.5)
+      expect(described_class::POWER_LAW_ALPHA).to eq(0.05)
     end
 
     it 'defines DECAY_THRESHOLD' do
-      expect(described_class::DECAY_THRESHOLD).to eq(0.1)
+      expect(described_class::DECAY_THRESHOLD).to eq(0.05)
+    end
+
+    it 'defines DECAY_MIN_AGE_HOURS' do
+      expect(described_class::DECAY_MIN_AGE_HOURS).to eq(168)
     end
 
     it 'defines CORROBORATION_SIMILARITY_THRESHOLD' do
@@ -45,12 +49,17 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Confidence do
   describe '.apply_decay' do
     it 'applies power-law decay with default alpha when no age given' do
       result = described_class.apply_decay(confidence: 1.0)
-      expected = 1.0 / (1.0 + 0.5) # ~0.6667
+      expected = 1.0 / (1.0 + 0.05) # ~0.9524
       expect(result).to be_within(0.0001).of(expected)
     end
 
-    it 'applies age-based power-law decay when age_hours is provided' do
+    it 'skips decay when age_hours is below minimum age' do
       result = described_class.apply_decay(confidence: 1.0, age_hours: 10)
+      expect(result).to eq(1.0)
+    end
+
+    it 'applies age-based power-law decay when age_hours exceeds minimum' do
+      result = described_class.apply_decay(confidence: 1.0, age_hours: 500)
       expect(result).to be > 0.0
       expect(result).to be < 1.0
     end
@@ -98,11 +107,11 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Confidence do
 
   describe '.decayed?' do
     it 'returns true when confidence below threshold' do
-      expect(described_class.decayed?(confidence: 0.05)).to be true
+      expect(described_class.decayed?(confidence: 0.01)).to be true
     end
 
     it 'returns false when confidence at or above threshold' do
-      expect(described_class.decayed?(confidence: 0.1)).to be false
+      expect(described_class.decayed?(confidence: 0.05)).to be false
     end
   end
 

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

@@ -14,11 +14,15 @@ RSpec.describe 'Apollo Decay Cycle' do
 
   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)
+      expect(Legion::Extensions::Apollo::Helpers::Confidence.power_law_alpha).to eq(0.05)
     end
 
     it 'returns default decay threshold' do
-      expect(Legion::Extensions::Apollo::Helpers::Confidence.decay_threshold).to eq(0.1)
+      expect(Legion::Extensions::Apollo::Helpers::Confidence.decay_threshold).to eq(0.05)
+    end
+
+    it 'returns default decay minimum age hours' do
+      expect(Legion::Extensions::Apollo::Helpers::Confidence.decay_min_age_hours).to eq(168)
     end
   end
 end

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

@@ -45,10 +45,41 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       expect(result[:source_agent]).to eq('worker-1')
     end
 
-    it 'rejects invalid content_type' do
-      expect do
-        runner.store_knowledge(content: 'test', content_type: :invalid)
-      end.to raise_error(ArgumentError, /content_type/)
+    it 'falls back to :observation for unrecognized content_type' do
+      result = runner.store_knowledge(content: 'test', content_type: 'invalid_type')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'normalizes LLM-provided content_type "reasoning" to :concept' do
+      result = runner.store_knowledge(content: 'test', content_type: 'reasoning')
+      expect(result[:content_type]).to eq(:concept)
+    end
+
+    it 'normalizes "text" to :observation' do
+      result = runner.store_knowledge(content: 'test', content_type: 'text')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'normalizes "text/plain" to :observation' do
+      result = runner.store_knowledge(content: 'test', content_type: 'text/plain')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'strips leading colon from ":fact"' do
+      result = runner.store_knowledge(content: 'test', content_type: ':fact')
+      expect(result[:content_type]).to eq(:fact)
+    end
+
+    it 'normalizes "inference" to :association' do
+      result = runner.store_knowledge(content: 'test', content_type: 'inference')
+      expect(result[:content_type]).to eq(:association)
+    end
+
+    it 'accepts all valid CONTENT_TYPES unchanged' do
+      %i[fact concept procedure association observation].each do |ct|
+        result = runner.store_knowledge(content: 'test', content_type: ct)
+        expect(result[:content_type]).to eq(ct)
+      end
     end
   end
 

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

@@ -71,7 +71,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
 
       it 'returns alpha in result hash' do
         result = host.run_decay_cycle
-        expect(result[:alpha]).to eq(0.5)
+        expect(result[:alpha]).to eq(0.05)
         expect(result).not_to have_key(:rate)
       end
 

metadata

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