lex-apollo 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7d785a9fed9656eb22b307620a384f64e52646bca14728dc0de3ef2b1adb5bd
-  data.tar.gz: c64bcf1b75ee0ed43a747722a610c5cee8de823995d5f7455e31ae5c9174c56d
+  metadata.gz: 98960e6e7d1261ea36708f77b302dfa5011a3f7ea5ce4a1db66198887656fd4e
+  data.tar.gz: 9263a29e03175cfcdf7431138d05ec4bb362f29113ccb4f9d5d35e1f28d0fe85
 SHA512:
-  metadata.gz: 0ff89d33e4993dd8c71e392202c66add619ab04045fa674b5f8f0c4d891b727ca7401865d349c68bdc3a0344e1773db4f86651ed7e96ecbcaf0098a9d05cdbc9
-  data.tar.gz: 29b69744b9870bee8e1fbfc030652aede63a51c3a12cd02a3bc69bfc805b6267cf8045346cb37dc2565e1e103ae6f3b559972536b02f3a62dd4b6f12223361a5
+  metadata.gz: d99ea64a8ead8d08d4915607fc31d999f2000d5934c0519428c6a6eea6e4c13d9981050472e5ebbbdcd9771ab796a85f608e0c0d6b1949d28bece52f26c7a963
+  data.tar.gz: 884ec51ff3eb5850ae19a68c3eec31f6931bfccc9283a93c705cd4ba771faf1c1db2136958e4628b54f563ba7dfc6d19e79807176f39da28995181678c19ce52

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.3.6] - 2026-03-21
+
+### Added
+- Time-aware power-law decay in batch cycle (alpha=0.5 per Murre & Dros 2015)
+- Source channel diversity enforcement in corroboration paths
+- Right-to-erasure propagation via handle_erasure_request
+- Knowledge domain namespaces with query filtering
+- Domain-aware mesh propagation filtering (prepare_mesh_export)
+
+### Changed
+- POWER_LAW_ALPHA updated from 0.1 to 0.5
+- run_decay_cycle uses time-aware SQL instead of flat multiplier
+
 ## [0.3.4] - 2026-03-20
 
 ### Added

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

@@ -8,7 +8,7 @@ module Legion
           INITIAL_CONFIDENCE = 0.5
           CORROBORATION_BOOST = 0.3
           RETRIEVAL_BOOST = 0.02
-          POWER_LAW_ALPHA = 0.1
+          POWER_LAW_ALPHA = 0.5
           DECAY_THRESHOLD = 0.1
           CORROBORATION_SIMILARITY_THRESHOLD = 0.9
           WRITE_CONFIDENCE_GATE = 0.6

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

@@ -44,7 +44,7 @@ module Legion
             SQL
           end
 
-          def build_semantic_search_sql(limit: 10, min_confidence: 0.3, statuses: nil, tags: nil, **)
+          def build_semantic_search_sql(limit: 10, min_confidence: 0.3, statuses: nil, tags: nil, domain: nil, **)
             conditions = ["e.confidence >= #{min_confidence}"]
 
             if statuses&.any?
@@ -57,11 +57,13 @@ module Legion
               conditions << "e.tags && ARRAY[#{tag_list}]::text[]"
             end
 
+            conditions << "e.knowledge_domain = '#{domain}'" if domain
+
             where_clause = conditions.join(' AND ')
 
             <<~SQL
               SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
-                     e.access_count, e.created_at,
+                     e.access_count, e.created_at, e.knowledge_domain,
                      (e.embedding <=> $embedding) AS distance
               FROM apollo_entries e
               WHERE #{where_clause}

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

@@ -9,6 +9,12 @@ module Legion
     module Apollo
       module Runners
         module Knowledge
+          DOMAIN_ISOLATION = {
+            'claims_optimization' => ['claims_optimization'],
+            'clinical_care'       => %w[clinical_care general],
+            'general'             => :all
+          }.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)
@@ -53,31 +59,34 @@ module Legion
             }
           end
 
-          def handle_ingest(content:, content_type:, tags: [], source_agent: 'unknown', source_provider: nil, context: {}, **) # rubocop:disable Metrics/ParameterLists
+          def handle_ingest(content:, content_type:, tags: [], source_agent: 'unknown', source_provider: nil, source_channel: nil, knowledge_domain: nil, context: {}, **) # 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: content)
             content_type_sym = content_type.to_s
             tag_array = Array(tags)
+            domain = knowledge_domain || tag_array.first || 'general'
 
-            corroborated, existing_id = find_corroboration(embedding, content_type_sym, source_agent)
+            corroborated, existing_id = find_corroboration(embedding, content_type_sym, source_agent, source_channel)
 
             unless corroborated
               new_entry = Legion::Data::Model::ApolloEntry.create(
-                content:         content,
-                content_type:    content_type_sym,
-                confidence:      Helpers::Confidence::INITIAL_CONFIDENCE,
-                source_agent:    source_agent,
-                source_provider: source_provider || derive_provider_from_agent(source_agent),
-                source_context:  ::JSON.dump(context.is_a?(Hash) ? context : {}),
-                tags:            Sequel.pg_array(tag_array),
-                status:          'candidate',
-                embedding:       Sequel.lit("'[#{embedding.join(',')}]'::vector")
+                content:          content,
+                content_type:     content_type_sym,
+                confidence:       Helpers::Confidence::INITIAL_CONFIDENCE,
+                source_agent:     source_agent,
+                source_provider:  source_provider || derive_provider_from_agent(source_agent),
+                source_channel:   source_channel,
+                source_context:   ::JSON.dump(context.is_a?(Hash) ? context : {}),
+                tags:             Sequel.pg_array(tag_array),
+                status:           'candidate',
+                knowledge_domain: domain,
+                embedding:        Sequel.lit("'[#{embedding.join(',')}]'::vector")
               )
               existing_id = new_entry.id
             end
 
-            upsert_expertise(source_agent: source_agent, domain: tag_array.first || 'general')
+            upsert_expertise(source_agent: source_agent, domain: domain)
 
             Legion::Data::Model::ApolloAccessLog.create(
               entry_id: existing_id, agent_id: source_agent, action: 'ingest'
@@ -91,13 +100,13 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_query(query:, limit: 10, min_confidence: 0.3, status: [:confirmed], tags: nil, agent_id: 'unknown', **) # rubocop:disable Metrics/ParameterLists
+          def handle_query(query:, limit: 10, min_confidence: 0.3, status: [:confirmed], tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Metrics/ParameterLists
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
             embedding = Helpers::Embedding.generate(text: query)
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
-              statuses: Array(status).map(&:to_s), tags: tags
+              statuses: Array(status).map(&:to_s), tags: tags, domain: domain
             )
 
             db = Legion::Data::Model::ApolloEntry.db
@@ -122,7 +131,8 @@ module Legion
             formatted = entries.map do |entry|
               { id: entry[:id], content: entry[:content], content_type: entry[:content_type],
                 confidence: entry[:confidence], distance: entry[:distance],
-                tags: entry[:tags], source_agent: entry[:source_agent] }
+                tags: entry[:tags], source_agent: entry[:source_agent],
+                knowledge_domain: entry[:knowledge_domain] }
             end
 
             { success: true, entries: formatted, count: formatted.size }
@@ -130,7 +140,40 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def retrieve_relevant(query: nil, limit: 5, min_confidence: 0.3, tags: nil, skip: false, **)
+          def redistribute_knowledge(agent_id:, min_confidence: 0.5, **)
+            return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
+
+            entries = Legion::Data::Model::ApolloEntry
+                      .where(source_agent: agent_id, status: 'confirmed')
+                      .where { confidence > min_confidence }
+                      .all
+
+            return { success: true, redistributed: 0 } if entries.empty?
+
+            store = (Legion::Extensions::Agentic::Memory::Trace.shared_store if defined?(Legion::Extensions::Agentic::Memory::Trace))
+
+            redistributed = 0
+            entries.each do |entry|
+              if store
+                trace = Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace.new_trace(
+                  type:            :semantic,
+                  content_payload: { content: entry.content, source_agent: agent_id,
+                                     content_type: entry.content_type, tags: Array(entry.tags) },
+                  strength:        entry.confidence.to_f,
+                  domain_tag:      Array(entry.tags).first || 'general'
+                )
+                store.store(trace)
+              end
+              redistributed += 1
+            end
+
+            Legion::Logging.info "[apollo] redistributed #{redistributed} entries from departing agent=#{agent_id}"
+            { success: true, redistributed: redistributed, agent_id: agent_id }
+          rescue Sequel::Error => e
+            { 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
             return { status: :skipped } if skip
 
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
@@ -140,7 +183,7 @@ module Legion
             embedding = Helpers::Embedding.generate(text: query.to_s)
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
-              statuses: ['confirmed'], tags: tags
+              statuses: ['confirmed'], tags: tags, domain: domain
             )
 
             db = Legion::Data::Model::ApolloEntry.db
@@ -156,7 +199,8 @@ module Legion
             formatted = entries.map do |entry|
               { id: entry[:id], content: entry[:content], content_type: entry[:content_type],
                 confidence: entry[:confidence], distance: entry[:distance],
-                tags: entry[:tags], source_agent: entry[:source_agent] }
+                tags: entry[:tags], source_agent: entry[:source_agent],
+                knowledge_domain: entry[:knowledge_domain] }
             end
 
             { success: true, entries: formatted, count: formatted.size }
@@ -164,8 +208,72 @@ module Legion
             { success: false, error: e.message }
           end
 
+          def prepare_mesh_export(target_domain:, min_confidence: 0.5, limit: 100, **)
+            unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
+              return { success: false, error: 'apollo_data_not_available' }
+            end
+
+            conn = Legion::Data.connection
+            allowed = allowed_domains_for(target_domain)
+
+            dataset = conn[:apollo_entries]
+                      .where(status: 'confirmed')
+                      .where { confidence >= min_confidence }
+                      .limit(limit)
+
+            dataset = dataset.where(knowledge_domain: allowed) unless allowed == :all
+
+            entries = dataset.all
+
+            formatted = entries.map do |entry|
+              { id: entry[:id], content: entry[:content], content_type: entry[:content_type],
+                confidence: entry[:confidence], knowledge_domain: entry[:knowledge_domain],
+                tags: entry[:tags], source_agent: entry[:source_agent] }
+            end
+
+            { success: true, entries: formatted, count: formatted.size, target_domain: target_domain }
+          rescue Sequel::Error => e
+            { success: false, error: e.message }
+          end
+
+          def handle_erasure_request(agent_id:, **)
+            unless defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
+              return { deleted: 0, redacted: 0, error: 'apollo_data_not_available' }
+            end
+
+            conn = Legion::Data.connection
+
+            # Delete entries solely from dead agent (not confirmed by others)
+            deleted = conn[:apollo_entries]
+                      .where(source_agent: agent_id)
+                      .exclude(status: 'confirmed')
+                      .delete
+
+            # Redact attribution on confirmed entries (corroborated, retain knowledge)
+            redacted = conn[:apollo_entries]
+                       .where(source_agent: agent_id, status: 'confirmed')
+                       .update(source_agent: 'redacted', source_provider: nil, source_channel: nil)
+
+            { deleted: deleted, redacted: redacted, agent_id: agent_id }
+          rescue Sequel::Error => e
+            { deleted: 0, redacted: 0, error: e.message }
+          end
+
           private
 
+          def allowed_domains_for(target_domain)
+            rules = if defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :domain_isolation)
+                      Legion::Settings.dig(:apollo, :domain_isolation)
+                    else
+                      DOMAIN_ISOLATION
+                    end
+
+            allowed = rules[target_domain]
+            return :all if allowed == :all || allowed.nil?
+
+            Array(allowed)
+          end
+
           def detect_contradictions(entry_id, embedding, content)
             return [] unless embedding && defined?(Legion::Data::Model::ApolloEntry)
 
@@ -209,7 +317,7 @@ module Legion
             false
           end
 
-          def find_corroboration(embedding, content_type_sym, source_agent)
+          def find_corroboration(embedding, content_type_sym, source_agent, source_channel = nil)
             existing = Legion::Data::Model::ApolloEntry
                        .where(content_type: content_type_sym)
                        .exclude(embedding: nil)
@@ -222,6 +330,14 @@ module Legion
               next unless Helpers::Similarity.above_corroboration_threshold?(similarity: sim)
 
               weight = same_source_provider?(source_agent, entry) ? 0.5 : 1.0
+
+              # Reject corroboration entirely if same channel (same data source)
+              if source_channel && entry.respond_to?(:source_channel)
+                existing_channel = entry.source_channel
+                weight = 0.0 if existing_channel && existing_channel == source_channel
+              end
+              next if weight.zero?
+
               entry.update(
                 confidence: Helpers::Confidence.apply_corroboration_boost(confidence: entry.confidence, weight: weight),
                 updated_at: Time.now

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

@@ -21,28 +21,40 @@ module Legion
             { action: :resolve_dispute, entry_id: entry_id, resolution: resolution }
           end
 
-          def run_decay_cycle(rate: nil, min_confidence: nil, **)
-            rate ||= decay_rate
+          def run_decay_cycle(alpha: nil, min_confidence: nil, **)
+            alpha ||= decay_alpha
             min_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)'
+            )
+            decay_factor = Sequel.lit(
+              'POWER(CAST(? AS double precision) / (CAST(? AS double precision) + 1.0), ?)', hours_expr, hours_expr, alpha
+            )
+
             decayed = conn[:apollo_entries]
                       .exclude(status: 'archived')
-                      .update(confidence: Sequel[:confidence] * rate)
+                      .update(confidence: Sequel[:confidence] * decay_factor)
 
             archived = conn[:apollo_entries]
                        .where { confidence < min_confidence }
                        .exclude(status: 'archived')
                        .update(status: 'archived')
 
-            { decayed: decayed, archived: archived, rate: rate, threshold: min_confidence }
+            { decayed: decayed, archived: archived, alpha: alpha, threshold: min_confidence }
           rescue Sequel::Error => e
             { decayed: 0, archived: 0, error: e.message }
           end
 
-          def check_corroboration(**)
+          def check_corroboration(**) # rubocop:disable Metrics/CyclomaticComplexity
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
             candidates = Legion::Data::Model::ApolloEntry.where(status: 'candidate').exclude(embedding: nil).all
@@ -67,6 +79,11 @@ 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
+
               candidate.update(
                 status:       'confirmed',
                 confirmed_at: Time.now,
@@ -92,10 +109,9 @@ module Legion
 
           private
 
-          def decay_rate
-            alpha = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :power_law_alpha)) ||
-                    Helpers::Confidence::POWER_LAW_ALPHA
-            1.0 / (1.0 + alpha)
+          def decay_alpha
+            (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :power_law_alpha)) ||
+              Helpers::Confidence::POWER_LAW_ALPHA
           end
 
           def known_provider?(provider)

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.3.4'
+      VERSION = '0.3.6'
     end
   end
 end

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

@@ -18,7 +18,7 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Confidence do
     end
 
     it 'defines POWER_LAW_ALPHA' do
-      expect(described_class::POWER_LAW_ALPHA).to eq(0.1)
+      expect(described_class::POWER_LAW_ALPHA).to eq(0.5)
     end
 
     it 'defines DECAY_THRESHOLD' do
@@ -45,7 +45,7 @@ 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.1) # ~0.909091
+      expected = 1.0 / (1.0 + 0.5) # ~0.6667
       expect(result).to be_within(0.0001).of(expected)
     end
 

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

@@ -12,10 +12,9 @@ RSpec.describe 'Apollo Decay Cycle' do
     end
   end
 
-  describe '#decay_rate' do
-    it 'returns power-law derived rate when settings unavailable' do
-      expected = 1.0 / (1.0 + 0.1) # ~0.909091
-      expect(maintenance.send(:decay_rate)).to be_within(0.0001).of(expected)
+  describe '#decay_alpha' do
+    it 'returns POWER_LAW_ALPHA when settings unavailable' do
+      expect(maintenance.send(:decay_alpha)).to eq(0.5)
     end
   end
 

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

@@ -157,6 +157,37 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         )
         host.handle_ingest(content: 'test', content_type: 'fact', source_agent: 'agent-1')
       end
+
+      it 'passes source_channel to create' do
+        expect(mock_entry_class).to receive(:create).with(
+          hash_including(source_channel: 'slack-alerts')
+        ).and_return(mock_entry)
+        host.handle_ingest(content: 'test', content_type: 'fact',
+                           source_agent: 'agent-1', source_channel: 'slack-alerts')
+      end
+
+      it 'passes knowledge_domain to create from explicit param' do
+        expect(mock_entry_class).to receive(:create).with(
+          hash_including(knowledge_domain: 'clinical')
+        ).and_return(mock_entry)
+        host.handle_ingest(content: 'test', content_type: 'fact',
+                           source_agent: 'agent-1', knowledge_domain: 'clinical')
+      end
+
+      it 'defaults knowledge_domain to first tag' do
+        expect(mock_entry_class).to receive(:create).with(
+          hash_including(knowledge_domain: 'cardiology')
+        ).and_return(mock_entry)
+        host.handle_ingest(content: 'test', content_type: 'fact',
+                           tags: %w[cardiology treatment], source_agent: 'agent-1')
+      end
+
+      it 'defaults knowledge_domain to general when no tags and no explicit domain' do
+        expect(mock_entry_class).to receive(:create).with(
+          hash_including(knowledge_domain: 'general')
+        ).and_return(mock_entry)
+        host.handle_ingest(content: 'test', content_type: 'fact', source_agent: 'agent-1')
+      end
     end
 
     context 'when Sequel raises an error' do
@@ -305,6 +336,228 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         expect(result[:success]).to be true
         expect(result[:count]).to eq(1)
       end
+
+      it 'passes domain to graph query builder' do
+        expect(Legion::Extensions::Apollo::Helpers::GraphQuery).to receive(:build_semantic_search_sql).with(
+          hash_including(domain: 'clinical')
+        ).and_call_original
+        host.retrieve_relevant(query: 'treatment', domain: 'clinical')
+      end
+    end
+  end
+
+  describe '#redistribute_knowledge' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.redistribute_knowledge(agent_id: 'agent-x')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when the departing agent has no confirmed entries' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        chain = double('chain')
+        allow(mock_entry_class).to receive(:where).and_return(chain)
+        allow(chain).to receive(:where).and_return(double(all: []))
+      end
+
+      it 'returns success with zero redistributed' do
+        result = host.redistribute_knowledge(agent_id: 'departed-1')
+        expect(result[:success]).to be true
+        expect(result[:redistributed]).to eq(0)
+      end
+    end
+
+    context 'when the departing agent has confirmed entries' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_entry) do
+        double('entry', content: 'Ruby is fast', content_type: 'fact',
+                        confidence: 0.8, tags: ['ruby'])
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        chain = double('chain')
+        allow(mock_entry_class).to receive(:where).and_return(chain)
+        allow(chain).to receive(:where).and_return(double(all: [mock_entry]))
+      end
+
+      it 'returns the count of redistributed entries' do
+        result = host.redistribute_knowledge(agent_id: 'departed-2')
+        expect(result[:success]).to be true
+        expect(result[:redistributed]).to eq(1)
+        expect(result[:agent_id]).to eq('departed-2')
+      end
+
+      it 'stores into trace shared_store when Memory::Trace is available' do
+        mock_store = double('store')
+        mock_trace_helpers = Module.new do
+          def self.new_trace(type:, content_payload: nil, **kwargs) # rubocop:disable Lint/UnusedMethodArgument
+            { trace_id: 'trace-abc', trace_type: type, strength: kwargs[:strength] || 0.5 }
+          end
+        end
+        stub_const('Legion::Extensions::Agentic::Memory::Trace', Module.new)
+        stub_const('Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace', mock_trace_helpers)
+        allow(Legion::Extensions::Agentic::Memory::Trace).to receive(:shared_store).and_return(mock_store)
+        allow(mock_store).to receive(:store)
+
+        result = host.redistribute_knowledge(agent_id: 'departed-3')
+        expect(result[:redistributed]).to eq(1)
+        expect(mock_store).to have_received(:store).once
+      end
+    end
+
+    context 'when Sequel raises an error' do
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', Class.new)
+        allow(Legion::Data::Model::ApolloEntry).to receive(:where)
+          .and_raise(Sequel::Error, 'db error')
+      end
+
+      it 'returns a structured error' do
+        result = host.redistribute_knowledge(agent_id: 'agent-x')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('db error')
+      end
+    end
+  end
+
+  describe '#prepare_mesh_export' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Legion::Data is not available' do
+      before { hide_const('Legion::Data') if defined?(Legion::Data) }
+
+      it 'returns a structured error' do
+        result = host.prepare_mesh_export(target_domain: 'clinical_care')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when data is available' do
+      let(:mock_conn) { double('connection') }
+      let(:mock_dataset) { double('dataset') }
+      let(:clinical_entry) do
+        { id: 'e1', content: 'treatment', content_type: 'fact',
+          confidence: 0.8, knowledge_domain: 'clinical_care',
+          tags: ['clinical'], source_agent: 'agent-1' }
+      end
+      let(:claims_entry) do
+        { id: 'e2', content: 'denial', content_type: 'fact',
+          confidence: 0.7, knowledge_domain: 'claims_optimization',
+          tags: ['claims'], source_agent: 'agent-2' }
+      end
+
+      before do
+        data_mod = Module.new do
+          def self.connection; end
+
+          def self.respond_to?(method, *args)
+            method == :connection || super
+          end
+        end
+        stub_const('Legion::Data', data_mod)
+        allow(Legion::Data).to receive(:connection).and_return(mock_conn)
+        allow(mock_conn).to receive(:[]).with(:apollo_entries).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:where).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:limit).and_return(mock_dataset)
+      end
+
+      it 'filters entries by domain compatibility for clinical_care' do
+        allow(mock_dataset).to receive(:all).and_return([clinical_entry])
+        result = host.prepare_mesh_export(target_domain: 'clinical_care')
+        expect(result[:success]).to be true
+        expect(result[:target_domain]).to eq('clinical_care')
+      end
+
+      it 'allows all domains when target is general' do
+        allow(mock_dataset).to receive(:all).and_return([clinical_entry, claims_entry])
+        result = host.prepare_mesh_export(target_domain: 'general')
+        expect(result[:success]).to be true
+        expect(result[:count]).to eq(2)
+      end
+
+      it 'restricts claims_optimization to only claims entries' do
+        allow(mock_dataset).to receive(:all).and_return([claims_entry])
+        result = host.prepare_mesh_export(target_domain: 'claims_optimization')
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#handle_erasure_request' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Legion::Data is not available' do
+      before { hide_const('Legion::Data') if defined?(Legion::Data) }
+
+      it 'returns zero counts with error' do
+        result = host.handle_erasure_request(agent_id: 'agent-dead')
+        expect(result[:deleted]).to eq(0)
+        expect(result[:redacted]).to eq(0)
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when data is available' do
+      let(:mock_conn) { double('connection') }
+      let(:mock_dataset) { double('dataset') }
+
+      before do
+        data_mod = Module.new do
+          def self.connection; end
+
+          def self.respond_to?(method, *args)
+            method == :connection || super
+          end
+        end
+        stub_const('Legion::Data', data_mod)
+        allow(Legion::Data).to receive(:connection).and_return(mock_conn)
+        allow(mock_conn).to receive(:[]).with(:apollo_entries).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:where).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:exclude).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:delete).and_return(3)
+        allow(mock_dataset).to receive(:update).and_return(2)
+      end
+
+      it 'deletes non-confirmed entries and redacts confirmed ones' do
+        result = host.handle_erasure_request(agent_id: 'agent-dead')
+        expect(result[:deleted]).to eq(3)
+        expect(result[:redacted]).to eq(2)
+        expect(result[:agent_id]).to eq('agent-dead')
+      end
+    end
+
+    context 'when Sequel raises an error' do
+      before do
+        data_mod = Module.new do
+          def self.connection; end
+
+          def self.respond_to?(method, *args)
+            method == :connection || super
+          end
+        end
+        stub_const('Legion::Data', data_mod)
+        allow(Legion::Data).to receive(:connection).and_return(double('conn').tap do |c|
+          allow(c).to receive(:[]).and_raise(Sequel::Error, 'db gone')
+        end)
+      end
+
+      it 'returns zero counts with the error message' do
+        result = host.handle_erasure_request(agent_id: 'agent-dead')
+        expect(result[:deleted]).to eq(0)
+        expect(result[:redacted]).to eq(0)
+        expect(result[:error]).to eq('db gone')
+      end
     end
   end
 end

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

@@ -37,6 +37,58 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
     end
   end
 
+  describe '#run_decay_cycle' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Legion::Data is not available' do
+      before { hide_const('Legion::Data') if defined?(Legion::Data) }
+
+      it 'returns zero counts' do
+        result = host.run_decay_cycle
+        expect(result[:decayed]).to eq(0)
+        expect(result[:archived]).to eq(0)
+      end
+    end
+
+    context 'when data is available' do
+      let(:mock_conn) { double('connection') }
+      let(:mock_dataset) { double('dataset') }
+
+      before do
+        data_mod = Module.new do
+          def self.connection; end
+
+          def self.respond_to?(method, *args)
+            method == :connection || super
+          end
+        end
+        stub_const('Legion::Data', data_mod)
+        allow(Legion::Data).to receive(:connection).and_return(mock_conn)
+        allow(mock_conn).to receive(:[]).with(:apollo_entries).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:exclude).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:where).and_return(mock_dataset)
+        allow(mock_dataset).to receive(:update).and_return(5)
+      end
+
+      it 'returns alpha in result hash' do
+        result = host.run_decay_cycle
+        expect(result[:alpha]).to eq(0.5)
+        expect(result).not_to have_key(:rate)
+      end
+
+      it 'returns decayed and archived counts' do
+        result = host.run_decay_cycle
+        expect(result[:decayed]).to eq(5)
+        expect(result[:archived]).to eq(5)
+      end
+
+      it 'accepts custom alpha parameter' do
+        result = host.run_decay_cycle(alpha: 0.3)
+        expect(result[:alpha]).to eq(0.3)
+      end
+    end
+  end
+
   describe '#check_corroboration' do
     let(:host) { Object.new.extend(described_class) }
 
@@ -106,6 +158,34 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       end
     end
 
+    context 'when candidate and confirmed share the same source_channel' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_relation_class) { double('ApolloRelation') }
+      let(:embedding) { Array.new(1536, 0.5) }
+      let(:candidate) do
+        double('candidate', id: 'c-1', content_type: 'fact', embedding: embedding,
+               confidence: 0.5, source_provider: 'openai', source_channel: 'slack-alerts')
+      end
+      let(:confirmed_entry) do
+        double('confirmed', id: 'f-1', content_type: 'fact', embedding: embedding,
+               source_provider: 'claude', source_channel: 'slack-alerts')
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
+        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
+                                                  .and_return(double(exclude: double(all: [candidate])))
+        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
+                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+      end
+
+      it 'does not promote even with different providers' do
+        result = host.check_corroboration
+        expect(result[:promoted]).to eq(0)
+      end
+    end
+
     context 'when candidate has different content_type than confirmed' do
       let(:mock_entry_class) { double('ApolloEntry') }
       let(:embedding) { Array.new(1536, 0.5) }

data/spec/spec_helper.rb

@@ -17,9 +17,13 @@ unless defined?(Sequel)
     class Error < StandardError; end
 
     def self.pg_array(arr) = arr
-    def self.lit(str) = str
-    Expr = Struct.new(:value) { def +(other) = "#{value} + #{other}" }
+    def self.lit(str, *) = str
+    Expr = Struct.new(:value) do
+      def +(other) = "#{value} + #{other}"
+      def *(other) = "#{value} * #{other}"
+    end
     def self.expr(sym) = Expr.new(sym)
+    def self.[](sym) = Expr.new(sym)
   end
 end
 

metadata

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