lex-apollo 0.4.28 → 0.4.44

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

@@ -122,11 +122,10 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
   end
 
   describe '#deprecate_entry' do
-    it 'returns a deprecate payload' do
+    it 'retains the client action envelope without claiming a completed service mutation' do
       result = runner.deprecate_entry(entry_id: 'uuid-123', reason: 'outdated')
       expect(result[:action]).to eq(:deprecate)
-      expect(result[:entry_id]).to eq('uuid-123')
-      expect(result[:reason]).to eq('outdated')
+      expect(result).not_to have_key(:success)
     end
   end
 
@@ -169,6 +168,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         allow(dedup_chain).to receive(:exclude).with(status: 'archived').and_return(double(first: nil))
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
+        allow(mock_db).to receive(:transaction) { |**_options, &block| block.call }
         allow(mock_entry_class).to receive(:create).and_return(mock_entry)
         allow(mock_expertise_class).to receive(:where).and_return(double(first: nil))
         allow(mock_expertise_class).to receive(:create)
@@ -345,12 +345,28 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
           expect(result[:success]).to be true
           expect(result[:entry_id]).to eq('uuid-race-winner')
         end
+
+        it 'returns a failure when a rolled-back uniqueness conflict has no winner' do
+          allow(mock_entry_class).to receive(:create)
+            .and_raise(Sequel::UniqueConstraintViolation, 'duplicate key value violates unique constraint')
+          collision_dataset = double('collision_dataset')
+          allow(mock_entry_class).to receive(:where).with(content_hash: anything).and_return(collision_dataset)
+          allow(collision_dataset).to receive(:exclude).with(status: 'archived').and_return(collision_dataset)
+          allow(collision_dataset).to receive(:first).and_return(nil, nil)
+
+          result = host.handle_ingest(content: 'lost race content', content_type: 'fact',
+                                      source_agent: 'agent-1', content_hash: 'no-winner')
+
+          expect(result).to include(success: false, error: 'duplicate key value violates unique constraint')
+        end
       end
     end
 
     context 'when Sequel raises an error' do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', Class.new)
+        stub_const('Legion::Data::Model::ApolloExpertise', Class.new)
+        stub_const('Legion::Data::Model::ApolloAccessLog', Class.new)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(Legion::Data::Model::ApolloEntry).to receive(:where)
@@ -376,6 +392,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       let(:mock_expertise_class2) { double('ApolloExpertise2') }
       let(:mock_access_log_class2) { double('ApolloAccessLog2') }
       let(:mock_entry2) { double('entry2', id: 99, embedding: nil) }
+      let(:mock_db2) { double('db2') }
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class2)
@@ -384,6 +401,8 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         scoped_ds = double('scoped_ds2', first: nil, where: double('scoped_ds2b', first: nil))
         allow(mock_entry_class2).to receive(:where).and_return(scoped_ds)
         allow(scoped_ds).to receive(:exclude).and_return(scoped_ds)
+        allow(mock_entry_class2).to receive(:db).and_return(mock_db2)
+        allow(mock_db2).to receive(:transaction) { |**_options, &block| block.call }
         allow(mock_expertise_class2).to receive(:where).and_return(double(first: nil))
         allow(mock_expertise_class2).to receive(:create)
         allow(mock_access_log_class2).to receive(:create)
@@ -433,6 +452,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       let(:mock_access_log_class3) { double('ApolloAccessLog3') }
       let(:mock_entry_a) { double('entry_a', id: 7, embedding: nil) }
       let(:mock_entry_b) { double('entry_b', id: 8, embedding: nil) }
+      let(:mock_db3) { double('db3') }
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class3)
@@ -449,6 +469,8 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         allow(scoped_ds3).to receive(:where).and_return(double('scoped_ds3b', first: nil))
         allow(scoped_ds3).to receive(:exclude).and_return(scoped_ds3)
         allow(mock_entry_class3).to receive(:where).and_return(scoped_ds3)
+        allow(mock_entry_class3).to receive(:db).and_return(mock_db3)
+        allow(mock_db3).to receive(:transaction) { |**_options, &block| block.call }
         # two different principals each get their own entry
         allow(mock_entry_class3).to receive(:create).and_return(mock_entry_a, mock_entry_b)
       end
@@ -492,6 +514,89 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         end
       end
     end
+
+    context 'contradiction detection flag' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_relation_class) { double('ApolloRelation') }
+      let(:mock_expertise_class) { double('ApolloExpertise') }
+      let(:mock_access_log_class) { double('ApolloAccessLog') }
+      let(:mock_entry) { double('entry', id: 'uuid-new', embedding: nil) }
+      let(:empty_dataset) { double('dataset', each: nil) }
+      let(:mock_db) { double('db') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
+        stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
+        stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
+        dedup_chain = double('dedup_chain')
+        allow(mock_entry_class).to receive(:where).with(content_hash: anything).and_return(dedup_chain)
+        allow(dedup_chain).to receive(:exclude).with(status: 'archived').and_return(double(first: nil))
+        allow(mock_entry_class).to receive(:db).and_return(mock_db)
+        allow(mock_db).to receive(:fetch).and_return(double(all: []))
+        allow(mock_db).to receive(:transaction) { |**_options, &block| block.call }
+        allow(mock_entry_class).to receive(:create).and_return(mock_entry)
+        allow(mock_expertise_class).to receive(:where).and_return(double(first: nil))
+        allow(mock_expertise_class).to receive(:create)
+        allow(mock_access_log_class).to receive(:create)
+      end
+
+      it 'defaults contradiction detection to disabled' do
+        expect(Legion::Extensions::Apollo.settings[:contradiction][:enabled]).to be false
+      end
+
+      it 'does not call detect_contradictions when flag is false' do
+        expect(host).not_to receive(:detect_contradictions)
+        result = host.handle_ingest(content: 'test fact', content_type: 'fact', source_agent: 'agent-1')
+        expect(result[:success]).to be true
+        expect(result[:contradictions]).to eq([])
+      end
+
+      it 'returns stable contradictions key as empty array when disabled' do
+        result = host.handle_ingest(content: 'test content', content_type: 'fact', source_agent: 'agent-1')
+        expect(result).to have_key(:contradictions)
+        expect(result[:contradictions]).to eq([])
+      end
+
+      context 'when enabled' do
+        before do
+          Legion::Settings[:extensions][:apollo][:contradiction][:enabled] = true
+          stub_const('Legion::Extensions::Apollo::Actor::ContradictionScanner',
+                     Class.new do
+                       @queue = Queue.new
+                       class << self
+                         attr_reader :queue
+
+                         def enqueue(entry_id:, embedding:, content:)
+                           queue.push({ entry_id: entry_id, embedding: embedding, content: content })
+                         end
+
+                         def pending_count = queue.size
+
+                         def drain
+                           items = []
+                           items << queue.pop until queue.empty?
+                           items
+                         end
+                       end
+                     end)
+        end
+
+        after do
+          Legion::Settings[:extensions][:apollo][:contradiction][:enabled] = false
+        end
+
+        it 'enqueues contradiction work to the actor instead of running inline' do
+          result = host.handle_ingest(content: 'enabled test', content_type: 'fact', source_agent: 'agent-1')
+          expect(result[:success]).to be true
+          expect(result[:contradictions]).to eq([])
+          expect(Legion::Extensions::Apollo::Actor::ContradictionScanner.pending_count).to eq(1)
+        end
+      end
+    end
   end
 
   describe '#handle_query' do
@@ -507,6 +612,25 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       end
     end
 
+    context 'when semantic query access logging is unavailable' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        hide_const('Legion::Data::Model::ApolloAccessLog') if defined?(Legion::Data::Model::ApolloAccessLog)
+        hide_const('Legion::Data::Model::Apollo::AccessLog') if defined?(Legion::Data::Model::Apollo::AccessLog)
+      end
+
+      it 'fails before embedding, lookup, or confidence mutation' do
+        expect(mock_entry_class).not_to receive(:db)
+        expect(Legion::LLM::Call::Embeddings).not_to receive(:generate)
+
+        expect(host.handle_query(query: 'semantic query')).to include(
+          success: false, error: 'apollo_data_not_available'
+        )
+      end
+    end
+
     context 'when Apollo data is available' do
       let(:mock_entry_class) { double('ApolloEntry') }
       let(:mock_access_log_class) { double('ApolloAccessLog') }
@@ -555,6 +679,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloAccessLog', Class.new)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
@@ -612,37 +737,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         expect(dataset).to have_received(:where).with(knowledge_domain: 'general')
       end
     end
-
-    context 'access scope forwarding' do
-      let(:mock_entry_class) { double('ApolloEntry') }
-      let(:mock_db) { double('db') }
-
-      before do
-        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
-        allow(mock_entry_class).to receive(:db).and_return(mock_db)
-        allow(mock_db).to receive(:fetch).and_return(double(all: []))
-        allow(mock_entry_class).to receive(:where).and_return(double(update: true))
-      end
-
-      it 'forwards requesting_principal_id to build_semantic_search_sql' do
-        expect(Legion::Extensions::Apollo::Helpers::GraphQuery).to receive(:build_semantic_search_sql).with(
-          hash_including(requesting_principal_id: 42)
-        ).and_return('SELECT 1')
-        allow(mock_db).to receive(:fetch).and_return(double(all: []))
-
-        host.handle_query(query: 'test', requesting_principal_id: 42)
-      end
-
-      it 'passes nil requesting_principal_id when not provided (no filter)' do
-        expect(Legion::Extensions::Apollo::Helpers::GraphQuery).to receive(:build_semantic_search_sql).with(
-          hash_including(requesting_principal_id: nil)
-        ).and_return('SELECT 1')
-
-        host.handle_query(query: 'test')
-      end
-    end
   end
 
   describe '#normalize_text_input' do
@@ -712,21 +806,6 @@ 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
-
-      it 'forwards requesting_principal_id to build_semantic_search_sql' do
-        expect(Legion::Extensions::Apollo::Helpers::GraphQuery).to receive(:build_semantic_search_sql).with(
-          hash_including(requesting_principal_id: 7)
-        ).and_return('SELECT 1')
-
-        host.retrieve_relevant(query: 'test', requesting_principal_id: 7)
-      end
     end
   end
 
@@ -783,13 +862,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         expect(mock_access_log_class).not_to receive(:create)
         host.handle_traverse(entry_id: 'uuid-1')
       end
-
-      it 'filters invalid relation_types' do
-        expect(Legion::Extensions::Apollo::Helpers::GraphQuery).to receive(:build_traversal_sql).with(
-          hash_including(relation_types: ['causes'])
-        ).and_call_original
-        host.handle_traverse(entry_id: 'uuid-1', relation_types: %w[causes invalid_type])
-      end
     end
 
     context 'when Sequel raises an error' do
@@ -861,7 +933,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       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
+          def self.new_trace(type:, **kwargs)
             { trace_id: 'trace-abc', trace_type: type, strength: kwargs[:strength] || 0.5 }
           end
         end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'json'
+
+RSpec.describe 'Apollo service lifecycle mutations' do
+  let(:lifecycle_script) do
+    <<~'RUBY'
+      require 'sequel'
+      require 'sinatra/base'
+      require 'rack/mock'
+      require 'rspec'
+      require 'spec_helper'
+      require 'json'
+      require 'legion/extensions/apollo/api'
+      db = Sequel.sqlite
+      db.create_table(:apollo_entries) do
+        primary_key :id
+        String :content
+        String :content_type
+        String :status
+        Float :confidence
+        String :source_context
+        DateTime :created_at
+        DateTime :updated_at
+        DateTime :confirmed_at
+        check(Sequel.lit("content != 'protected' OR status != 'archived'"))
+      end
+      Legion::Data.const_set(:Model, Module.new) unless defined?(Legion::Data::Model)
+      Legion::Data::Model.const_set(:Apollo, Module.new)
+      entry_model = Class.new(Sequel::Model(db[:apollo_entries]))
+      Legion::Data::Model::Apollo.const_set(:Entry, entry_model)
+      now = Time.now
+      old = now - (100 * 86_400)
+      attributes = { content_type: 'fact', status: 'candidate', confidence: 0.8,
+                     source_context: ::JSON.generate(origin: 'preserve'), created_at: now, updated_at: nil }
+      db[:apollo_entries].insert(attributes.merge(id: 1, content: 'target'))
+      db[:apollo_entries].insert(attributes.merge(id: 2, content: 'protected'))
+      db[:apollo_entries].insert(attributes.merge(id: 3, content: 'stale', confidence: 0.04, created_at: old))
+      db[:apollo_entries].insert(attributes.merge(id: 4, content: 'touched', status: 'confirmed', confidence: 0.6,
+                                                 created_at: old, updated_at: now))
+      db[:apollo_entries].insert(attributes.merge(id: 5, content: 'already archived', status: 'archived', confidence: 0.7,
+                                                 created_at: old))
+      input = ::JSON.parse($stdin.read, symbolize_names: true)
+      maintenance = Object.new.extend(Legion::Extensions::Apollo::Runners::Maintenance)
+      case input[:operation]
+      when 'deprecate'
+        api = Rack::MockRequest.new(Legion::Extensions::Apollo::Api)
+        payload = ::JSON.generate(reason: 'Verified replacement exists.')
+        first = api.post('/api/apollo/entries/1/deprecate', 'CONTENT_TYPE' => 'application/json', input: payload)
+        first_updated_at = entry_model[1].updated_at
+        repeated = api.post('/api/apollo/entries/1/deprecate', 'CONTENT_TYPE' => 'application/json', input: payload)
+        repeat_preserved_time = entry_model[1].updated_at == first_updated_at
+        missing = api.post('/api/apollo/entries/999/deprecate')
+        failed = api.post('/api/apollo/entries/2/deprecate', 'CONTENT_TYPE' => 'application/json', input: payload)
+        malformed = api.post('/api/apollo/entries/1/deprecate', 'CONTENT_TYPE' => 'application/json', input: '{')
+        Legion::Data::Model::Apollo.send(:remove_const, :Entry)
+        unavailable = api.post('/api/apollo/entries/1/deprecate')
+        Legion::Data::Model::Apollo.const_set(:Entry, entry_model)
+        responses = { first: first, repeated: repeated, missing: missing, failed: failed,
+                      malformed: malformed, unavailable: unavailable }.transform_values do |response|
+          { status: response.status, body: ::JSON.parse(response.body) }
+        end
+        result = { responses: responses, repeat_preserved_time: repeat_preserved_time }
+      when 'maintenance'
+        decay = maintenance.force_decay(factor: 0.5)
+        after_decay = db[:apollo_entries].order(:id).all
+        invalid_factor = maintenance.force_decay(factor: -0.1)
+        invalid_factor_unchanged = after_decay == db[:apollo_entries].order(:id).all
+        archive = maintenance.archive_stale(days: 90)
+        repeated = maintenance.archive_stale(days: 90)
+        before_invalid_days = db[:apollo_entries].order(:id).all
+        invalid_days = maintenance.archive_stale(days: -1)
+        result = { decay: decay, after_decay: after_decay, invalid_factor: invalid_factor,
+                   invalid_factor_unchanged: invalid_factor_unchanged, archive: archive, repeated: repeated,
+                   invalid_days: invalid_days, invalid_days_unchanged: before_invalid_days == db[:apollo_entries].order(:id).all }
+      when 'dispute'
+        db[:apollo_entries].where(id: [1, 2, 3]).update(status: 'disputed')
+        db[:apollo_entries].insert(attributes.merge(id: 6, content: 'kept dispute', status: 'disputed'))
+        before_unknown = entry_model[6].values
+        unknown = maintenance.resolve_dispute(entry_id: 6, resolution: :unexpected)
+        unknown_unchanged = before_unknown == entry_model[6].values
+        accepted = maintenance.resolve_dispute(entry_id: 1, resolution: :accept)
+        rejected = maintenance.resolve_dispute(entry_id: 3, resolution: :reject)
+        kept = maintenance.resolve_dispute(entry_id: 6, resolution: :keep)
+        failed = maintenance.resolve_dispute(entry_id: 2, resolution: :reject)
+        missing = maintenance.resolve_dispute(entry_id: 999, resolution: :accept)
+        not_disputed = maintenance.resolve_dispute(entry_id: 4, resolution: :reject)
+        repeated = maintenance.resolve_dispute(entry_id: 1, resolution: :accept)
+        result = { accepted: accepted, rejected: rejected, kept: kept, failed: failed, missing: missing,
+                   not_disputed: not_disputed, repeated: repeated, unknown: unknown, unknown_unchanged: unknown_unchanged }
+      end
+      puts "APOLLO_RESULT=#{::JSON.generate(result.merge(entries: db[:apollo_entries].order(:id).all))}"
+    RUBY
+  end
+
+  def lifecycle_state(operation:)
+    stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, '-Ilib', '-Ispec', '-e', lifecycle_script,
+      chdir:      File.expand_path('../../../../..', __dir__),
+      stdin_data: JSON.generate(operation: operation)
+    )
+    line = stdout.lines.find { |output| output.start_with?('APOLLO_RESULT=') }
+    raise "Lifecycle process failed: #{stderr}\n#{stdout}" unless status.success? && line
+
+    JSON.parse(line.delete_prefix('APOLLO_RESULT='), symbolize_names: true)
+  end
+
+  it 'archives through HTTP with retained metadata and truthful repeat, missing, unavailable, and rollback outcomes' do
+    state = lifecycle_state(operation: 'deprecate')
+    responses = state[:responses]
+
+    expect(responses[:first]).to include(status: 200, body: hash_including(success: true, updated: true, status: 'archived'))
+    expect(responses[:repeated]).to include(status: 200, body: hash_including(success: true, updated: false))
+    expect(state[:repeat_preserved_time]).to be true
+    expect(responses[:missing]).to include(status: 404, body: hash_including(error: 'entry_not_found'))
+    expect(responses[:unavailable]).to include(status: 503, body: hash_including(error: 'apollo_data_not_available'))
+    expect(responses[:failed]).to include(status: 500, body: hash_including(success: false))
+    expect(responses[:malformed][:status]).to eq(400)
+    expect(state[:entries].first[:status]).to eq('archived')
+    expect(JSON.parse(state[:entries].first[:source_context], symbolize_names: true))
+      .to include(origin: 'preserve', deprecation_reason: 'Verified replacement exists.')
+    expect(state[:entries][1]).to include(status: 'candidate', source_context: JSON.generate(origin: 'preserve'))
+  end
+
+  it 'multiplies active confidence without implicit archival and archives only stale, untouched entries' do
+    state = lifecycle_state(operation: 'maintenance')
+
+    expect(state[:decay]).to include(success: true, decayed: 4)
+    expect(state[:after_decay].map { |entry| entry[:confidence] }).to eq([0.4, 0.4, 0.02, 0.3, 0.7])
+    expect(state[:after_decay][2][:status]).to eq('candidate')
+    expect(state[:invalid_factor]).to include(success: false, error: 'invalid_factor')
+    expect(state[:invalid_factor_unchanged]).to be true
+    expect(state[:archive]).to include(success: true, archived: 1)
+    expect(state[:repeated]).to include(success: true, archived: 0)
+    expect(state[:entries][2][:status]).to eq('archived')
+    expect(state[:entries][3][:status]).to eq('confirmed')
+    expect(state[:invalid_days]).to include(success: false, error: 'invalid_days')
+    expect(state[:invalid_days_unchanged]).to be true
+  end
+
+  it 'applies the approved dispute transitions and preserves state for invalid, ineligible, or failed decisions' do
+    state = lifecycle_state(operation: 'dispute')
+
+    expect(state[:accepted]).to include(success: true, status: 'confirmed')
+    expect(state[:kept]).to include(success: true, status: 'confirmed')
+    expect(state[:rejected]).to include(success: true, status: 'archived')
+    expect(state[:failed]).to include(success: false)
+    expect(state[:missing]).to include(success: false, error: 'entry_not_found')
+    expect(state[:not_disputed]).to include(success: false, error: 'entry_not_disputed')
+    expect(state[:repeated]).to include(success: false, error: 'entry_not_disputed')
+    expect(state[:unknown]).to include(success: false, error: 'invalid_resolution')
+    expect(state[:unknown_unchanged]).to be true
+    expect(state[:entries].first).to include(status: 'confirmed', confidence: 0.8)
+    expect(state[:entries].first[:confirmed_at]).not_to be_nil
+    expect(JSON.parse(state[:entries].first[:source_context], symbolize_names: true))
+      .to include(origin: 'preserve', dispute_resolution: 'accept')
+    expect(state[:entries][1]).to include(status: 'disputed', source_context: JSON.generate(origin: 'preserve'))
+    expect(state[:entries][2][:status]).to eq('archived')
+    expect(state[:entries][3][:status]).to eq('confirmed')
+    expect(state[:entries].last[:status]).to eq('confirmed')
+  end
+end

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

@@ -12,28 +12,12 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
     obj
   end
 
-  describe '#force_decay' do
-    it 'returns a force_decay payload' do
-      result = runner.force_decay(factor: 0.5)
-      expect(result[:action]).to eq(:force_decay)
-      expect(result[:factor]).to eq(0.5)
-    end
-  end
-
-  describe '#archive_stale' do
-    it 'returns an archive payload with default days' do
-      result = runner.archive_stale
-      expect(result[:action]).to eq(:archive_stale)
-      expect(result[:days]).to eq(90)
-    end
-  end
+  it 'retains client action envelopes without claiming completed service mutations when data is unavailable' do
+    results = [runner.force_decay(factor: 0.5), runner.archive_stale(days: 90),
+               runner.resolve_dispute(entry_id: 'uuid-123', resolution: :keep)]
 
-  describe '#resolve_dispute' do
-    it 'returns a resolve payload' do
-      result = runner.resolve_dispute(entry_id: 'uuid-123', resolution: :keep)
-      expect(result[:action]).to eq(:resolve_dispute)
-      expect(result[:resolution]).to eq(:keep)
-    end
+    expect(results.map { |result| result[:action] }).to eq(%i[force_decay archive_stale resolve_dispute])
+    expect(results).to all(satisfy { |result| !result.key?(:success) })
   end
 
   describe '#run_decay_cycle' do
@@ -101,111 +85,41 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       end
     end
 
-    context 'when no candidates exist' do
+    context 'when relation persistence is unavailable' do
       let(:mock_entry_class) { double('ApolloEntry') }
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(limit: double(all: []))))
-        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(limit: double(all: []))))
-      end
-
-      it 'returns zero promoted and scanned' do
-        result = host.check_corroboration
-        expect(result[:success]).to be true
-        expect(result[:promoted]).to eq(0)
-        expect(result[:scanned]).to eq(0)
-      end
-    end
-
-    context 'when a candidate matches a confirmed entry' 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, update: true)
-      end
-      let(:confirmed_entry) do
-        double('confirmed', id: 'f-1', content_type: 'fact', embedding: embedding)
-      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(limit: double(all: [candidate]))))
-        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
-        allow(mock_relation_class).to receive(:create)
+        hide_const('Legion::Data::Model::ApolloRelation') if defined?(Legion::Data::Model::ApolloRelation)
+        hide_const('Legion::Data::Model::Apollo::Relation') if defined?(Legion::Data::Model::Apollo::Relation)
       end
 
-      it 'promotes the candidate' do
-        expect(candidate).to receive(:update).with(hash_including(status: 'confirmed'))
-        result = host.check_corroboration
-        expect(result[:promoted]).to eq(1)
-        expect(result[:scanned]).to eq(1)
-      end
+      it 'fails before scanning or promoting candidates' do
+        expect(mock_entry_class).not_to receive(:where)
 
-      it 'creates a similar_to relation' do
-        expect(mock_relation_class).to receive(:create).with(
-          hash_including(from_entry_id: 'c-1', to_entry_id: 'f-1', relation_type: 'similar_to')
-        )
-        host.check_corroboration
+        expect(host.check_corroboration).to include(success: false, error: 'apollo_data_not_available')
       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(limit: double(all: [candidate]))))
-        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(limit: 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
+    context 'when no candidates exist' do
       let(:mock_entry_class) { double('ApolloEntry') }
-      let(:embedding) { Array.new(1536, 0.5) }
-      let(:candidate) do
-        double('candidate', id: 'c-1', content_type: 'fact', embedding: embedding, confidence: 0.5)
-      end
-      let(:confirmed_entry) do
-        double('confirmed', id: 'f-1', content_type: 'concept', embedding: embedding)
-      end
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
-        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
+        stub_const('Legion::Data::Model::ApolloRelation', Class.new)
+        candidate_dataset = double(
+          exclude: double(order: double(limit: double(all: [])))
+        )
+        confirmed_dataset = double(select_map: [])
+        allow(mock_entry_class).to receive(:where).with(status: 'candidate').and_return(candidate_dataset)
+        allow(mock_entry_class).to receive(:where).with(status: 'confirmed').and_return(confirmed_dataset)
       end
 
-      it 'does not promote' do
+      it 'returns zero promoted and scanned' do
         result = host.check_corroboration
+        expect(result[:success]).to be true
         expect(result[:promoted]).to eq(0)
+        expect(result[:scanned]).to eq(0)
       end
     end
   end