lex-mesh 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edbe1f87a3c1b6cad5d87f2ee8c1b04551b9bbd36804c7d4f71ed18f9833f58e
-  data.tar.gz: 50f43be7cffacaa7b23e316d2f69a1763a2b82a7437f7d1e854e4f5cd088bc3e
+  metadata.gz: 983bda71103db47ebf1fd1a9087afa36ac9073b108aed204f579204718f84672
+  data.tar.gz: 5a2a670f327317978f84f10684ba0b6f09031065e4402bece53309ccab96462e
 SHA512:
-  metadata.gz: d14a5e8b04963df9a79bdc216c27c669330801c2d0677299908a15cbf2abd125b2e841a245a678823c6c9efab9b83c13e7b0d35b230ae0ba13ddbc42c0e152fc
-  data.tar.gz: fe99ad0868788b91826c3bfa25dbbaa131e63b471b409e9ae110c4296bb2af8f44a366939331fff63f9358b6d49e1f513bc268aaf3f2c6c00ac530791c4a4060
+  metadata.gz: 98a5c88d848ad732100824f8c6bcf4657413bb2fae5137a0a8d46cde3df54888596ddab738e4716a291e28cdfc6c81758d0cfdef73feaef70046e933983dd3e4
+  data.tar.gz: c3e8d3eec443be56de9b29817aff18ce83a7b98a5d84ceac5bf702206c33dd987990e77c31cf3c08359825b3916f44535747ad8419259201d6fcbbbff9c0309a

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/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/preference_profile.rb

@@ -246,6 +246,86 @@ module Legion
           def personality_available?
             defined?(Legion::Extensions::Agentic::Self::Personality::Runners::Personality)
           end
+
+          OBSERVATION_THRESHOLD = 20
+
+          def update_from_observation(owner_id:, signals:)
+            @observation_counts  ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            key = owner_id.to_s
+            @observation_counts[key] = (@observation_counts[key] || 0) + 1 # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals[key] ||= [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals[key] << signals # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            derive_and_store_observations(owner_id: key) if @observation_counts[key] >= OBSERVATION_THRESHOLD # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            { updated: true }
+          rescue StandardError => _e
+            { updated: false }
+          end
+
+          def observation_counts
+            @observation_counts ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def inferred_preferences(owner_id)
+            @inferred_preferences ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences[owner_id.to_s] || [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def clear_observations
+            @observation_counts    = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals   = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences  = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def derive_and_store_observations(owner_id:)
+            @observation_signals ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            signals = @observation_signals[owner_id] || [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+            return if signals.empty?
+
+            inferred = []
+            inferred << derive_verbosity(signals)
+            inferred << derive_tone(signals)
+            inferred << derive_format(signals)
+            inferred = inferred.compact
+
+            @inferred_preferences ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences[owner_id] = inferred # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            inferred.each do |pref|
+              store_preference(
+                owner_id: owner_id,
+                domain:   pref[:domain],
+                value:    pref[:value],
+                source:   pref[:source]
+              )
+            end
+          end
+
+          def derive_verbosity(signals)
+            cli_count = signals.count { |s| s[:channel] == :cli }
+            cli_ratio = cli_count.to_f / signals.size
+            return nil unless cli_ratio >= 0.5
+
+            { domain: 'verbosity', value: 'concise', source: 'observation', confidence: 0.65 }
+          end
+
+          def derive_tone(signals)
+            da_count = signals.count { |s| s[:direct_address] }
+            da_ratio = da_count.to_f / signals.size
+            return nil unless da_ratio >= 0.5
+
+            { domain: 'tone', value: 'conversational', source: 'observation', confidence: 0.65 }
+          end
+
+          def derive_format(signals)
+            unique_channels = signals.map { |s| s[:channel] }.uniq
+            return nil unless unique_channels.size >= 3
+
+            { domain: 'format', value: 'adaptive', source: 'observation', confidence: 0.55 }
+          end
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module Legion
   module Extensions
     module Mesh
@@ -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,6 +145,53 @@ 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
@@ -147,6 +208,10 @@ module Legion
           def mesh_registry
             @mesh_registry ||= Helpers::Registry.new # rubocop:disable Legion/Singleton/UseInstance
           end
+
+          def peer_table
+            @peer_table ||= Helpers::PeerTable.new
+          end
         end
       end
     end

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.2'
+      VERSION = '0.4.4'
     end
   end
 end

data/lib/legion/extensions/mesh.rb

@@ -7,6 +7,7 @@ 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'
@@ -16,7 +17,10 @@ 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

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/helpers/preference_profile_spec.rb

@@ -191,6 +191,81 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
     end
   end
 
+  describe '.update_from_observation' do
+    before { described_class.clear_observations }
+
+    let(:cli_signal)   { { content_type: :text, channel: :cli, direct_address: false } }
+    let(:chat_signal)  { { content_type: :text, channel: :chat, direct_address: true } }
+    let(:mixed_signal) { { content_type: :text, channel: :api, direct_address: false } }
+
+    it 'returns { updated: true } on each call' do
+      result = described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal)
+      expect(result).to eq({ updated: true })
+    end
+
+    it 'accumulates signals per owner_id' do
+      5.times { described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal) }
+      counts = described_class.observation_counts
+      expect(counts['user-obs']).to eq(5)
+    end
+
+    it 'does not infer preferences before threshold (20)' do
+      19.times { described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal) }
+      inferred = described_class.inferred_preferences('user-obs')
+      expect(inferred).to be_empty
+    end
+
+    it 'derives :concise verbosity for CLI-heavy usage after threshold' do
+      20.times { described_class.update_from_observation(owner_id: 'user-cli', signals: cli_signal) }
+      inferred = described_class.inferred_preferences('user-cli')
+      verbosity = inferred.find { |p| p[:domain] == 'verbosity' }
+      expect(verbosity).not_to be_nil
+      expect(verbosity[:value]).to eq('concise')
+      expect(verbosity[:source]).to eq('observation')
+    end
+
+    it 'derives :conversational tone for high direct_address ratio after threshold' do
+      20.times { described_class.update_from_observation(owner_id: 'user-da', signals: chat_signal) }
+      inferred = described_class.inferred_preferences('user-da')
+      tone = inferred.find { |p| p[:domain] == 'tone' }
+      expect(tone).not_to be_nil
+      expect(tone[:value]).to eq('conversational')
+      expect(tone[:source]).to eq('observation')
+    end
+
+    it 'derives :adaptive format for mixed channel usage after threshold' do
+      channels = %i[cli api chat rest]
+      20.times.with_index do |i, _|
+        ch = channels[i % channels.length]
+        described_class.update_from_observation(
+          owner_id: 'user-mix',
+          signals:  { content_type: :text, channel: ch, direct_address: false }
+        )
+      end
+      inferred = described_class.inferred_preferences('user-mix')
+      format = inferred.find { |p| p[:domain] == 'format' }
+      expect(format).not_to be_nil
+      expect(format[:value]).to eq('adaptive')
+      expect(format[:source]).to eq('observation')
+    end
+
+    it 'keeps separate observation counts per owner_id' do
+      3.times { described_class.update_from_observation(owner_id: 'user-a', signals: cli_signal) }
+      7.times { described_class.update_from_observation(owner_id: 'user-b', signals: cli_signal) }
+      counts = described_class.observation_counts
+      expect(counts['user-a']).to eq(3)
+      expect(counts['user-b']).to eq(7)
+    end
+
+    it 'calls store_preference for each inferred preference after threshold' do
+      allow(described_class).to receive(:store_preference).and_call_original
+      20.times { described_class.update_from_observation(owner_id: 'user-store', signals: cli_signal) }
+      expect(described_class).to have_received(:store_preference).with(
+        hash_including(owner_id: 'user-store', source: 'observation')
+      ).at_least(:once)
+    end
+  end
+
   describe '.preference_instructions' do
     it 'generates natural language prompt instructions from profile' do
       profile = {

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

@@ -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.2
+  version: 0.4.4
 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