lex-apollo 0.4.30 → 0.4.44

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'json'
+
+RSpec.describe 'Apollo corroboration persistence' do
+  let(:candidate) do
+    { id: 1, status: 'candidate', content_type: 'fact', knowledge_domain: 'clinical', access_scope: 'global',
+      confidence: 0.5, source_provider: 'openai', source_channel: 'source-a' }
+  end
+  let(:confirmed) do
+    { id: 2, status: 'confirmed', content_type: 'fact', knowledge_domain: 'clinical', access_scope: 'global',
+      confidence: 0.8, source_provider: 'claude', source_channel: 'source-b' }
+  end
+
+  let(:corroboration_script) do
+    <<~'RUBY'
+      require 'sequel'
+      require 'rspec'
+      require 'spec_helper'
+      require 'json'
+      db = Sequel.sqlite
+      db.create_table(:apollo_entries) do
+        primary_key :id
+        String :status
+        String :content_type
+        String :knowledge_domain
+        String :access_scope
+        Integer :identity_principal_id
+        Integer :identity_id
+        String :source_provider
+        String :source_channel
+        String :embedding
+        Float :confidence
+        String :source_context
+        DateTime :confirmed_at
+        DateTime :updated_at
+      end
+      db.create_table(:apollo_relations) do
+        primary_key :id
+        Integer :from_entry_id
+        Integer :to_entry_id
+        String :relation_type
+        String :source_agent
+        Float :weight
+      end
+      db.create_table(:identities) do
+        Integer :id
+        Integer :principal_id
+      end
+      db.create_table(:identity_group_memberships) do
+        Integer :principal_id
+        Integer :group_id
+      end
+      Legion::Data.const_set(:Model, Module.new) unless defined?(Legion::Data::Model)
+      Legion::Data::Model.const_set(:Apollo, Module.new)
+      Legion::Data::Model::Apollo.const_set(:Entry, Class.new(Sequel::Model(db[:apollo_entries])))
+      Legion::Data::Model::Apollo.const_set(:Relation, Class.new(Sequel::Model(db[:apollo_relations])))
+      input = ::JSON.parse($stdin.read, symbolize_names: true)
+      input[:entries].each { |entry| db[:apollo_entries].insert(entry.merge(embedding: '[1.0,0.0]')) }
+      input[:memberships].each { |membership| db[:identity_group_memberships].insert(membership) }
+      input[:identities].each { |identity| db[:identities].insert(identity) }
+      runner = Object.new.extend(Legion::Extensions::Apollo::Runners::Maintenance)
+      results = Array.new(input[:runs] || 1) { runner.check_corroboration }
+      state = { result: results.last, results: results, entries: db[:apollo_entries].order(:id).all,
+                relations: db[:apollo_relations].all }
+      puts "APOLLO_RESULT=#{::JSON.generate(state)}"
+    RUBY
+  end
+
+  def corroboration_state(entries:, memberships: [], identities: [], runs: 1)
+    stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, '-Ilib', '-Ispec', '-e', corroboration_script,
+      chdir:      File.expand_path('../../../../..', __dir__),
+      stdin_data: JSON.generate(entries: entries, memberships: memberships, identities: identities, runs: runs)
+    )
+    line = stdout.lines.find { |output| output.start_with?('APOLLO_RESULT=') }
+    raise "Corroboration process failed: #{stderr}\n#{stdout}" unless status.success? && line
+
+    JSON.parse(line.delete_prefix('APOLLO_RESULT='), symbolize_names: true)
+  end
+
+  it 'rejects other domains, inactive states, other content types, and dependent sources' do
+    state = corroboration_state(entries: [
+                                  candidate,
+                                  confirmed.merge(knowledge_domain: 'general'),
+                                  confirmed.merge(id: 3, status: 'archived'),
+                                  confirmed.merge(id: 4, status: 'disputed'),
+                                  confirmed.merge(id: 5, content_type: 'concept'),
+                                  confirmed.merge(id: 6, source_provider: 'openai'),
+                                  confirmed.merge(id: 7, source_channel: 'source-a')
+                                ])
+
+    expect(state[:result]).to include(success: true, promoted: 0)
+    expect(state[:entries].first).to include(status: 'candidate', confidence: 0.5)
+    expect(state[:relations]).to eq([])
+  end
+
+  it 'corroborates private knowledge only with eligible evidence owned by the same principal' do
+    state = corroboration_state(entries: [
+                                  candidate.merge(access_scope: 'private', identity_principal_id: 42),
+                                  confirmed.merge(access_scope: 'private', identity_principal_id: 99),
+                                  confirmed.merge(id: 3, access_scope: 'private', identity_principal_id: 42, knowledge_domain: 'other'),
+                                  confirmed.merge(id: 4, access_scope: 'private', identity_principal_id: 42)
+                                ])
+
+    expect(state[:result]).to include(success: true, promoted: 1)
+    expect(state[:entries].first).to include(status: 'confirmed', confidence: 0.8)
+    expect(state[:relations]).to contain_exactly(hash_including(from_entry_id: 1, to_entry_id: 4, relation_type: 'similar_to'))
+  end
+
+  it 'requires shared identity-group membership for team corroboration' do
+    state = corroboration_state(
+      entries:     [candidate.merge(access_scope: 'team', identity_principal_id: 42),
+                    confirmed.merge(access_scope: 'team', identity_principal_id: 77),
+                    confirmed.merge(id: 3, access_scope: 'team', identity_principal_id: 99)],
+      memberships: [{ principal_id: 42, group_id: 7 }, { principal_id: 99, group_id: 7 }, { principal_id: 77, group_id: 8 }]
+    )
+
+    expect(state[:result]).to include(success: true, promoted: 1)
+    expect(state[:relations]).to contain_exactly(hash_including(from_entry_id: 1, to_entry_id: 3))
+  end
+
+  it 'does not corroborate private knowledge with an unresolved owner' do
+    state = corroboration_state(entries: [candidate.merge(access_scope: 'private'),
+                                          confirmed.merge(access_scope: 'private', identity_principal_id: 42)])
+
+    expect(state[:result]).to include(success: true, promoted: 0)
+    expect(state[:entries].first[:status]).to eq('candidate')
+    expect(state[:relations]).to eq([])
+  end
+
+  it 'does not use private evidence to promote a global entry' do
+    state = corroboration_state(entries: [candidate.merge(identity_principal_id: 42),
+                                          confirmed.merge(access_scope: 'private', identity_principal_id: 42)])
+
+    expect(state[:result]).to include(success: true, promoted: 0)
+    expect(state[:entries].first[:confidence]).to eq(0.5)
+    expect(state[:relations]).to eq([])
+  end
+
+  it 'recognizes private ownership through the existing identity-to-principal mapping' do
+    state = corroboration_state(
+      entries:    [candidate.merge(access_scope: 'private', identity_principal_id: 42),
+                   confirmed.merge(access_scope: 'private', identity_id: 70)],
+      identities: [{ id: 70, principal_id: 42 }]
+    )
+
+    expect(state[:result]).to include(success: true, promoted: 1)
+    expect(state[:relations]).to contain_exactly(hash_including(from_entry_id: 1, to_entry_id: 2))
+  end
+
+  it 'bootstraps exactly one fresh-store confirmation from independent candidate evidence' do
+    state = corroboration_state(
+      entries: [candidate, candidate.merge(id: 2, source_provider: 'claude', source_channel: 'source-b')],
+      runs:    2
+    )
+
+    expect(state[:results]).to include(hash_including(promoted: 1), hash_including(promoted: 0))
+    expect(state[:entries].map { |entry| entry[:status] }).to eq(%w[confirmed candidate])
+    expect(state[:relations]).to contain_exactly(hash_including(from_entry_id: 1, to_entry_id: 2, relation_type: 'similar_to'))
+  end
+
+  it 'does not bootstrap confirmation from the same provider or source channel' do
+    same_provider = corroboration_state(
+      entries: [candidate, candidate.merge(id: 2, source_channel: 'source-b')]
+    )
+    same_channel = corroboration_state(
+      entries: [candidate, candidate.merge(id: 2, source_provider: 'claude')]
+    )
+
+    expect(same_provider[:result]).to include(success: true, promoted: 0)
+    expect(same_channel[:result]).to include(success: true, promoted: 0)
+    expect(same_provider[:relations]).to eq([])
+    expect(same_channel[:relations]).to eq([])
+  end
+
+  it 'does not use candidate evidence owned by another private principal to bootstrap confirmation' do
+    state = corroboration_state(
+      entries: [candidate.merge(access_scope: 'private', identity_principal_id: 42),
+                candidate.merge(id: 2, access_scope: 'private', identity_principal_id: 99,
+                                source_provider: 'claude', source_channel: 'source-b')]
+    )
+
+    expect(state[:result]).to include(success: true, promoted: 0)
+    expect(state[:entries].map { |entry| entry[:status] }).to all(eq('candidate'))
+    expect(state[:relations]).to eq([])
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'json'
+
+RSpec.describe 'Apollo GAS relation persistence' do
+  let(:deposit_script) do
+    <<~'RUBY'
+      require 'sequel'
+      require 'rspec'
+      require 'spec_helper'
+      require 'json'
+      require 'legion/extensions/apollo/helpers/writeback'
+      require 'legion/extensions/apollo/runners/gas'
+      db = Sequel.sqlite
+      db.create_table(:apollo_entries) do
+        primary_key :id
+        String :content
+        String :content_hash, unique: true
+        String :content_type
+        String :status
+        String :access_scope
+        Integer :identity_principal_id
+        Float :confidence
+      end
+      db.create_table(:apollo_relations) do
+        primary_key :id
+        foreign_key :from_entry_id, :apollo_entries, null: false
+        foreign_key :to_entry_id, :apollo_entries, null: false
+        String :relation_type
+        String :source_agent
+        Float :weight
+        check(Sequel.~(relation_type: 'causes'))
+      end
+      db.create_table(:apollo_expertise) { primary_key :id }
+      db.create_table(:apollo_access_logs) { primary_key :id }
+      Legion::Data.const_set(:Model, Module.new) unless defined?(Legion::Data::Model)
+      Legion::Data::Model.const_set(:Apollo, Module.new)
+      { Entry: :apollo_entries, Relation: :apollo_relations, Expertise: :apollo_expertise,
+        AccessLog: :apollo_access_logs }.each do |name, table|
+        Legion::Data::Model::Apollo.const_set(name, Class.new(Sequel::Model(db[table])))
+      end
+      input = ::JSON.parse($stdin.read, symbolize_names: true)
+      input[:entries].each do |entry|
+        db[:apollo_entries].insert(entry.merge(content_hash: Legion::Extensions::Apollo::Helpers::Writeback.content_hash(entry[:content])))
+      end
+      knowledge = Legion::Extensions::Apollo::Runners::Knowledge
+      knowledge.extend(knowledge)
+      result = Legion::Extensions::Apollo::Runners::Gas.phase_deposit(
+        input[:facts], [], input[:relations], [], { request_id: 'gas-regression' }
+      )
+      puts "APOLLO_RESULT=#{::JSON.generate(result: result, relations: db[:apollo_relations].all)}"
+    RUBY
+  end
+
+  def gas_deposit_state(entries:, facts:, relations:)
+    stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, '-Ilib', '-Ispec', '-e', deposit_script,
+      chdir:      File.expand_path('../../../../..', __dir__),
+      stdin_data: JSON.generate(entries: entries, facts: facts, relations: relations)
+    )
+    line = stdout.lines.find { |output| output.start_with?('APOLLO_RESULT=') }
+    raise "GAS deposit process failed: #{stderr}\n#{stdout}" unless status.success? && line
+
+    JSON.parse(line.delete_prefix('APOLLO_RESULT='), symbolize_names: true)
+  end
+
+  it 'links successful deduplicated facts safely and continues after an independent relation write fails' do
+    entry = { content_type: 'fact', status: 'candidate', access_scope: 'global', confidence: 0.5 }
+    entries = [entry.merge(id: 1, content: 'stored fact'), entry.merge(id: 2, content: 'target evidence'),
+               entry.merge(id: 3, content: 'private evidence', access_scope: 'private', identity_principal_id: 99),
+               entry.merge(id: 4, content: 'second fact')]
+    facts = [{ content: 'stored fact', content_type: :fact }, { content: '', content_type: :fact },
+             { content: 'second fact', content_type: :fact }]
+    relation = { from_content: 'stored fact', to_id: 2, relation_type: 'supports_by', confidence: 0.9 }
+    relations = [relation, relation.dup, relation.merge(from_content: ''), relation.merge(to_id: 999),
+                 relation.merge(to_id: 1), relation.merge(to_id: 3), relation.merge(confidence: 0.2),
+                 relation.merge(relation_type: 'unsupported'), relation.merge(from_content: 'second fact', relation_type: 'causes'),
+                 relation.merge(from_content: 'second fact', relation_type: 'depends_on')]
+
+    state = gas_deposit_state(entries: entries, facts: facts, relations: relations)
+
+    expect(state[:result]).to include(deposited: 2, failed: 1, facts: 2, synthesis: 0,
+                                      relations: 2, relations_failed: 3, relations_skipped: 5)
+    expect(state[:relations]).to contain_exactly(
+      hash_including(from_entry_id: 1, to_entry_id: 2, relation_type: 'supports_by'),
+      hash_including(from_entry_id: 4, to_entry_id: 2, relation_type: 'depends_on')
+    )
+  end
+end

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

@@ -17,19 +17,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas do
       }
     end
 
-    it 'runs all 6 phases in order' do
-      allow(described_class).to receive(:phase_comprehend).and_return([{ content: 'fact', content_type: :fact }])
-      allow(described_class).to receive(:phase_extract).and_return([{ name: 'pgvector', type: 'technology' }])
-      allow(described_class).to receive(:phase_relate).and_return([])
-      allow(described_class).to receive(:phase_synthesize).and_return([])
-      allow(described_class).to receive(:phase_deposit).and_return({ deposited: 1 })
-      allow(described_class).to receive(:phase_anticipate).and_return([])
-
-      result = described_class.process(audit_event)
-      expect(result).to be_a(Hash)
-      expect(result[:phases_completed]).to eq(6)
-    end
-
     it 'skips when audit event has no content' do
       result = described_class.process({ request_id: 'req_abc' })
       expect(result[:phases_completed]).to eq(0)
@@ -80,29 +67,36 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas do
     end
   end
 
-  describe '.phase_relate' do
-    it 'returns empty array (stub)' do
-      expect(described_class.phase_relate([], [])).to eq([])
-    end
-  end
-
-  describe '.phase_synthesize' do
-    it 'returns empty array (stub)' do
-      expect(described_class.phase_synthesize([], [])).to eq([])
-    end
-  end
+  describe '.phase_deposit' do
+    it 'reports unavailable writes as failures rather than successful deposits' do
+      hide_const('Legion::Extensions::Apollo::Runners::Knowledge')
+      result = described_class.phase_deposit([{ content: 'fact' }], [], [{ to_id: 'target' }],
+                                             [{ content: 'synthesis' }], { request_id: 'req_1' })
 
-  describe '.phase_anticipate' do
-    it 'returns empty array (stub)' do
-      expect(described_class.phase_anticipate([], [])).to eq([])
+      expect(result).to include(deposited: 0, failed: 2, relations: 0, relations_failed: 1)
     end
-  end
 
-  describe '.phase_deposit' do
-    it 'returns deposited 0 when Knowledge not defined' do
-      hide_const('Legion::Extensions::Apollo::Runners::Knowledge') if defined?(Legion::Extensions::Apollo::Runners::Knowledge)
-      result = described_class.phase_deposit([], [], [], [], { request_id: 'req_1' })
-      expect(result).to eq({ deposited: 0 })
+    it 'counts only successful fact and synthesis writes with an entry ID' do
+      knowledge = double('Knowledge')
+      stub_const('Legion::Extensions::Apollo::Runners::Knowledge', knowledge)
+      allow(knowledge).to receive(:handle_ingest) do |content:, **|
+        case content
+        when 'stored fact' then { success: true, entry_id: 41 }
+        when 'stored synthesis' then { success: true, entry_id: 42 }
+        when 'missing ID' then { success: true }
+        else { success: false, error: 'write failed' }
+        end
+      end
+      facts = [{ content: 'stored fact', content_type: :fact }, { content: 'failed fact', content_type: :fact }]
+      synthesis = [
+        { content: 'stored synthesis', content_type: :inference, source_indices: [0] },
+        { content: 'failed synthesis', content_type: :implication, source_indices: [0] },
+        { content: 'missing ID', content_type: :connection, source_indices: [0] }
+      ]
+
+      result = described_class.phase_deposit(facts, [], [], synthesis, { request_id: 'req_1' })
+
+      expect(result).to include(deposited: 2, failed: 3, facts: 1, synthesis: 1, relations: 0)
     end
   end
 end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'json'
+
+RSpec.describe 'Apollo ingest transaction' do
+  let(:ingest_script) do
+    <<~'RUBY'
+      require 'sequel'
+      require 'rspec'
+      require 'sequel/extensions/pg_array'
+      require 'spec_helper'
+      require 'json'
+      require 'legion/extensions/apollo/runners/knowledge'
+      db = Sequel.sqlite
+      db.create_table(:apollo_entries) do
+        primary_key :id
+        String :content
+        String :content_type
+        Float :confidence
+        String :source_agent
+        String :source_provider
+        String :source_channel
+        String :source_context
+        String :tags
+        String :status
+        String :knowledge_domain
+        String :submitted_by
+        String :submitted_from
+        String :content_hash
+        String :access_scope
+        Integer :identity_principal_id
+        Integer :identity_id
+        String :identity_canonical_name
+        String :embedding
+        DateTime :created_at
+        DateTime :updated_at
+        check(Sequel.lit("content != 'entry failure'"))
+      end
+      db.create_table(:apollo_expertise) do
+        primary_key :id
+        String :agent_id
+        String :domain
+        Float :proficiency
+        Integer :entry_count
+        DateTime :last_active_at
+        check(Sequel.lit("agent_id != 'fail-expertise'"))
+      end
+      db.create_table(:apollo_access_log) do
+        primary_key :id
+        Integer :entry_id
+        String :agent_id
+        String :action
+        check(Sequel.lit("agent_id != 'fail-audit'"))
+      end
+      input = ::JSON.parse($stdin.read, symbolize_names: true)
+      Legion::Data.const_set(:Model, Module.new) unless defined?(Legion::Data::Model)
+      Legion::Data::Model.const_set(:Apollo, Module.new)
+      { Entry: :apollo_entries, Expertise: :apollo_expertise, AccessLog: :apollo_access_log }.each do |name, table|
+        next if name == input[:missing]&.to_sym
+
+        Legion::Data::Model::Apollo.const_set(name, Class.new(Sequel::Model(db[table])))
+      end
+      runner = Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge)
+      result = runner.handle_ingest(
+        content: input[:content], content_type: :fact, source_agent: input[:source_agent], embedding: nil
+      )
+      state = { result: result, entries: db[:apollo_entries].count,
+                expertise: db[:apollo_expertise].count, access_logs: db[:apollo_access_log].count }
+      puts "APOLLO_RESULT=#{::JSON.generate(state)}"
+    RUBY
+  end
+
+  def ingest_state(content:, source_agent: 'success', missing: nil)
+    stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, '-Ilib', '-Ispec', '-e', ingest_script,
+      chdir:      File.expand_path('../../../../..', __dir__),
+      stdin_data: JSON.generate(content: content, source_agent: source_agent, missing: missing)
+    )
+    line = stdout.lines.find { |output| output.start_with?('APOLLO_RESULT=') }
+    raise "Ingest transaction process failed: #{stderr}\n#{stdout}" unless status.success? && line
+
+    JSON.parse(line.delete_prefix('APOLLO_RESULT='), symbolize_names: true)
+  end
+
+  it 'commits the entry, expertise bookkeeping, and access log as one successful ingest' do
+    state = ingest_state(content: 'committed knowledge')
+
+    expect(state[:result]).to include(success: true, status: 'candidate')
+    expect(state).to include(entries: 1, expertise: 1, access_logs: 1)
+  end
+
+  it 'rolls back all persistence when any synchronous ingest side effect fails' do
+    entry_failure = ingest_state(content: 'entry failure')
+    expertise_failure = ingest_state(content: 'expertise failure', source_agent: 'fail-expertise')
+    audit_failure = ingest_state(content: 'audit failure', source_agent: 'fail-audit')
+
+    [entry_failure, expertise_failure, audit_failure].each do |state|
+      expect(state[:result]).to include(success: false)
+      expect(state).to include(entries: 0, expertise: 0, access_logs: 0)
+    end
+  end
+  it 'rejects missing required auxiliary models before creating the primary entry' do
+    missing_expertise = ingest_state(content: 'unavailable expertise', missing: :Expertise)
+    missing_access_log = ingest_state(content: 'unavailable access log', missing: :AccessLog)
+
+    [missing_expertise, missing_access_log].each do |state|
+      expect(state[:result]).to include(success: false, error: 'apollo_data_not_available')
+      expect(state).to include(entries: 0, expertise: 0, access_logs: 0)
+    end
+  end
+end