lex-mesh 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25cafa977ed6aaf671c903e71895312253a412c32c141e8de9674b1a86747bff
-  data.tar.gz: c7bbdde6f4c065f0fdaea58a5a5124bd53e49f0c48e0d275de0828bd93ec2439
+  metadata.gz: d736de5644beff024c6acc40ededd1eface48a64dc919b4f1033e0971a7af71f
+  data.tar.gz: e58b0661aab721ebaf1c7f413691a41f2a5f0f1e455710b3d27f79ad687655fb
 SHA512:
-  metadata.gz: 76357a6ca4c31089fd7f5317097f935b07df6349476b344bd2681dccfbd796d79b1061922b22d42ca45b92d045bdbf901ed8d6c502f525cff3a668099dfea56c
-  data.tar.gz: 9e17a698c0b941fd2000ab9affffa87cd3bad983b37acacce794ee0fb4d975a8cdc04eee44480f976856e712fb6af8dfa80f976d07c2fd94ea302ba61f31b389
+  metadata.gz: d1abfff1fe01a29d3b9be8ee75c5f949f753a9fdf33df340e1362ef758236fb411a826eb0ae3c448bc330b8bc06cff725f35d10b5767f39ca7a8ffcb06969782
+  data.tar.gz: e1266fc12dd23f183439f2ed5c1d2a21a1c11b824652e918b6fc398df40eea46cc5aa0dbabbb14e99b8f41aa4b0cd2e99d71a259aaba8de595088c51336c7a62

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Actor
+        class Gossip < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::Mesh::Runners::Mesh
+          end
+
+          def runner_function
+            :publish_gossip
+          end
+
+          def time
+            15
+          end
+
+          def use_runner?
+            true
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+
+          def args
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@
 
 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'
 require 'legion/extensions/mesh/helpers/preference_profile'
 require 'legion/extensions/mesh/helpers/pending_requests'
 require 'legion/extensions/mesh/helpers/topology'
@@ -13,6 +15,8 @@ module Legion
       class Client
         include Runners::Mesh
         include Runners::Preferences
+        include Runners::Delegation
+        include Runners::TaskRequest
 
         def initialize(**opts)
           @opts = opts

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

@@ -13,11 +13,14 @@ module Legion
             @messages = []
           end
 
-          def register_agent(agent_id, capabilities: [], endpoint: nil)
+          def register_agent(agent_id, capabilities: [], endpoint: nil, source: :native, node: nil)
             @agents[agent_id] = {
               agent_id:      agent_id,
               capabilities:  capabilities,
               endpoint:      endpoint,
+              source:        source,
+              node:          node || local_node_name,
+              generation:    1,
               registered_at: Time.now.utc,
               last_seen:     Time.now.utc,
               status:        :online
@@ -39,6 +42,7 @@ module Legion
 
             agent[:last_seen] = Time.now.utc
             agent[:status] = :online
+            agent[:generation] = (agent[:generation] || 0) + 1
           end
 
           def find_by_capability(capability)
@@ -81,9 +85,21 @@ module Legion
             @agents.values.select { |a| a[:status] == :online }
           end
 
+          def all_agents
+            @agents.values
+          end
+
           def count
             @agents.size
           end
+
+          private
+
+          def local_node_name
+            Legion::Settings[:client][:name]
+          rescue StandardError
+            'unknown'
+          end
         end
       end
     end

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

@@ -64,6 +64,50 @@ module Legion
             { success: true, expired: expired, count: expired.size }
           end
 
+          def publish_gossip(**)
+            registry = mesh_registry
+            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 }
+            end
+
+            @gossip_round = (@gossip_round || 0) + 1
+            publish_gossip_message(peers)
+            { success: true, peers_broadcast: peers.size, gossip_round: @gossip_round }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          def merge_gossip(incoming_peers:, sender: nil, **) # rubocop:disable Lint/UnusedMethodArgument
+            registry = mesh_registry
+            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
+              end
+            end
+
+            { success: true, merged: merged, total_peers: incoming_peers.size }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
           private
 
           def publish_mesh_departure(agent_id:, capabilities:)
@@ -77,6 +121,29 @@ module Legion
             Legion::Logging.warn "[mesh] failed to publish departure signal: #{e.message}"
           end
 
+          def publish_gossip_message(peers)
+            return unless defined?(Legion::Extensions::Mesh::Transport::Messages::Gossip)
+
+            Legion::Extensions::Mesh::Transport::Messages::Gossip.new(
+              sender:       local_node_name,
+              gossip_round: @gossip_round,
+              peers:        peers
+            ).publish
+          end
+
+          def gossip_max_peers
+            settings = Legion::Settings.dig(:mesh, :gossip)
+            (settings.is_a?(Hash) ? settings[:max_peers_per_message] : nil) || 100
+          rescue StandardError
+            100
+          end
+
+          def local_node_name
+            Legion::Settings[:client][:name]
+          rescue StandardError
+            'unknown'
+          end
+
           def mesh_registry
             @mesh_registry ||= Helpers::Registry.new
           end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative '../helpers/pending_requests'
+require_relative '../helpers/delegation'
+require_relative '../helpers/registry'
+require_relative 'mesh'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Runners
+        module TaskRequest
+          include Runners::Mesh
+
+          DEFAULT_TIMEOUT = 30
+
+          def request_task(from:, to:, task:, payload:, timeout: DEFAULT_TIMEOUT, consent_level: :execute, **) # rubocop:disable Metrics/ParameterLists
+            target_id = resolve_target(to)
+            return { success: false, reason: :no_agent_found, requested: to } unless target_id
+
+            correlation_id = "task-#{SecureRandom.uuid}"
+
+            delegation = delegation_tracker.create(
+              from: from, to: target_id,
+              task_context: task, consent_level: consent_level
+            )
+            return { success: false, reason: delegation[:error] } if delegation[:error]
+
+            task_pending.register(
+              correlation_id: correlation_id,
+              callback:       nil,
+              ttl:            timeout
+            )
+
+            send_message(from: from, to: target_id, pattern: :unicast,
+                         payload: { type: :task_request, correlation_id: correlation_id,
+                                    task: task, payload: payload, reply_to: from })
+
+            Legion::Logging.info "[mesh-task] request: from=#{from} to=#{target_id} task=#{task} cid=#{correlation_id[0..11]}"
+            { success: true, correlation_id: correlation_id, delegation_id: delegation[:delegation_id],
+              target_agent: target_id }
+          end
+
+          def handle_task_reply(correlation_id:, result:, **)
+            resolved = task_pending.resolve(correlation_id: correlation_id, result: result)
+            if resolved
+              Legion::Logging.debug "[mesh-task] reply resolved: cid=#{correlation_id[0..11]}"
+              { success: true, resolved: true, correlation_id: correlation_id }
+            else
+              { success: false, reason: :not_found, correlation_id: correlation_id }
+            end
+          end
+
+          def pending_task_stats(**)
+            { success: true, pending_count: task_pending.pending_count }
+          end
+
+          def expire_pending_tasks(**)
+            expired = task_pending.expire
+            Legion::Logging.debug "[mesh-task] expired #{expired.size} pending tasks" unless expired.empty?
+            { success: true, expired_count: expired.size, expired_ids: expired }
+          end
+
+          private
+
+          def resolve_target(to)
+            return to if mesh_registry.agents.key?(to)
+
+            agents = mesh_registry.find_by_capability(to.to_sym)
+            return nil if agents.empty?
+
+            online = agents.select { |a| a[:status] == :online }
+            (online.empty? ? agents : online).sample[:agent_id]
+          end
+
+          def task_pending
+            @task_pending ||= Helpers::PendingRequests.new(default_ttl: DEFAULT_TIMEOUT)
+          end
+
+          def delegation_tracker
+            @delegation_tracker ||= Helpers::Delegation.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Messages
+          class Gossip < Legion::Transport::Message
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
+
+            def routing_key
+              'mesh.gossip'
+            end
+
+            def message
+              {
+                type:         'mesh_gossip',
+                sender:       @options[:sender],
+                gossip_round: @options[:gossip_round] || 0,
+                peers:        @options[:peers] || []
+              }
+            end
+
+            def type
+              'mesh_gossip'
+            end
+
+            def encrypt?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/transport/queues/gossip.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Queues
+          class Gossip < Legion::Transport::Queue
+            def queue_name
+              'mesh.gossip'
+            end
+
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
+
+            def routing_key
+              'mesh.gossip'
+            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.2.4'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/legion/extensions/mesh.rb

@@ -10,6 +10,7 @@ require 'legion/extensions/mesh/helpers/peer_verify'
 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)
   require 'legion/extensions/mesh/transport/messages/preference_query'

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class since legionio gem is not available in test
+unless defined?(Legion::Extensions::Actors::Every)
+  module Legion
+    module Extensions
+      module Actors
+        class Every # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every' unless $LOADED_FEATURES.include?('legion/extensions/actors/every')
+
+require 'legion/extensions/mesh/actors/gossip'
+
+RSpec.describe Legion::Extensions::Mesh::Actor::Gossip do
+  it 'fires every 15 seconds' do
+    expect(described_class.new.time).to eq(15)
+  end
+
+  it 'calls publish_gossip runner function' do
+    instance = described_class.allocate
+    expect(instance.runner_function).to eq(:publish_gossip)
+  end
+end

data/spec/legion/extensions/mesh/client_spec.rb

@@ -51,4 +51,26 @@ RSpec.describe Legion::Extensions::Mesh::Client do
       expect(result[:expired]).to eq(0)
     end
   end
+
+  it 'responds to delegation runner methods' do
+    expect(client).to respond_to(:delegate)
+    expect(client).to respond_to(:complete_delegation)
+    expect(client).to respond_to(:revoke_delegation)
+  end
+
+  it 'responds to task request runner methods' do
+    expect(client).to respond_to(:request_task)
+    expect(client).to respond_to(:handle_task_reply)
+    expect(client).to respond_to(:pending_task_stats)
+  end
+
+  describe '#request_task' do
+    it 'sends a task request via the client' do
+      client.register(agent_id: 'a', capabilities: [:orchestration])
+      client.register(agent_id: 'b', capabilities: [:review])
+      result = client.request_task(from: 'a', to: 'b', task: 'review', payload: {})
+      expect(result[:success]).to be true
+      expect(result[:target_agent]).to eq('b')
+    end
+  end
 end

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

@@ -313,6 +313,32 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::Registry do
     end
   end
 
+  describe 'gossip fields' do
+    it 'stores source, node, and generation on registration' do
+      registry.register_agent('agent-1', capabilities: [:test], source: :native, node: 'node-01')
+      agent = registry.agents['agent-1']
+      expect(agent[:source]).to eq(:native)
+      expect(agent[:node]).to eq('node-01')
+      expect(agent[:generation]).to eq(1)
+    end
+
+    it 'increments generation on heartbeat' do
+      registry.register_agent('agent-1', capabilities: [:test])
+      registry.heartbeat('agent-1')
+      expect(registry.agents['agent-1'][:generation]).to eq(2)
+    end
+  end
+
+  describe '#all_agents' do
+    it 'returns all agent records as an array' do
+      registry.register_agent('a1', capabilities: [:search])
+      registry.register_agent('a2', capabilities: [:compute])
+      all = registry.all_agents
+      expect(all).to be_an(Array)
+      expect(all.size).to eq(2)
+    end
+  end
+
   describe '#count' do
     it 'returns 0 for an empty registry' do
       expect(registry.count).to eq(0)

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Gossip runner methods' do
+  subject { Object.new.extend(Legion::Extensions::Mesh::Runners::Mesh) }
+
+  before do
+    allow(subject).to receive(:mesh_registry).and_return(
+      Legion::Extensions::Mesh::Helpers::Registry.new
+    )
+  end
+
+  describe '#merge_gossip' do
+    it 'adds unknown agents from incoming gossip' do
+      incoming = [
+        { agent_id: 'remote-1', capabilities: [:test], node: 'node-02',
+          source: :native, status: :online, generation: 5,
+          last_seen: Time.now.utc.to_s, registered_at: Time.now.utc.to_s }
+      ]
+      result = subject.merge_gossip(incoming_peers: incoming, sender: 'node-02')
+      expect(result[:success]).to be true
+      expect(result[:merged]).to eq(1)
+    end
+
+    it 'updates agents with higher generation' do
+      registry = subject.send(:mesh_registry)
+      registry.register_agent('agent-1', capabilities: [:old], node: 'node-01')
+
+      incoming = [
+        { agent_id: 'agent-1', capabilities: [:updated], node: 'node-01',
+          source: :native, status: :online, generation: 99,
+          last_seen: Time.now.utc.to_s, registered_at: Time.now.utc.to_s }
+      ]
+      result = subject.merge_gossip(incoming_peers: incoming, sender: 'node-01')
+      expect(result[:merged]).to eq(1)
+      expect(registry.agents['agent-1'][:generation]).to eq(99)
+    end
+
+    it 'skips agents from local node' do
+      local_name = 'local-node'
+      allow(subject).to receive(:local_node_name).and_return(local_name)
+
+      incoming = [
+        { agent_id: 'local-agent', node: local_name, generation: 1 }
+      ]
+      result = subject.merge_gossip(incoming_peers: incoming, sender: 'other-node')
+      expect(result[:merged]).to eq(0)
+    end
+
+    it 'ignores agents with lower or equal generation' do
+      registry = subject.send(:mesh_registry)
+      registry.register_agent('agent-1', capabilities: [:test], node: 'node-01')
+      # generation is 1 after register
+
+      incoming = [
+        { agent_id: 'agent-1', capabilities: [:test], node: 'node-01',
+          generation: 1, source: :native, status: :online }
+      ]
+      result = subject.merge_gossip(incoming_peers: incoming, sender: 'node-02')
+      expect(result[:merged]).to eq(0)
+    end
+  end
+
+  describe '#publish_gossip' do
+    it 'returns success with peer count' do
+      allow(subject).to receive(:publish_gossip_message)
+      result = subject.publish_gossip
+      expect(result[:success]).to be true
+      expect(result[:peers_broadcast]).to be_a(Integer)
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/runners/task_request'
+
+RSpec.describe Legion::Extensions::Mesh::Runners::TaskRequest do
+  subject(:runner) { Object.new.extend(described_class) }
+
+  before do
+    runner.instance_variable_set(:@mesh_registry, nil)
+    runner.instance_variable_set(:@task_pending, nil)
+    runner.instance_variable_set(:@delegation_tracker, nil)
+  end
+
+  describe '#request_task' do
+    before do
+      runner.register(agent_id: 'requester', capabilities: [:orchestration])
+      runner.register(agent_id: 'worker-1', capabilities: [:code_review])
+      runner.register(agent_id: 'worker-2', capabilities: %i[code_review testing])
+    end
+
+    it 'sends a task request to a specific agent by ID' do
+      result = runner.request_task(from: 'requester', to: 'worker-1',
+                                   task: 'review_code', payload: { file: 'app.rb' })
+      expect(result[:success]).to be true
+      expect(result[:correlation_id]).to be_a(String)
+      expect(result[:delegation_id]).to start_with('del-')
+      expect(result[:target_agent]).to eq('worker-1')
+    end
+
+    it 'routes to an agent by capability when to: is not a registered agent' do
+      result = runner.request_task(from: 'requester', to: 'code_review',
+                                   task: 'review_code', payload: {})
+      expect(result[:success]).to be true
+      expect(%w[worker-1 worker-2]).to include(result[:target_agent])
+    end
+
+    it 'returns error when no agent found for capability' do
+      result = runner.request_task(from: 'requester', to: 'nonexistent_capability',
+                                   task: 'do_thing', payload: {})
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:no_agent_found)
+    end
+
+    it 'registers a pending request' do
+      result = runner.request_task(from: 'requester', to: 'worker-1',
+                                   task: 'review', payload: {}, timeout: 60)
+      expect(runner.send(:task_pending).pending?(result[:correlation_id])).to be true
+    end
+  end
+
+  describe '#handle_task_reply' do
+    it 'resolves a pending request' do
+      runner.register(agent_id: 'req', capabilities: [])
+      runner.register(agent_id: 'wrk', capabilities: [:work])
+
+      req = runner.request_task(from: 'req', to: 'wrk', task: 'test', payload: {})
+      result = runner.handle_task_reply(
+        correlation_id: req[:correlation_id],
+        result:         { status: :completed, output: 'done' }
+      )
+      expect(result[:success]).to be true
+      expect(result[:resolved]).to be true
+    end
+
+    it 'returns not_found for unknown correlation_id' do
+      result = runner.handle_task_reply(correlation_id: 'unknown', result: {})
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#pending_task_stats' do
+    it 'returns count of pending requests' do
+      runner.register(agent_id: 'a', capabilities: [])
+      runner.register(agent_id: 'b', capabilities: [:work])
+      runner.request_task(from: 'a', to: 'b', task: 't', payload: {})
+      stats = runner.pending_task_stats
+      expect(stats[:success]).to be true
+      expect(stats[:pending_count]).to be >= 1
+    end
+  end
+
+  describe '#expire_pending_tasks' do
+    it 'expires timed-out requests' do
+      result = runner.expire_pending_tasks
+      expect(result[:success]).to be true
+      expect(result[:expired_count]).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# 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/gossip'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::Gossip do
+  subject do
+    described_class.new(
+      sender:       'node-01',
+      gossip_round: 5,
+      peers:        [{ agent_id: 'w1', capabilities: [:test], node: 'node-01', generation: 3 }]
+    )
+  end
+
+  it 'uses the node exchange' do
+    expect(subject.exchange).to eq(Legion::Transport::Exchanges::Node)
+  end
+
+  it 'routes to mesh.gossip' do
+    expect(subject.routing_key).to eq('mesh.gossip')
+  end
+
+  it 'includes sender and peers in the message body' do
+    msg = subject.message
+    expect(msg[:type]).to eq('mesh_gossip')
+    expect(msg[:sender]).to eq('node-01')
+    expect(msg[:peers]).to be_an(Array)
+    expect(msg[:gossip_round]).to eq(5)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
@@ -48,6 +48,7 @@ files:
 - Gemfile
 - lex-mesh.gemspec
 - lib/legion/extensions/mesh.rb
+- lib/legion/extensions/mesh/actors/gossip.rb
 - lib/legion/extensions/mesh/actors/heartbeat.rb
 - lib/legion/extensions/mesh/actors/pending_expiry.rb
 - lib/legion/extensions/mesh/actors/preference_listener.rb
@@ -62,11 +63,15 @@ files:
 - lib/legion/extensions/mesh/runners/delegation.rb
 - lib/legion/extensions/mesh/runners/mesh.rb
 - 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_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_spec.rb
 - spec/legion/extensions/mesh/actors/heartbeat_spec.rb
 - spec/legion/extensions/mesh/actors/pending_expiry_spec.rb
 - spec/legion/extensions/mesh/actors/preference_listener_spec.rb
@@ -79,8 +84,11 @@ files:
 - spec/legion/extensions/mesh/helpers/registry_spec.rb
 - spec/legion/extensions/mesh/helpers/topology_spec.rb
 - spec/legion/extensions/mesh/runners/delegation_spec.rb
+- spec/legion/extensions/mesh/runners/mesh_gossip_spec.rb
 - spec/legion/extensions/mesh/runners/mesh_spec.rb
 - 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_departure_spec.rb
 - spec/legion/extensions/mesh/transport/messages/preference_query_spec.rb
 - spec/legion/extensions/mesh/transport/messages/preference_response_spec.rb