lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Entrainment::Runners::CognitiveEntrainment do
+  let(:runner_host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#create_entrainment_pairing' do
+    it 'creates a pairing' do
+      result = runner_host.create_entrainment_pairing(
+        agent_a: 'alpha', agent_b: 'beta', domain: :reasoning
+      )
+      expect(result[:success]).to be true
+      expect(result[:pairing_id]).to be_a(String)
+    end
+  end
+
+  describe '#record_entrainment_interaction' do
+    it 'records an interaction' do
+      created = runner_host.create_entrainment_pairing(
+        agent_a: 'alpha', agent_b: 'beta', domain: :reasoning
+      )
+      result = runner_host.record_entrainment_interaction(
+        pairing_id: created[:pairing_id], aligned: true
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#pairings_for_agent' do
+    it 'finds pairings for an agent' do
+      runner_host.create_entrainment_pairing(
+        agent_a: 'alpha', agent_b: 'beta', domain: :reasoning
+      )
+      result = runner_host.pairings_for_agent(agent_id: 'alpha')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#entrained_partners' do
+    it 'returns entrained partners' do
+      result = runner_host.entrained_partners(agent_id: 'alpha')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#strongest_entrainment_pairings' do
+    it 'returns strongest pairings' do
+      result = runner_host.strongest_entrainment_pairings(limit: 3)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#domain_entrainment' do
+    it 'returns pairings by domain' do
+      result = runner_host.domain_entrainment(domain: :reasoning)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#overall_entrainment_level' do
+    it 'returns overall synchrony' do
+      result = runner_host.overall_entrainment_level
+      expect(result[:success]).to be true
+      expect(result).to include(:overall_synchrony)
+    end
+  end
+
+  describe '#update_cognitive_entrainment' do
+    it 'runs drift and prune' do
+      result = runner_host.update_cognitive_entrainment
+      expect(result[:success]).to be true
+      expect(result).to include(:pruned)
+    end
+  end
+
+  describe '#cognitive_entrainment_stats' do
+    it 'returns stats' do
+      result = runner_host.cognitive_entrainment_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_pairings, :entrained_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/governance/actors/vote_timeout_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/social/governance/actors/vote_timeout'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Actor::VoteTimeout do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Social::Governance::Runners::Governance }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'timeout_proposals' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 300 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

data/spec/legion/extensions/agentic/social/governance/client_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/governance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Client do
+  it 'responds to governance runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:create_proposal)
+    expect(client).to respond_to(:vote_on_proposal)
+    expect(client).to respond_to(:get_proposal)
+    expect(client).to respond_to(:open_proposals)
+    expect(client).to respond_to(:validate_action)
+  end
+end

data/spec/legion/extensions/agentic/social/governance/helpers/layers_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/governance/helpers/layers'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Helpers::Layers do
+  describe 'GOVERNANCE_LAYERS' do
+    it 'contains four layers as symbols' do
+      expect(described_class::GOVERNANCE_LAYERS.size).to eq(4)
+    end
+
+    it 'includes agent_validation' do
+      expect(described_class::GOVERNANCE_LAYERS).to include(:agent_validation)
+    end
+
+    it 'includes anomaly_detection' do
+      expect(described_class::GOVERNANCE_LAYERS).to include(:anomaly_detection)
+    end
+
+    it 'includes human_deliberation' do
+      expect(described_class::GOVERNANCE_LAYERS).to include(:human_deliberation)
+    end
+
+    it 'includes transparency' do
+      expect(described_class::GOVERNANCE_LAYERS).to include(:transparency)
+    end
+
+    it 'is frozen' do
+      expect(described_class::GOVERNANCE_LAYERS).to be_frozen
+    end
+  end
+
+  describe 'PROPOSAL_CATEGORIES' do
+    it 'contains five categories' do
+      expect(described_class::PROPOSAL_CATEGORIES.size).to eq(5)
+    end
+
+    it 'includes policy_change' do
+      expect(described_class::PROPOSAL_CATEGORIES).to include(:policy_change)
+    end
+
+    it 'includes resource_allocation' do
+      expect(described_class::PROPOSAL_CATEGORIES).to include(:resource_allocation)
+    end
+
+    it 'includes access_control' do
+      expect(described_class::PROPOSAL_CATEGORIES).to include(:access_control)
+    end
+
+    it 'includes emergency' do
+      expect(described_class::PROPOSAL_CATEGORIES).to include(:emergency)
+    end
+
+    it 'includes protocol_update' do
+      expect(described_class::PROPOSAL_CATEGORIES).to include(:protocol_update)
+    end
+
+    it 'is frozen' do
+      expect(described_class::PROPOSAL_CATEGORIES).to be_frozen
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'sets MIN_COUNCIL_SIZE to 3' do
+      expect(described_class::MIN_COUNCIL_SIZE).to eq(3)
+    end
+
+    it 'sets QUORUM_FRACTION to 0.66' do
+      expect(described_class::QUORUM_FRACTION).to eq(0.66)
+    end
+
+    it 'sets VOTE_TIMEOUT to 86400' do
+      expect(described_class::VOTE_TIMEOUT).to eq(86_400)
+    end
+  end
+
+  describe '.valid_layer?' do
+    it 'returns true for agent_validation' do
+      expect(described_class.valid_layer?(:agent_validation)).to be true
+    end
+
+    it 'returns true for anomaly_detection' do
+      expect(described_class.valid_layer?(:anomaly_detection)).to be true
+    end
+
+    it 'returns true for human_deliberation' do
+      expect(described_class.valid_layer?(:human_deliberation)).to be true
+    end
+
+    it 'returns true for transparency' do
+      expect(described_class.valid_layer?(:transparency)).to be true
+    end
+
+    it 'returns false for unknown layer symbol' do
+      expect(described_class.valid_layer?(:unknown)).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_layer?(nil)).to be false
+    end
+
+    it 'returns false for string version of valid layer' do
+      expect(described_class.valid_layer?('agent_validation')).to be false
+    end
+  end
+
+  describe '.valid_category?' do
+    it 'returns true for policy_change' do
+      expect(described_class.valid_category?(:policy_change)).to be true
+    end
+
+    it 'returns true for resource_allocation' do
+      expect(described_class.valid_category?(:resource_allocation)).to be true
+    end
+
+    it 'returns true for access_control' do
+      expect(described_class.valid_category?(:access_control)).to be true
+    end
+
+    it 'returns true for emergency' do
+      expect(described_class.valid_category?(:emergency)).to be true
+    end
+
+    it 'returns true for protocol_update' do
+      expect(described_class.valid_category?(:protocol_update)).to be true
+    end
+
+    it 'returns false for unknown category' do
+      expect(described_class.valid_category?(:invalid)).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_category?(nil)).to be false
+    end
+
+    it 'returns false for string version of valid category' do
+      expect(described_class.valid_category?('emergency')).to be false
+    end
+  end
+
+  describe '.quorum_met?' do
+    context 'when council_size is below minimum' do
+      it 'returns false for council_size of 2' do
+        expect(described_class.quorum_met?(2, 2)).to be false
+      end
+
+      it 'returns false for council_size of 1' do
+        expect(described_class.quorum_met?(1, 1)).to be false
+      end
+
+      it 'returns false for council_size of 0' do
+        expect(described_class.quorum_met?(0, 0)).to be false
+      end
+    end
+
+    context 'with minimum council size of 3' do
+      it 'returns true when 2 of 3 vote (meets ceil(3 * 0.66) = 2)' do
+        expect(described_class.quorum_met?(2, 3)).to be true
+      end
+
+      it 'returns true when all 3 vote' do
+        expect(described_class.quorum_met?(3, 3)).to be true
+      end
+
+      it 'returns false when only 1 of 3 vote' do
+        expect(described_class.quorum_met?(1, 3)).to be false
+      end
+    end
+
+    context 'with larger council sizes' do
+      it 'requires ceil(4 * 0.66) = 3 votes for council of 4' do
+        expect(described_class.quorum_met?(3, 4)).to be true
+        expect(described_class.quorum_met?(2, 4)).to be false
+      end
+
+      it 'requires ceil(5 * 0.66) = 4 votes for council of 5' do
+        expect(described_class.quorum_met?(4, 5)).to be true
+        expect(described_class.quorum_met?(3, 5)).to be false
+      end
+
+      it 'requires ceil(9 * 0.66) = 6 votes for council of 9' do
+        expect(described_class.quorum_met?(6, 9)).to be true
+        expect(described_class.quorum_met?(5, 9)).to be false
+      end
+    end
+
+    it 'returns false for zero votes regardless of council size' do
+      expect(described_class.quorum_met?(0, 3)).to be false
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/governance/helpers/proposal_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/governance/helpers/layers'
+require 'legion/extensions/agentic/social/governance/helpers/proposal'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Helpers::Proposal do
+  subject(:proposal_store) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with an empty proposals hash' do
+      expect(proposal_store.proposals).to eq({})
+    end
+  end
+
+  describe '#create' do
+    let(:created_id) do
+      proposal_store.create(category: :policy_change, description: 'Enable new policy', proposer: 'agent-1')
+    end
+
+    it 'returns a UUID string' do
+      expect(created_id).to match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+    end
+
+    it 'stores the proposal under the returned ID' do
+      expect(proposal_store.proposals[created_id]).not_to be_nil
+    end
+
+    it 'stores the correct category' do
+      expect(proposal_store.proposals[created_id][:category]).to eq(:policy_change)
+    end
+
+    it 'stores the correct description' do
+      expect(proposal_store.proposals[created_id][:description]).to eq('Enable new policy')
+    end
+
+    it 'stores the correct proposer' do
+      expect(proposal_store.proposals[created_id][:proposer]).to eq('agent-1')
+    end
+
+    it 'defaults council_size to MIN_COUNCIL_SIZE' do
+      expect(proposal_store.proposals[created_id][:council_size])
+        .to eq(Legion::Extensions::Agentic::Social::Governance::Helpers::Layers::MIN_COUNCIL_SIZE)
+    end
+
+    it 'uses the provided council_size when specified' do
+      id = proposal_store.create(category: :emergency, description: 'urgent', proposer: 'agent-x', council_size: 7)
+      expect(proposal_store.proposals[id][:council_size]).to eq(7)
+    end
+
+    it 'initializes with status :open' do
+      expect(proposal_store.proposals[created_id][:status]).to eq(:open)
+    end
+
+    it 'initializes votes_for as empty array' do
+      expect(proposal_store.proposals[created_id][:votes_for]).to eq([])
+    end
+
+    it 'initializes votes_against as empty array' do
+      expect(proposal_store.proposals[created_id][:votes_against]).to eq([])
+    end
+
+    it 'sets created_at to a Time object' do
+      expect(proposal_store.proposals[created_id][:created_at]).to be_a(Time)
+    end
+
+    it 'sets resolved_at to nil initially' do
+      expect(proposal_store.proposals[created_id][:resolved_at]).to be_nil
+    end
+
+    it 'generates unique IDs for separate calls' do
+      id1 = proposal_store.create(category: :policy_change, description: 'a', proposer: 'x')
+      id2 = proposal_store.create(category: :policy_change, description: 'b', proposer: 'y')
+      expect(id1).not_to eq(id2)
+    end
+  end
+
+  describe '#get' do
+    it 'returns the proposal hash for a valid ID' do
+      id = proposal_store.create(category: :policy_change, description: 'test', proposer: 'agent-1')
+      result = proposal_store.get(id)
+      expect(result[:proposal_id]).to eq(id)
+    end
+
+    it 'returns nil for an unknown ID' do
+      expect(proposal_store.get('nonexistent-uuid')).to be_nil
+    end
+  end
+
+  describe '#open_proposals' do
+    it 'returns empty array when no proposals exist' do
+      expect(proposal_store.open_proposals).to eq([])
+    end
+
+    it 'returns all open proposals' do
+      proposal_store.create(category: :policy_change, description: 'first', proposer: 'a1')
+      proposal_store.create(category: :emergency, description: 'second', proposer: 'a2')
+      expect(proposal_store.open_proposals.size).to eq(2)
+    end
+
+    it 'excludes resolved proposals' do
+      id = proposal_store.create(category: :policy_change, description: 'vote me', proposer: 'a1', council_size: 3)
+      proposal_store.vote(id, voter: 'v1', approve: true)
+      proposal_store.vote(id, voter: 'v2', approve: true)
+      expect(proposal_store.open_proposals).to be_empty
+    end
+  end
+
+  describe '#vote' do
+    let(:proposal_id) do
+      proposal_store.create(category: :policy_change, description: 'test', proposer: 'agent-1', council_size: 3)
+    end
+
+    it 'returns nil for an unknown proposal ID' do
+      expect(proposal_store.vote('no-such-id', voter: 'v1', approve: true)).to be_nil
+    end
+
+    it 'returns :already_voted when the same voter votes twice' do
+      proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+      result = proposal_store.vote(proposal_id, voter: 'v1', approve: false)
+      expect(result).to eq(:already_voted)
+    end
+
+    it 'prevents double voting even when switching approve/reject' do
+      proposal_store.vote(proposal_id, voter: 'v1', approve: false)
+      result = proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+      expect(result).to eq(:already_voted)
+    end
+
+    it 'adds approve vote to votes_for' do
+      proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+      expect(proposal_store.proposals[proposal_id][:votes_for]).to include('v1')
+    end
+
+    it 'adds reject vote to votes_against' do
+      proposal_store.vote(proposal_id, voter: 'v1', approve: false)
+      expect(proposal_store.proposals[proposal_id][:votes_against]).to include('v1')
+    end
+
+    it 'returns :pending when quorum is not yet met' do
+      result = proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+      expect(result).to eq(:pending)
+    end
+
+    context 'when quorum for approval is met' do
+      it 'returns :approved and sets status' do
+        proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+        result = proposal_store.vote(proposal_id, voter: 'v2', approve: true)
+        expect(result).to eq(:approved)
+        expect(proposal_store.proposals[proposal_id][:status]).to eq(:approved)
+      end
+
+      it 'sets resolved_at on approval' do
+        proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+        proposal_store.vote(proposal_id, voter: 'v2', approve: true)
+        expect(proposal_store.proposals[proposal_id][:resolved_at]).to be_a(Time)
+      end
+    end
+
+    context 'when quorum for rejection is met' do
+      it 'returns :rejected when enough votes against' do
+        proposal_store.vote(proposal_id, voter: 'v1', approve: false)
+        result = proposal_store.vote(proposal_id, voter: 'v2', approve: false)
+        expect(result).to eq(:rejected)
+        expect(proposal_store.proposals[proposal_id][:status]).to eq(:rejected)
+      end
+
+      it 'sets resolved_at on rejection' do
+        proposal_store.vote(proposal_id, voter: 'v1', approve: false)
+        proposal_store.vote(proposal_id, voter: 'v2', approve: false)
+        expect(proposal_store.proposals[proposal_id][:resolved_at]).to be_a(Time)
+      end
+
+      it 'returns :rejected when all council members voted and no quorum for approval' do
+        proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+        proposal_store.vote(proposal_id, voter: 'v2', approve: false)
+        result = proposal_store.vote(proposal_id, voter: 'v3', approve: false)
+        expect(result).to eq(:rejected)
+      end
+    end
+
+    it 'returns nil when voting on a resolved (approved) proposal' do
+      proposal_store.vote(proposal_id, voter: 'v1', approve: true)
+      proposal_store.vote(proposal_id, voter: 'v2', approve: true)
+      result = proposal_store.vote(proposal_id, voter: 'v3', approve: true)
+      expect(result).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/governance/runners/governance_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/governance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Runners::Governance do
+  let(:client) { Legion::Extensions::Agentic::Social::Governance::Client.new }
+
+  describe '#create_proposal' do
+    it 'creates a proposal' do
+      result = client.create_proposal(category: :policy_change, description: 'test', proposer: 'agent-1')
+      expect(result[:proposal_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:status]).to eq(:open)
+    end
+
+    it 'rejects invalid category' do
+      result = client.create_proposal(category: :invalid, description: 'test', proposer: 'agent-1')
+      expect(result[:error]).to eq(:invalid_category)
+    end
+  end
+
+  describe '#vote_on_proposal' do
+    it 'records a vote' do
+      prop = client.create_proposal(category: :policy_change, description: 'test', proposer: 'agent-1', council_size: 3)
+      result = client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'agent-2', approve: true)
+      expect(result[:voted]).to be true
+    end
+
+    it 'prevents double voting' do
+      prop = client.create_proposal(category: :policy_change, description: 'test', proposer: 'agent-1', council_size: 3)
+      client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'agent-2', approve: true)
+      result = client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'agent-2', approve: true)
+      expect(result[:error]).to eq(:already_voted)
+    end
+
+    it 'approves with quorum' do
+      prop = client.create_proposal(category: :policy_change, description: 'test', proposer: 'agent-1', council_size: 3)
+      client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'v1', approve: true)
+      result = client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'v2', approve: true)
+      expect(result[:resolution]).to eq(:approved)
+    end
+  end
+
+  describe '#validate_action' do
+    it 'allows agent_validation' do
+      result = client.validate_action(layer: :agent_validation, action: 'test')
+      expect(result[:allowed]).to be true
+    end
+
+    it 'blocks human_deliberation' do
+      result = client.validate_action(layer: :human_deliberation, action: 'test')
+      expect(result[:allowed]).to be false
+    end
+
+    it 'rejects invalid layer' do
+      result = client.validate_action(layer: :invalid, action: 'test')
+      expect(result[:error]).to eq(:invalid_layer)
+    end
+  end
+
+  describe '#open_proposals' do
+    it 'lists open proposals' do
+      client.create_proposal(category: :policy_change, description: 'test', proposer: 'agent-1')
+      result = client.open_proposals
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#timeout_proposals' do
+    it 'returns zero timed_out when no proposals exist' do
+      result = client.timeout_proposals
+      expect(result[:checked]).to eq(0)
+      expect(result[:timed_out]).to eq(0)
+      expect(result[:timed_out_ids]).to eq([])
+    end
+
+    it 'returns zero timed_out for recently created proposals' do
+      client.create_proposal(category: :policy_change, description: 'fresh', proposer: 'agent-1')
+      result = client.timeout_proposals
+      expect(result[:timed_out]).to eq(0)
+    end
+
+    it 'times out proposals older than VOTE_TIMEOUT' do
+      prop = client.create_proposal(category: :policy_change, description: 'old', proposer: 'agent-1')
+      store = client.instance_variable_get(:@proposal_store)
+      store.proposals[prop[:proposal_id]][:created_at] = Time.now.utc - (Legion::Extensions::Agentic::Social::Governance::Helpers::Layers::VOTE_TIMEOUT + 1)
+      result = client.timeout_proposals
+      expect(result[:timed_out]).to eq(1)
+      expect(result[:timed_out_ids]).to include(prop[:proposal_id])
+    end
+
+    it 'does not time out already-resolved proposals' do
+      prop = client.create_proposal(category: :policy_change, description: 'resolved', proposer: 'agent-1', council_size: 3)
+      store = client.instance_variable_get(:@proposal_store)
+      store.proposals[prop[:proposal_id]][:created_at] = Time.now.utc - (Legion::Extensions::Agentic::Social::Governance::Helpers::Layers::VOTE_TIMEOUT + 1)
+      client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'v1', approve: true)
+      client.vote_on_proposal(proposal_id: prop[:proposal_id], voter: 'v2', approve: true)
+      result = client.timeout_proposals
+      expect(result[:timed_out]).to eq(0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/governance/runners/shadow_ai_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Governance::Runners::ShadowAi do
+  let(:host) { Object.new.extend(described_class) }
+
+  describe '#check_llm_bypass_indicators' do
+    it 'detects direct API key when provider not enabled' do
+      allow(ENV).to receive(:key?).and_call_original
+      allow(ENV).to receive(:key?).with('OPENAI_API_KEY').and_return(true)
+      allow(ENV).to receive(:key?).with('ANTHROPIC_API_KEY').and_return(false)
+      allow(Legion::Settings).to receive(:[]).with(:llm).and_return(
+        { providers: { openai: { enabled: false } } }
+      )
+      result = host.check_llm_bypass_indicators
+      expect(result[:bypassed]).to be true
+      expect(result[:indicators]).to include(:direct_openai_key)
+    end
+
+    it 'returns clean when no bypass indicators' do
+      allow(ENV).to receive(:key?).with('OPENAI_API_KEY').and_return(false)
+      allow(ENV).to receive(:key?).with('ANTHROPIC_API_KEY').and_return(false)
+      result = host.check_llm_bypass_indicators
+      expect(result[:bypassed]).to be false
+      expect(result[:indicators]).to be_empty
+    end
+
+    it 'does not flag when provider is enabled' do
+      allow(ENV).to receive(:key?).and_call_original
+      allow(ENV).to receive(:key?).with('OPENAI_API_KEY').and_return(true)
+      allow(ENV).to receive(:key?).with('ANTHROPIC_API_KEY').and_return(false)
+      allow(Legion::Settings).to receive(:[]).with(:llm).and_return(
+        { providers: { openai: { enabled: true } } }
+      )
+      result = host.check_llm_bypass_indicators
+      expect(result[:bypassed]).to be false
+    end
+  end
+
+  describe '#check_airb_compliance' do
+    it 'returns unavailable when data model not loaded' do
+      result = host.check_airb_compliance
+      expect(result[:source]).to eq(:unavailable)
+    end
+  end
+
+  describe '#full_scan' do
+    it 'returns combined results' do
+      allow(host).to receive(:scan_unregistered_extensions).and_return(
+        { installed: 5, registered: 5, unregistered: [] }
+      )
+      allow(host).to receive(:check_llm_bypass_indicators).and_return(
+        { indicators: [], bypassed: false }
+      )
+      allow(host).to receive(:check_airb_compliance).and_return(
+        { checked: 0, source: :unavailable }
+      )
+
+      result = host.full_scan
+      expect(result[:issues_found]).to be_falsey
+      expect(result[:extensions][:installed]).to eq(5)
+    end
+  end
+end