lex-apollo 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6156122baf8989f96a09685918e8ed6f6608730c8e19e442a632f5faa8853ee7
-  data.tar.gz: 478d0003003a76abc6ffdc0c39a7be3b06d8e75f91e1c88a6edfa5e46a05634a
+  metadata.gz: 8f3802ccfc38ce2517807c30308ecf2e0c7257ff164fce30e83529e11ce9762e
+  data.tar.gz: f07b13160329615265956271795b41cbaaf898d1e0d0084f46bb7598e6f50733
 SHA512:
-  metadata.gz: 898147c2dbe69430a0dc4606db21a82100de37a1865b9d56157499530c7e7a205e8cc44cd39f23410293a8f3874c9dadacf9c5aa47c89bd5b61a7a39b9067951
-  data.tar.gz: 8ed9fe61c718b12abfd8b5b2c6a75e249e47491c6bf8068df984f6f18c8943ee5d3d56b3b2def551703b4cd7b0463942e20a4803a740ca7da65d25a87b90c344
+  metadata.gz: 7179a58756d5a9f6cfbdde00d06f809a99b5795ff2a7bf8aea599785d0fdc18d363228b844fc769f0cd459eabfdec416540f474e814a84713937eff06692d82b
+  data.tar.gz: 1eb71fa6a968770f8327e026f42a5cf3bce50ceb18c7ab65545e9bc3ecd325f550c9eb3af239e64f456a8e5263ba4cc3faf66729f2e96aa821e9caf3e317dc51

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.3.7] - 2026-03-22
+
+### Changed
+- Add legion-cache, legion-crypt, legion-data, legion-json, legion-logging, legion-settings, and legion-transport as runtime dependencies
+- Replace direct Legion::Logging calls with injected log helper in runners and actors
+- Update spec_helper with real sub-gem helper stubs (Legion::Logging stub removed)
+
+## [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/actors/entity_watchdog.rb

@@ -52,10 +52,10 @@ module Legion
               end
             end
 
-            log_debug("EntityWatchdog: ingested #{ingested} new entities from #{texts.size} log entries")
+            log.debug("EntityWatchdog: ingested #{ingested} new entities from #{texts.size} log entries")
             { success: true, ingested: ingested, logs_scanned: texts.size }
           rescue StandardError => e
-            log_error("EntityWatchdog scan_and_ingest failed: #{e.message}")
+            log.error("EntityWatchdog scan_and_ingest failed: #{e.message}")
             { success: false, error: e.message }
           end
 
@@ -100,7 +100,7 @@ module Legion
               context:      { entity_type: entity[:type], original_name: entity[:name] }
             ).publish
           rescue StandardError => e
-            log_error("EntityWatchdog publish failed: #{e.message}")
+            log.error("EntityWatchdog publish failed: #{e.message}")
           end
 
           def entity_types
@@ -126,16 +126,6 @@ module Legion
             end
             DEDUP_THRESHOLD_DEFAULT
           end
-
-          private
-
-          def log_debug(message)
-            Legion::Logging.debug(message) if defined?(Legion::Logging)
-          end
-
-          def log_error(message)
-            Legion::Logging.error(message) if defined?(Legion::Logging)
-          end
         end
       end
     end

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 }
@@ -157,13 +167,13 @@ module Legion
               redistributed += 1
             end
 
-            Legion::Logging.info "[apollo] redistributed #{redistributed} entries from departing agent=#{agent_id}"
+            log.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, skip: false, **)
+          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)
@@ -173,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
@@ -189,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 }
@@ -197,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)
 
@@ -242,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)
@@ -255,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.5'
+      VERSION = '0.3.7'
     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,13 @@ 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
 
@@ -391,4 +429,135 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       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

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-
-module Legion
-  module Logging
-    def self.debug(_msg); end
-    def self.info(_msg); end
-    def self.warn(_msg); end
-    def self.error(_msg); end
-  end
-end
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/cache/helper'
+require 'legion/crypt/helper'
+require 'legion/data/helper'
+require 'legion/json/helper'
+require 'legion/transport'
 
 # Sequel is a runtime dependency via legion-data; stub for specs
 unless defined?(Sequel)
@@ -17,9 +15,39 @@ 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
+
+module Legion
+  module Extensions
+    module Helpers
+      module Lex
+        include Legion::Logging::Helper
+        include Legion::Settings::Helper
+        include Legion::Cache::Helper
+        include Legion::Crypt::Helper
+        include Legion::Data::Helper
+        include Legion::JSON::Helper
+        include Legion::Transport::Helper
+      end
+    end
+
+    module Actors
+      class Every
+        include Helpers::Lex
+      end
+
+      class Subscription
+        include Helpers::Lex
+      end
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Esity
@@ -9,6 +9,104 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement