lex-mesh 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30d95d61132596e1638e9855fb045f20a7b9b0285c63c35766a9e07c776c78d2
-  data.tar.gz: 1e8c6704b51f98cc9c768bd5798b3634badb6491e542a022f75c612a5165aa6a
+  metadata.gz: b16d673e30a813f0fa38f61386eae0e9a72a35cc2b0eedc6b45ced88a4acadf7
+  data.tar.gz: dc7a12c1de2412117ac9ce56c7803626dba16604f9cbfba57ca41e72e55dc3b5
 SHA512:
-  metadata.gz: 7a82cf01be6f79a4c81092f4d5b56fe902e6e6ac933b7dd14fca4b5169ea2aac20a310eb056ced5bc36f0240800ebcc9cfcb5f6d2e6d835606080f969cfb07ca
-  data.tar.gz: a4d0cffdfc0177c59f7899caa8b65fca7c2359e9085903f3fb60b77eb2d7ee2a690aac20ac1c5a71a0ec072bfa10baf6265c3ea697b78fd6b9a454cd93c007f1
+  metadata.gz: 7abe441618ba1fca371412adf3a2a48f16f54adc4130d060369e1fcdc7222a777fcc48e165576e74e4cf1892fdd9a42f4562242523bf2d9e8239cdb8af771b4c
+  data.tar.gz: 61e2b0e8aba072966d10e820db3708ff2c76ecfcda9fc73e99bcd61eff051323c81ea5c1cef0e1c56ce126604369983205f32e732376eab53ad1fae4af1857f5

data/Gemfile

@@ -8,3 +8,4 @@ gem 'base64'
 gem 'ed25519', '~> 1.3'
 gem 'rspec', '~> 3.13'
 gem 'rubocop', '~> 1.75', require: false
+gem 'rubocop-legion', '~> 0.1'

data/lib/legion/extensions/mesh/actors/gossip.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class Gossip < Legion::Extensions::Actors::Every
+        class Gossip < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/actors/gossip_listener.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Actor
+        class GossipListener < Legion::Extensions::Actors::Subscription
+          def runner_class
+            Legion::Extensions::Mesh::Runners::Mesh
+          end
+
+          def runner_function
+            'dispatch_gossip_message'
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def queue
+            Legion::Extensions::Mesh::Transport::Queues::Gossip
+          end
+
+          def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
+            defined?(Legion::Extensions::Mesh::Runners::Mesh) &&
+              Legion.const_defined?(:Transport, false)
+          rescue StandardError => _e
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/actors/heartbeat.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class Heartbeat < Legion::Extensions::Actors::Every
+        class Heartbeat < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/actors/pending_expiry.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class PendingExpiry < Legion::Extensions::Actors::Every
+        class PendingExpiry < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
           def runner_class
             Legion::Extensions::Mesh::Runners::Preferences
           end

data/lib/legion/extensions/mesh/actors/preference_listener.rb

@@ -31,10 +31,10 @@ module Legion
             Legion::Extensions::Mesh::Transport::Queues::Preference
           end
 
-          def enabled?
+          def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
             defined?(Legion::Extensions::Mesh::Runners::Preferences) &&
-              defined?(Legion::Transport)
-          rescue StandardError
+              Legion.const_defined?(:Transport, false)
+          rescue StandardError => _e
             false
           end
         end

data/lib/legion/extensions/mesh/actors/silence_watchdog.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class SilenceWatchdog < Legion::Extensions::Actors::Every
+        class SilenceWatchdog < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/client.rb

@@ -20,7 +20,7 @@ module Legion
 
         def initialize(**opts)
           @opts = opts
-          @mesh_registry = Helpers::Registry.new
+          @mesh_registry = Helpers::Registry.new # rubocop:disable Legion/Singleton/UseInstance
         end
 
         private

data/lib/legion/extensions/mesh/helpers/peer_table.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Helpers
+        class PeerTable
+          DEFAULT_TTL = 60 # seconds
+
+          def initialize(ttl: DEFAULT_TTL)
+            @ttl = ttl
+            @peers = {}
+            @mutex = Mutex.new
+          end
+
+          def upsert(agent_id, data = {})
+            @mutex.synchronize do
+              @peers[agent_id] = data.merge(last_seen_at: Time.now.utc)
+            end
+          end
+
+          def get(agent_id)
+            @mutex.synchronize { @peers[agent_id] }
+          end
+
+          def all
+            @mutex.synchronize { @peers.dup }
+          end
+
+          def expire
+            cutoff = Time.now.utc - @ttl
+            expired = []
+            @mutex.synchronize do
+              @peers.each do |id, entry|
+                next unless entry[:last_seen_at] < cutoff
+
+                expired << id
+              end
+              expired.each { |id| @peers.delete(id) }
+            end
+            expired
+          end
+
+          def count
+            @mutex.synchronize { @peers.size }
+          end
+
+          def remove(agent_id)
+            @mutex.synchronize { @peers.delete(agent_id) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/helpers/peer_verify.rb

@@ -21,21 +21,21 @@ module Legion
               return { valid: false, org_id: org_id, reason: :unknown_peer } unless peer
 
               require 'ed25519'
-              pub_key_b64 = peer[:public_key].sub(/\Aed25519:/, '')
+              pub_key_b64 = peer[:public_key].delete_prefix('ed25519:')
               verify_key  = Ed25519::VerifyKey.new(Base64.strict_decode64(pub_key_b64))
               signature   = Base64.strict_decode64(signed_message[:signature])
               message_bytes = signed_message[:signed_bytes] || json_dump(signed_message[:payload])
               verify_key.verify(signature, message_bytes)
               { valid: true, org_id: org_id }
-            rescue Ed25519::VerifyError
+            rescue Ed25519::VerifyError => _e
               { valid: false, org_id: org_id, reason: :invalid_signature }
             rescue StandardError => e
               { valid: false, org_id: org_id, reason: :error, message: e.message }
             end
 
             def check_rate_limit(org_id)
-              @counters ||= Hash.new { |h, k| h[k] = { count: 0, window_start: Time.now.utc } }
-              counter = @counters[org_id]
+              @counters ||= Hash.new { |h, k| h[k] = { count: 0, window_start: Time.now.utc } } # rubocop:disable ThreadSafety/ClassInstanceVariable
+              counter = @counters[org_id] # rubocop:disable ThreadSafety/ClassInstanceVariable
               peer  = find_peer(org_id)
               limit = peer&.dig(:rate_limit) || 100
 
@@ -51,7 +51,7 @@ module Legion
             end
 
             def reset_counters!
-              @counters = nil
+              @counters = nil # rubocop:disable ThreadSafety/ClassInstanceVariable
             end
 
             private
@@ -65,7 +65,7 @@ module Legion
 
             def json_dump(data)
               if defined?(Legion::JSON)
-                Legion::JSON.dump({ data: data })
+                Legion::JSON.dump({ data: data }) # rubocop:disable Legion/HelperMigration/DirectJson
               else
                 require 'json'
                 ::JSON.dump({ data: data })

data/lib/legion/extensions/mesh/helpers/pending_requests.rb

@@ -21,7 +21,7 @@ module Legion
             end
           end
 
-          def resolve(correlation_id:, result:) # rubocop:disable Naming/PredicateMethod
+          def resolve(correlation_id:, result:)
             entry = @mutex.synchronize { @requests.delete(correlation_id) }
             return false unless entry
 

data/lib/legion/extensions/mesh/helpers/preference_profile.rb

@@ -124,8 +124,8 @@ module Legion
           MESH_CACHE_TTL = 3600 # 1 hour default
 
           def store_mesh_profile(agent_id:, profile:, source_agent_id:)
-            @mesh_cache ||= {}
-            @mesh_cache[agent_id.to_s] = {
+            @mesh_cache ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @mesh_cache[agent_id.to_s] = { # rubocop:disable ThreadSafety/ClassInstanceVariable
               profile:         profile,
               source_agent_id: source_agent_id,
               origin:          :mesh_transfer,
@@ -147,26 +147,26 @@ module Legion
           end
 
           def cached_mesh_profile(agent_id:, ttl: MESH_CACHE_TTL)
-            @mesh_cache ||= {}
-            entry = @mesh_cache[agent_id.to_s]
+            @mesh_cache ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            entry = @mesh_cache[agent_id.to_s] # rubocop:disable ThreadSafety/ClassInstanceVariable
             return nil unless entry
 
             if Time.now - entry[:cached_at] > ttl
-              @mesh_cache.delete(agent_id.to_s)
+              @mesh_cache.delete(agent_id.to_s) # rubocop:disable ThreadSafety/ClassInstanceVariable
               return nil
             end
 
             entry[:profile]
-          rescue StandardError
+          rescue StandardError => _e
             nil
           end
 
           def clear_mesh_cache(agent_id: nil)
-            @mesh_cache ||= {}
+            @mesh_cache ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
             if agent_id
-              @mesh_cache.delete(agent_id.to_s)
+              @mesh_cache.delete(agent_id.to_s) # rubocop:disable ThreadSafety/ClassInstanceVariable
             else
-              @mesh_cache.clear
+              @mesh_cache.clear # rubocop:disable ThreadSafety/ClassInstanceVariable
             end
           end
 
@@ -214,7 +214,7 @@ module Legion
             traces.select { |t| t[:domain_tags]&.include?('preference') }.filter_map do |trace|
               parse_preference_trace(trace)
             end
-          rescue StandardError
+          rescue StandardError => _e
             []
           end
 
@@ -226,7 +226,7 @@ module Legion
             return nil unless match
 
             { domain: match[1], value: match[2], source: match[3], confidence: trace[:confidence] }
-          rescue StandardError
+          rescue StandardError => _e
             nil
           end
 
@@ -239,7 +239,7 @@ module Legion
             )
             result = personality_runner.personality_compatibility(other_profile: profile[:personality])
             { score: result[:compatibility], interpretation: result[:interpretation] }
-          rescue StandardError
+          rescue StandardError => _e
             nil
           end
 

data/lib/legion/extensions/mesh/helpers/registry.rb

@@ -103,7 +103,7 @@ module Legion
 
           def local_node_name
             Legion::Settings[:client][:name]
-          rescue StandardError
+          rescue StandardError => _e
             'unknown'
           end
         end

data/lib/legion/extensions/mesh/runners/mesh.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module Legion
   module Extensions
     module Mesh
       module Runners
         module Mesh
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
           def register(agent_id:, capabilities: [], endpoint: nil, **)
             mesh_registry.register_agent(agent_id, capabilities: capabilities, endpoint: endpoint)
@@ -65,7 +67,17 @@ module Legion
           end
 
           def publish_gossip(**)
+            expired = peer_table.expire
             registry = mesh_registry
+
+            Array(expired).each do |agent_id|
+              result = registry.unregister_agent(agent_id)
+              if result
+                log.info "[mesh] ttl-expired agent unregistered from registry: agent=#{agent_id}"
+              else
+                log.debug "[mesh] ttl-expired agent not found in registry: agent=#{agent_id}"
+              end
+            end
             peers = registry.all_agents.first(gossip_max_peers).map do |agent|
               agent.slice(:agent_id, :capabilities, :node, :source, :status, :generation,
                           :last_seen, :registered_at).transform_values { |v| v.is_a?(Time) ? v.to_s : v }
@@ -78,36 +90,38 @@ module Legion
             { success: false, reason: :error, message: e.message }
           end
 
-          def merge_gossip(incoming_peers:, sender: nil, **) # rubocop:disable Lint/UnusedMethodArgument
+          def merge_gossip(incoming_peers:, sender: nil, **)
             registry = mesh_registry
+            conflict_agents = []
             merged = 0
-
-            incoming_peers.each do |peer|
-              peer = peer.transform_keys(&:to_sym)
-              next if peer[:node] == local_node_name
-
-              local = registry.agents[peer[:agent_id]]
-              if local.nil?
-                registry.register_agent(
-                  peer[:agent_id],
-                  capabilities: (peer[:capabilities] || []).map(&:to_sym),
-                  source:       (peer[:source] || :native).to_sym,
-                  node:         peer[:node]
-                )
-                registry.agents[peer[:agent_id]][:generation] = peer[:generation] || 1
-                merged += 1
-              elsif (peer[:generation] || 0) > (local[:generation] || 0)
-                local.merge!(peer.slice(:capabilities, :status, :generation, :last_seen))
-                local[:capabilities] = (local[:capabilities] || []).map(&:to_sym)
-                merged += 1
+            incoming_peers.each do |raw_peer|
+              peer = raw_peer.transform_keys(&:to_sym)
+              if peer[:node] == local_node_name
+                conflict_agents << peer[:agent_id] if sender && sender != local_node_name
+                next
               end
+              merged += 1 if upsert_remote_peer(peer, registry)
+            end
+
+            if conflict_agents.any?
+              publish_mesh_conflict(local_node: local_node_name, conflicting_node: sender,
+                                    conflict_agents: conflict_agents)
             end
 
-            { success: true, merged: merged, total_peers: incoming_peers.size }
+            { success: true, merged: merged, total_peers: incoming_peers.size, conflicts: conflict_agents.size }
           rescue StandardError => e
             { success: false, reason: :error, message: e.message }
           end
 
+          def dispatch_gossip_message(type: nil, sender: nil, peers: [], **)
+            case type
+            when 'mesh_gossip'
+              merge_gossip(incoming_peers: peers, sender: sender)
+            else
+              { success: false, error: "unknown gossip message type: #{type}" }
+            end
+          end
+
           private
 
           def publish_mesh_departure(agent_id:, capabilities:)
@@ -131,21 +145,72 @@ module Legion
             ).publish
           end
 
+          def publish_mesh_conflict(local_node:, conflicting_node:, conflict_agents:)
+            return unless defined?(Legion::Extensions::Mesh::Transport::Messages::MeshConflict)
+
+            Legion::Extensions::Mesh::Transport::Messages::MeshConflict.new(
+              local_node:       local_node,
+              conflicting_node: conflicting_node,
+              conflict_agents:  conflict_agents
+            ).publish
+            log.warn "[mesh] split-brain detected: node=#{conflicting_node} claims agents on #{local_node}: #{conflict_agents.join(',')}"
+          rescue StandardError => e
+            log.warn "[mesh] failed to publish conflict signal: #{e.message}"
+          end
+
+          def upsert_remote_peer(peer, registry)
+            peer_table.upsert(peer[:agent_id], peer)
+            local = registry.agents[peer[:agent_id]]
+            if local.nil?
+              registry.register_agent(
+                peer[:agent_id],
+                capabilities: (peer[:capabilities] || []).map(&:to_sym),
+                source:       (peer[:source] || :native).to_sym,
+                node:         peer[:node]
+              )
+              entry = registry.agents[peer[:agent_id]]
+              entry[:generation] = peer[:generation] || 1
+              entry[:last_seen] = parse_last_seen(peer[:last_seen])
+              true
+            elsif (peer[:generation] || 0) > (local[:generation] || 0)
+              local.merge!(peer.slice(:capabilities, :status, :generation))
+              local[:capabilities] = (local[:capabilities] || []).map(&:to_sym)
+              local[:last_seen] = parse_last_seen(peer[:last_seen])
+              true
+            end
+          end
+
+          def parse_last_seen(value)
+            if value.nil?
+              Time.now.utc
+            elsif value.is_a?(Time)
+              value
+            else
+              Time.parse(value.to_s)
+            end
+          rescue ArgumentError => _e
+            Time.now.utc
+          end
+
           def gossip_max_peers
             settings = Legion::Settings.dig(:mesh, :gossip)
             (settings.is_a?(Hash) ? settings[:max_peers_per_message] : nil) || 100
-          rescue StandardError
+          rescue StandardError => _e
             100
           end
 
           def local_node_name
             Legion::Settings[:client][:name]
-          rescue StandardError
+          rescue StandardError => _e
             'unknown'
           end
 
           def mesh_registry
-            @mesh_registry ||= Helpers::Registry.new
+            @mesh_registry ||= Helpers::Registry.new # rubocop:disable Legion/Singleton/UseInstance
+          end
+
+          def peer_table
+            @peer_table ||= Helpers::PeerTable.new
           end
         end
       end

data/lib/legion/extensions/mesh/runners/preferences.rb

@@ -7,8 +7,8 @@ module Legion
     module Mesh
       module Runners
         module Preferences
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
           def query_preferences(target_agent_id:, domains: nil, callback: nil, ttl: 5, **)
             default_profile = Helpers::PreferenceProfile.resolve(owner_id: target_agent_id)
@@ -96,7 +96,7 @@ module Legion
             else
               'unknown'
             end
-          rescue StandardError
+          rescue StandardError => _e
             'unknown'
           end
 
@@ -110,7 +110,7 @@ module Legion
               correlation_id:      msg[:correlation_id]
             ).publish
           rescue StandardError => e
-            log_debug("[mesh] failed to publish preference response: #{e.message}")
+            log.debug("[mesh] failed to publish preference response: #{e.message}")
           end
 
           def publish_preference_query(target_agent_id:, correlation_id:, domains:)
@@ -125,7 +125,7 @@ module Legion
 
           def default_preference_callback(target_agent_id:)
             lambda do |_profile|
-              log_debug("[mesh] received and cached preferences for #{target_agent_id}")
+              log.debug("[mesh] received and cached preferences for #{target_agent_id}")
             end
           end
 
@@ -138,11 +138,11 @@ module Legion
             evaluator = Object.new.extend(trust_mod)
             result = evaluator.get_trust(agent_id: agent_id, domain: :general)
 
-            return :allowed unless result[:found]
+            return :allowed unless result[:found] # rubocop:disable Legion/Extension/RunnerReturnHash
 
             composite = result.dig(:trust, :composite) || 0.0
             composite >= Helpers::Topology::TRUST_CONSIDER_THRESHOLD ? :allowed : :denied
-          rescue StandardError
+          rescue StandardError => _e
             :allowed
           end
 

data/lib/legion/extensions/mesh/runners/task_request.rb

@@ -10,7 +10,7 @@ module Legion
   module Extensions
     module Mesh
       module Runners
-        module TaskRequest
+        module TaskRequest # rubocop:disable Legion/Extension/RunnerIncludeHelpers
           include Runners::Mesh
 
           DEFAULT_TIMEOUT = 30
@@ -65,10 +65,10 @@ module Legion
           private
 
           def resolve_target(to)
-            return to if mesh_registry.agents.key?(to)
+            return to if mesh_registry.agents.key?(to) # rubocop:disable Legion/Extension/RunnerReturnHash
 
             agents = mesh_registry.find_by_capability(to.to_sym)
-            return nil if agents.empty?
+            return nil if agents.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
 
             online = agents.select { |a| a[:status] == :online }
             (online.empty? ? agents : online).sample[:agent_id]

data/lib/legion/extensions/mesh/transport/messages/mesh_conflict.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Messages
+          class MeshConflict < Legion::Transport::Message
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
+
+            def routing_key
+              'mesh.conflict'
+            end
+
+            def message
+              {
+                type:             'mesh_conflict',
+                local_node:       @options[:local_node],
+                conflicting_node: @options[:conflicting_node],
+                conflict_agents:  @options[:conflict_agents] || [],
+                detected_at:      Time.now.to_s
+              }
+            end
+
+            def type
+              'mesh_conflict'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Mesh
-      VERSION = '0.4.1'
+      VERSION = '0.4.3'
     end
   end
 end

data/lib/legion/extensions/mesh.rb

@@ -7,22 +7,26 @@ require 'legion/extensions/mesh/helpers/preference_profile'
 require 'legion/extensions/mesh/helpers/pending_requests'
 require 'legion/extensions/mesh/helpers/delegation'
 require 'legion/extensions/mesh/helpers/peer_verify'
+require 'legion/extensions/mesh/helpers/peer_table'
 require 'legion/extensions/mesh/runners/mesh'
 require 'legion/extensions/mesh/runners/preferences'
 require 'legion/extensions/mesh/runners/delegation'
 require 'legion/extensions/mesh/runners/task_request'
 
-if defined?(Legion::Transport)
+if Legion.const_defined?(:Transport, false)
   require 'legion/extensions/mesh/transport/messages/preference_query'
   require 'legion/extensions/mesh/transport/messages/preference_response'
   require 'legion/extensions/mesh/transport/messages/mesh_departure'
+  require 'legion/extensions/mesh/transport/messages/gossip'
+  require 'legion/extensions/mesh/transport/messages/mesh_conflict'
   require 'legion/extensions/mesh/transport/queues/preference'
+  require 'legion/extensions/mesh/transport/queues/gossip'
 end
 
 module Legion
   module Extensions
     module Mesh
-      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
     end
   end
 end

data/spec/legion/extensions/mesh/actors/gossip_listener_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Stub the framework subscription base class
+unless defined?(Legion::Extensions::Actors::Subscription)
+  module Legion
+    module Extensions
+      module Actors
+        class Subscription # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+
+  $LOADED_FEATURES << 'legion/extensions/actors/subscription'
+end
+
+# Stub transport queue class if not loaded
+unless defined?(Legion::Extensions::Mesh::Transport::Queues::Gossip)
+  module Legion
+    module Extensions
+      module Mesh
+        module Transport
+          module Queues
+            class Gossip # rubocop:disable Lint/EmptyClass
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/runners/mesh'
+require 'legion/extensions/mesh/actors/gossip_listener'
+
+RSpec.describe Legion::Extensions::Mesh::Actor::GossipListener do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it 'returns the Mesh runner module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Mesh::Runners::Mesh)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns dispatch_gossip_message' do
+      expect(actor.runner_function).to eq('dispatch_gossip_message')
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false (actor handles dispatch directly without runner pipeline)' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+
+  describe '#queue' do
+    it 'returns the Gossip queue class' do
+      expect(actor.queue).to eq(Legion::Extensions::Mesh::Transport::Queues::Gossip)
+    end
+  end
+
+  describe '#enabled?' do
+    context 'when Mesh runner and Transport are both available' do
+      it 'returns truthy' do
+        stub_const('Legion::Transport', Module.new)
+        expect(actor.enabled?).to be_truthy
+      end
+    end
+
+    context 'when Transport is not available' do
+      it 'returns falsey' do
+        hide_const('Legion::Transport')
+        expect(actor.enabled?).to be_falsey
+      end
+    end
+  end
+end

data/spec/legion/extensions/mesh/helpers/peer_table_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/helpers/peer_table'
+
+RSpec.describe Legion::Extensions::Mesh::Helpers::PeerTable do
+  subject(:table) { described_class.new(ttl: 60) }
+
+  describe '#upsert / #get' do
+    it 'stores and retrieves a peer entry' do
+      table.upsert('agent-1', { node: 'node-01' })
+      entry = table.get('agent-1')
+      expect(entry[:node]).to eq('node-01')
+    end
+
+    it 'sets last_seen_at on upsert' do
+      table.upsert('agent-1', {})
+      expect(table.get('agent-1')[:last_seen_at]).to be_a(Time)
+    end
+
+    it 'overwrites an existing entry on re-upsert' do
+      table.upsert('agent-1', { node: 'node-01' })
+      table.upsert('agent-1', { node: 'node-02' })
+      expect(table.get('agent-1')[:node]).to eq('node-02')
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(table.get('missing')).to be_nil
+    end
+  end
+
+  describe '#expire' do
+    let(:short_ttl_table) { described_class.new(ttl: 1) }
+
+    it 'removes peers whose last_seen_at is older than TTL' do
+      short_ttl_table.upsert('old-agent', {})
+      entry = short_ttl_table.instance_variable_get(:@peers)['old-agent']
+      entry[:last_seen_at] = Time.now.utc - 120
+      expired = short_ttl_table.expire
+      expect(expired).to include('old-agent')
+      expect(short_ttl_table.get('old-agent')).to be_nil
+    end
+
+    it 'keeps peers within TTL' do
+      short_ttl_table.upsert('fresh-agent', {})
+      short_ttl_table.expire
+      expect(short_ttl_table.get('fresh-agent')).not_to be_nil
+    end
+
+    it 'returns an array of expired agent IDs' do
+      short_ttl_table.upsert('e1', {})
+      short_ttl_table.upsert('e2', {})
+      short_ttl_table.instance_variable_get(:@peers).each_value { |e| e[:last_seen_at] = Time.now.utc - 120 }
+      expired = short_ttl_table.expire
+      expect(expired).to contain_exactly('e1', 'e2')
+    end
+
+    it 'returns empty array when nothing is expired' do
+      table.upsert('fresh', {})
+      expect(table.expire).to be_empty
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent upserts without data corruption' do
+      threads = Array.new(10) do |i|
+        Thread.new { table.upsert("agent-#{i}", { node: "node-#{i}" }) }
+      end
+      threads.each(&:join)
+      expect(table.count).to eq(10)
+    end
+  end
+
+  describe '#count' do
+    it 'reflects the number of stored peers' do
+      table.upsert('a1', {})
+      table.upsert('a2', {})
+      expect(table.count).to eq(2)
+    end
+  end
+
+  describe '#remove' do
+    it 'removes a specific peer' do
+      table.upsert('agent-1', {})
+      table.remove('agent-1')
+      expect(table.get('agent-1')).to be_nil
+    end
+
+    it 'does nothing for unknown agent' do
+      expect { table.remove('missing') }.not_to raise_error
+    end
+  end
+
+  describe '#all' do
+    it 'returns a copy of all peers' do
+      table.upsert('a1', { node: 'n1' })
+      all = table.all
+      expect(all.keys).to include('a1')
+      all.delete('a1')
+      expect(table.get('a1')).not_to be_nil
+    end
+  end
+end

data/spec/legion/extensions/mesh/runners/mesh_gossip_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe 'Gossip runner methods' do
 
   before do
     allow(subject).to receive(:mesh_registry).and_return(
-      Legion::Extensions::Mesh::Helpers::Registry.new
+      Legion::Extensions::Mesh::Helpers::Registry.new # rubocop:disable Legion/Singleton/UseInstance
     )
   end
 
@@ -60,6 +60,49 @@ RSpec.describe 'Gossip runner methods' do
       result = subject.merge_gossip(incoming_peers: incoming, sender: 'node-02')
       expect(result[:merged]).to eq(0)
     end
+
+    context 'split-brain detection' do
+      before do
+        allow(subject).to receive(:local_node_name).and_return('local-node')
+        allow(subject).to receive(:publish_mesh_conflict)
+      end
+
+      it 'detects a conflict when incoming peers claim the local node from a different sender' do
+        incoming = [
+          { agent_id: 'local-agent', node: 'local-node', generation: 1 }
+        ]
+        result = subject.merge_gossip(incoming_peers: incoming, sender: 'other-node')
+        expect(result[:conflicts]).to eq(1)
+      end
+
+      it 'publishes MeshConflict when split-brain is detected' do
+        incoming = [
+          { agent_id: 'local-agent', node: 'local-node', generation: 1 }
+        ]
+        subject.merge_gossip(incoming_peers: incoming, sender: 'other-node')
+        expect(subject).to have_received(:publish_mesh_conflict).with(
+          local_node:       'local-node',
+          conflicting_node: 'other-node',
+          conflict_agents:  ['local-agent']
+        )
+      end
+
+      it 'does not publish MeshConflict when sender is the local node' do
+        incoming = [
+          { agent_id: 'local-agent', node: 'local-node', generation: 1 }
+        ]
+        subject.merge_gossip(incoming_peers: incoming, sender: 'local-node')
+        expect(subject).not_to have_received(:publish_mesh_conflict)
+      end
+
+      it 'reports zero conflicts when no peers claim the local node' do
+        incoming = [
+          { agent_id: 'remote-agent', node: 'remote-node', generation: 1 }
+        ]
+        result = subject.merge_gossip(incoming_peers: incoming, sender: 'remote-node')
+        expect(result[:conflicts]).to eq(0)
+      end
+    end
   end
 
   describe '#publish_gossip' do

data/spec/legion/extensions/mesh/transport/messages/mesh_conflict_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        def initialize(**options)
+          @options = options
+        end
+      end
+    end
+  end
+end
+
+unless defined?(Legion::Transport::Exchanges::Node)
+  module Legion
+    module Transport
+      module Exchanges
+        class Node # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/messages/mesh_conflict'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::MeshConflict do
+  subject(:msg) do
+    described_class.new(
+      local_node:       'node-01',
+      conflicting_node: 'node-02',
+      conflict_agents:  %w[agent-a agent-b]
+    )
+  end
+
+  describe '#exchange' do
+    it 'returns the Node exchange' do
+      expect(msg.exchange).to eq(Legion::Transport::Exchanges::Node)
+    end
+  end
+
+  describe '#routing_key' do
+    it 'uses mesh.conflict' do
+      expect(msg.routing_key).to eq('mesh.conflict')
+    end
+  end
+
+  describe '#message' do
+    it 'includes type mesh_conflict' do
+      expect(msg.message[:type]).to eq('mesh_conflict')
+    end
+
+    it 'includes local_node' do
+      expect(msg.message[:local_node]).to eq('node-01')
+    end
+
+    it 'includes conflicting_node' do
+      expect(msg.message[:conflicting_node]).to eq('node-02')
+    end
+
+    it 'includes conflict_agents list' do
+      expect(msg.message[:conflict_agents]).to eq(%w[agent-a agent-b])
+    end
+
+    it 'includes detected_at timestamp string' do
+      expect(msg.message[:detected_at]).to be_a(String)
+    end
+  end
+
+  describe '#type' do
+    it 'returns mesh_conflict' do
+      expect(msg.type).to eq('mesh_conflict')
+    end
+  end
+
+  describe 'conflict_agents default' do
+    subject(:msg_no_agents) do
+      described_class.new(local_node: 'node-01', conflicting_node: 'node-02')
+    end
+
+    it 'defaults conflict_agents to empty array' do
+      expect(msg_no_agents.message[:conflict_agents]).to eq([])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Esity
@@ -147,12 +147,14 @@ files:
 - lex-mesh.gemspec
 - lib/legion/extensions/mesh.rb
 - lib/legion/extensions/mesh/actors/gossip.rb
+- lib/legion/extensions/mesh/actors/gossip_listener.rb
 - lib/legion/extensions/mesh/actors/heartbeat.rb
 - lib/legion/extensions/mesh/actors/pending_expiry.rb
 - lib/legion/extensions/mesh/actors/preference_listener.rb
 - lib/legion/extensions/mesh/actors/silence_watchdog.rb
 - lib/legion/extensions/mesh/client.rb
 - lib/legion/extensions/mesh/helpers/delegation.rb
+- lib/legion/extensions/mesh/helpers/peer_table.rb
 - lib/legion/extensions/mesh/helpers/peer_verify.rb
 - lib/legion/extensions/mesh/helpers/pending_requests.rb
 - lib/legion/extensions/mesh/helpers/preference_profile.rb
@@ -163,12 +165,14 @@ files:
 - lib/legion/extensions/mesh/runners/preferences.rb
 - lib/legion/extensions/mesh/runners/task_request.rb
 - lib/legion/extensions/mesh/transport/messages/gossip.rb
+- lib/legion/extensions/mesh/transport/messages/mesh_conflict.rb
 - lib/legion/extensions/mesh/transport/messages/mesh_departure.rb
 - lib/legion/extensions/mesh/transport/messages/preference_query.rb
 - lib/legion/extensions/mesh/transport/messages/preference_response.rb
 - lib/legion/extensions/mesh/transport/queues/gossip.rb
 - lib/legion/extensions/mesh/transport/queues/preference.rb
 - lib/legion/extensions/mesh/version.rb
+- spec/legion/extensions/mesh/actors/gossip_listener_spec.rb
 - spec/legion/extensions/mesh/actors/gossip_spec.rb
 - spec/legion/extensions/mesh/actors/heartbeat_spec.rb
 - spec/legion/extensions/mesh/actors/pending_expiry_spec.rb
@@ -176,6 +180,7 @@ files:
 - spec/legion/extensions/mesh/actors/silence_watchdog_spec.rb
 - spec/legion/extensions/mesh/client_spec.rb
 - spec/legion/extensions/mesh/helpers/delegation_spec.rb
+- spec/legion/extensions/mesh/helpers/peer_table_spec.rb
 - spec/legion/extensions/mesh/helpers/peer_verify_spec.rb
 - spec/legion/extensions/mesh/helpers/pending_requests_spec.rb
 - spec/legion/extensions/mesh/helpers/preference_profile_spec.rb
@@ -187,6 +192,7 @@ files:
 - spec/legion/extensions/mesh/runners/preferences_spec.rb
 - spec/legion/extensions/mesh/runners/task_request_spec.rb
 - spec/legion/extensions/mesh/transport/messages/gossip_spec.rb
+- spec/legion/extensions/mesh/transport/messages/mesh_conflict_spec.rb
 - spec/legion/extensions/mesh/transport/messages/mesh_departure_spec.rb
 - spec/legion/extensions/mesh/transport/messages/preference_query_spec.rb
 - spec/legion/extensions/mesh/transport/messages/preference_response_spec.rb