legion-gaia 0.9.51 → 0.9.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48ad6f8421723d7d895e4b9d47d17470b4185a9b8ffb9457181a636d770ba021
-  data.tar.gz: 6dd1ad8c144273fd690c5647c9e92992558975a62b0417e6751adb26f77da6f8
+  metadata.gz: 8390ab05b469136c10d656240dd01aed52856c2eb6ad853b566c1bf6712cc351
+  data.tar.gz: '08fa057814b2eb00550a6afb0db16074871a0974a026aa2c8b2caa23768921f4'
 SHA512:
-  metadata.gz: a7d12973d7aa366c1bd1853deeae9af6518c4c6db352f379d2b04b50a17187afd161e1eb6f68b36d5e1754bd00a2c0bfc07f5ba696b6f1e6e2bb9d1e0ab34a6b
-  data.tar.gz: 36e7142df2a327aa193992611d3bfc76350c0ca77465cca388c235aab65a11a3be666e9aab782530fcbbcc736383ef368d71cccd9fad242d5774240fa67ceebe
+  metadata.gz: 0c2a1e84bf1839d3b50db07766243a15cd8bca7c56c6f14bbe68a7c4e9130a414fa745a06d0696901d319b784435943e5965b8397607c19ac9cbaa69bc534424
+  data.tar.gz: 9be977c4a11659433a0e6e7cbe11be7f5aee4692541b46b5be6f5c2856d38f9b1f1991b1653332847b8a57a7a5787b426e720d8b6940c136cb5c0d12b1f6e49d

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.9.52] - 2026-05-07
+
+### Fixed
+- Close the 2026-05-06 GAIA gap-analysis findings across advisory generation, Bot Framework JWT issuer validation, router outbound delivery, offline queuing, proactive partner channels, notification gating, Teams delivery, and shared-state synchronization.
+- Normalize advisory routing hints, support string-keyed tool predictions, and return a stable empty advisory hash when advisory generation fails.
+- Replace high-severity `log.unknown` message tracing with debug logging to avoid production PII log flooding.
+- Harden PR review follow-up behavior for outbound queue acknowledgements, delayed notification TTL preservation, atomic bond channel metadata updates, and adapter delivery-signature caching.
+
 ## [0.9.51] - 2026-04-27
 
 ### Fixed

data/lib/legion/gaia/advisory.rb

@@ -13,7 +13,7 @@ module Legion
       # Returns Hash with optional keys: system_prompt, routing_hint,
       # context_window, tool_hint, suppress, valence
       def advise(caller:, conversation_id: nil, messages: nil)
-        log.unknown "advise(caller: #{caller}, conversation_id: #{conversation_id}, messages: #{messages}) "
+        log.debug "advise(caller: #{caller}, conversation_id: #{conversation_id}, messages: #{messages}) "
         return nil unless Gaia.started?
 
         advisory = {}
@@ -27,17 +27,17 @@ module Legion
         result
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.advisory.advise', conversation_id: conversation_id)
-        nil
+        {}
       end
 
       def merge_tick_data!(advisory, tick_result)
-        log.unknown "merge_tick_data!(#{advisory.inspect}, #{tick_result})"
+        log.debug "merge_tick_data!(#{advisory.inspect}, #{tick_result})"
         return unless tick_result && tick_result[:results]
 
         results = tick_result[:results]
         apply_tool_hints!(advisory, results)
         apply_suppress!(advisory, results)
-        advisory[:routing_hint] = results.dig(:post_tick_reflection, :routing_preference)
+        advisory[:routing_hint] = normalize_routing_hint(results.dig(:post_tick_reflection, :routing_preference))
         advisory[:context_window] = results.dig(:memory_retrieval, :cross_conversation)
       end
 
@@ -45,7 +45,11 @@ module Legion
         predictions = results.dig(:prediction_engine, :predictions)
         return unless predictions
 
-        tools = predictions.select { |p| p[:confidence] >= 0.6 }.map { |p| p[:tool] }
+        tools = predictions.filter_map do |prediction|
+          confidence = value_for(prediction, :confidence).to_f
+          tool = value_for(prediction, :tool)
+          tool if confidence >= 0.6 && tool
+        end
         advisory[:tool_hint] = tools.empty? ? nil : tools
       end
 
@@ -62,11 +66,36 @@ module Legion
         return unless identity
 
         learned = AuditObserver.instance.learned_data_for(identity)
-        advisory[:routing_hint] ||= learned[:routing_preference] if learned[:routing_preference]
+        advisory[:routing_hint] ||= normalize_routing_hint(learned[:routing_preference]) if learned[:routing_preference]
         advisory[:tool_hint] ||= learned[:tool_predictions].keys.first(5) if learned[:tool_predictions]&.any?
       end
 
-      private_class_method :merge_tick_data!, :apply_tool_hints!, :apply_suppress!, :merge_observer_data!
+      def normalize_routing_hint(value)
+        return nil if value.nil?
+
+        if value.is_a?(Hash)
+          provider = value_for(value, :provider)
+          model = value_for(value, :model)
+          return nil if provider.to_s.empty? && model.to_s.empty?
+
+          return { provider: provider&.to_s, model: model&.to_s }
+        end
+
+        { provider: value.to_s, model: nil }
+      end
+
+      def value_for(hash, key)
+        return nil unless hash.respond_to?(:key?)
+
+        string_key = key.to_s
+        return hash[key] if hash.key?(key)
+        return hash[string_key] if hash.key?(string_key)
+
+        nil
+      end
+
+      private_class_method :merge_tick_data!, :apply_tool_hints!, :apply_suppress!, :merge_observer_data!,
+                           :normalize_routing_hint, :value_for
     end
   end
 end

data/lib/legion/gaia/audit_observer.rb

@@ -12,7 +12,6 @@ module Legion
       def initialize
         @user_prefs = {}
         @tool_patterns = {}
-        @quality_log  = []
         @mutex        = Mutex.new
       end
 
@@ -22,7 +21,6 @@ module Legion
         @mutex.synchronize do
           record_routing_preference(event)
           record_tool_patterns(event)
-          record_quality(event)
         end
         identity = extract_caller_identity(event)
         log.debug(
@@ -46,8 +44,7 @@ module Legion
           prefs = @user_prefs[identity] || {}
           {
             routing_preference: prefs[:routing],
-            tool_predictions: top_tools_for_patterns,
-            quality_signals: recent_quality
+            tool_predictions: top_tools_for_patterns
           }
         end
       end
@@ -56,7 +53,6 @@ module Legion
         @mutex.synchronize do
           @user_prefs.clear
           @tool_patterns.clear
-          @quality_log.clear
         end
       end
 
@@ -95,22 +91,9 @@ module Legion
         end
       end
 
-      def record_quality(event)
-        @quality_log << {
-          provider: event.dig(:routing, :provider),
-          tokens: event[:tokens],
-          timestamp: event[:timestamp]
-        }
-        @quality_log.shift if @quality_log.length > 100
-      end
-
       def top_tools_for_patterns
         @tool_patterns.sort_by { |_, v| -v[:count] }.first(10).to_h
       end
-
-      def recent_quality
-        @quality_log.last(10)
-      end
     end
   end
 end

data/lib/legion/gaia/bond_registry.rb

@@ -9,20 +9,37 @@ module Legion
       extend Legion::Logging::Helper
 
       @bonds = Concurrent::Hash.new
+      @mutex = Mutex.new
 
       module_function
 
-      def register(identity, bond: nil, role: nil, priority: :normal, channel_identity: nil)
+      def register(identity, bond: nil, role: nil, priority: :normal, channel_identity: nil,
+                   preferred_channel: nil, last_channel: nil)
         effective_bond = (bond || role || :unknown).to_sym
-        @bonds[identity.to_s] = {
+        @mutex.synchronize do
+          @bonds[identity.to_s] = build_entry(
+            identity,
+            bond: effective_bond,
+            priority: priority,
+            channel_identity: channel_identity,
+            preferred_channel: preferred_channel,
+            last_channel: last_channel
+          )
+        end
+        log.info("BondRegistry registered identity=#{identity} bond=#{effective_bond} priority=#{priority}")
+      end
+
+      def build_entry(identity, bond:, priority:, channel_identity:, preferred_channel:, last_channel:)
+        {
           identity: identity.to_s,
-          bond: effective_bond,
-          role: effective_bond,
+          bond: bond,
+          role: bond,
           priority: priority.to_sym,
           since: Time.now.utc,
-          channel_identity: channel_identity&.to_s
+          channel_identity: channel_identity&.to_s,
+          preferred_channel: preferred_channel&.to_sym,
+          last_channel: last_channel&.to_sym
         }
-        log.info("BondRegistry registered identity=#{identity} bond=#{effective_bond} priority=#{priority}")
       end
 
       def bond(identity)
@@ -53,6 +70,21 @@ module Legion
         @bonds.values
       end
 
+      def record_channel(identity, channel_id:, channel_identity: nil)
+        @mutex.synchronize do
+          entry = @bonds[identity.to_s]
+          return nil unless entry
+
+          channel = channel_id&.to_sym
+          updated = entry.merge(
+            last_channel: channel || entry[:last_channel],
+            preferred_channel: entry[:preferred_channel] || channel,
+            channel_identity: entry[:channel_identity] || channel_identity&.to_s
+          )
+          @bonds[identity.to_s] = updated
+        end
+      end
+
       # Returns the single best partner bond entry using deterministic selection:
       #   1. Prefer entries that have an explicit channel_identity stored (§9.6 guarantee)
       #   2. Then prefer entries with priority: :primary
@@ -81,8 +113,14 @@ module Legion
 
           identities = extract_identity_keys(content)
           priority = content.match?(/primary/i) ? :primary : :normal
-
-          identities.each { |id| register(id, bond: :partner, priority: priority) }
+          channel_identity = extract_channel_identity(content)
+          preferred_channel = extract_channel(content, 'preferred')
+          last_channel = extract_channel(content, 'last')
+
+          identities.each do |id|
+            register(id, bond: :partner, priority: priority, channel_identity: channel_identity,
+                         preferred_channel: preferred_channel, last_channel: last_channel)
+          end
         end
         log.info("BondRegistry hydrated entries=#{result[:results].size}")
       rescue StandardError => e
@@ -90,7 +128,7 @@ module Legion
       end
 
       def reset!
-        @bonds = Concurrent::Hash.new
+        @mutex.synchronize { @bonds = Concurrent::Hash.new }
         log.debug('BondRegistry reset')
       end
 
@@ -100,7 +138,25 @@ module Legion
 
         match[1].split(/[,\s]+/).map(&:strip).reject(&:empty?)
       end
-      private_class_method :extract_identity_keys
+
+      def extract_channel_identity(content)
+        match = content.match(/channel[_\s-]*identity[:\s]+([^\n]+)/i)
+        first_match_value(match)
+      end
+
+      def extract_channel(content, kind)
+        match = content.match(/#{kind}[_\s-]*channel[:\s]+([^\n]+)/i)
+        first_match_value(match)
+      end
+
+      def first_match_value(match)
+        return nil unless match
+
+        match[1].split(/[,\s]+/).first&.strip
+      end
+
+      private_class_method :build_entry, :extract_identity_keys, :extract_channel_identity, :extract_channel,
+                           :first_match_value
     end
   end
 end

data/lib/legion/gaia/channel_adapter.rb

@@ -63,7 +63,7 @@ module Legion
       protected
 
       def build_intent_metadata(content)
-        require_relative 'intent_classifier' unless defined?(IntentClassifier)
+        require_relative 'intent_classifier' unless defined?(Legion::Gaia::IntentClassifier)
         classification = IntentClassifier.classify_with_engagement(content)
         {
           interaction_intent: classification[:intent],

data/lib/legion/gaia/channel_registry.rb

@@ -5,12 +5,14 @@ module Legion
     class ChannelRegistry
       def initialize
         @adapters = {}
+        @deliver_signature_cache = {}
         @mutex = Mutex.new
       end
 
       def register(adapter)
         @mutex.synchronize do
           @adapters[adapter.channel_id] = adapter
+          @deliver_signature_cache.delete(adapter.class)
         end
       end
 
@@ -46,7 +48,8 @@ module Legion
         end
 
         rendered = adapter.translate_outbound(output_frame)
-        normalize_delivery_result(adapter.deliver(rendered), channel_id: output_frame.channel_id)
+        normalize_delivery_result(deliver_to_adapter(adapter, rendered, output_frame),
+                                  channel_id: output_frame.channel_id)
       end
 
       def start_all
@@ -59,6 +62,34 @@ module Legion
 
       private
 
+      def deliver_to_adapter(adapter, rendered, output_frame)
+        conversation_id = output_frame.metadata[:conversation_id]
+        if conversation_id && deliver_accepts_conversation_id?(adapter)
+          adapter.deliver(rendered, conversation_id: conversation_id)
+        else
+          adapter.deliver(rendered)
+        end
+      end
+
+      def deliver_accepts_conversation_id?(adapter)
+        adapter_class = adapter.class
+        @mutex.synchronize do
+          return @deliver_signature_cache[adapter_class] if @deliver_signature_cache.key?(adapter_class)
+        end
+
+        accepts_conversation_id = deliver_parameters(adapter).any? do |type, name|
+          %i[key keyreq].include?(type) && name == :conversation_id
+        end
+        @mutex.synchronize { @deliver_signature_cache[adapter_class] = accepts_conversation_id }
+        accepts_conversation_id
+      end
+
+      def deliver_parameters(adapter)
+        adapter.class.instance_method(:deliver).parameters
+      rescue StandardError
+        adapter.method(:deliver).parameters
+      end
+
       def normalize_delivery_result(result, channel_id:)
         return { delivered: false, reason: :adapter_returned_false, channel_id: channel_id } if result == false
         return { delivered: true, channel_id: channel_id } unless result.is_a?(Hash)

data/lib/legion/gaia/channels/cli_adapter.rb

@@ -15,6 +15,7 @@ module Legion
         def initialize
           super(channel_id: :cli, capabilities: CAPABILITIES)
           @output_buffer = []
+          @mutex = Mutex.new
         end
 
         def translate_inbound(raw_input)
@@ -35,22 +36,24 @@ module Legion
         end
 
         def deliver(rendered_content)
-          @output_buffer << rendered_content
+          @mutex.synchronize { @output_buffer << rendered_content }
           rendered_content
         end
 
         def drain_output
-          output = @output_buffer.dup
-          @output_buffer.clear
-          output
+          @mutex.synchronize do
+            output = @output_buffer.dup
+            @output_buffer.clear
+            output
+          end
         end
 
         def last_output
-          @output_buffer.last
+          @mutex.synchronize { @output_buffer.last }
         end
 
         def output_buffer_size
-          @output_buffer.size
+          @mutex.synchronize { @output_buffer.size }
         end
       end
     end

data/lib/legion/gaia/channels/teams/bot_framework_auth.rb

@@ -102,15 +102,17 @@ module Legion
           end
 
           def jwks_keys
-            now = Time.now.to_i
-            cache = @jwks_cache
-            return cache[:keys] if cache && cache[:expires_at] > now
-
-            metadata = fetch_json(OPENID_METADATA_URL)
-            jwks_uri = metadata['jwks_uri']
-            keys = fetch_json(jwks_uri).fetch('keys', [])
-            @jwks_cache = { keys: keys, expires_at: now + JWKS_CACHE_TTL }
-            keys
+            jwks_mutex.synchronize do
+              now = Time.now.to_i
+              cache = @jwks_cache
+              return cache[:keys] if cache && cache[:expires_at] > now
+
+              metadata = fetch_json(OPENID_METADATA_URL)
+              jwks_uri = metadata['jwks_uri']
+              keys = fetch_json(jwks_uri).fetch('keys', [])
+              @jwks_cache = { keys: keys, expires_at: now + JWKS_CACHE_TTL }
+              keys
+            end
           end
 
           def fetch_json(url)
@@ -146,12 +148,23 @@ module Legion
             issuer = payload['iss']
             valid_issuers = [BOT_FRAMEWORK_ISSUER]
             valid_issuers << EMULATOR_ISSUER if allow_emulator
-            valid_issuers.any? { |i| issuer&.start_with?(i) || issuer == i }
+            valid_issuers.any? { |valid_issuer| issuer_matches?(issuer, valid_issuer) }
           end
 
           def check_issuer(payload, _allow_emulator)
             { valid: false, error: :invalid_issuer, issuer: payload['iss'] }
           end
+
+          def issuer_matches?(issuer, valid_issuer)
+            return false if issuer.to_s.empty?
+
+            prefix = valid_issuer.end_with?('/') ? valid_issuer : "#{valid_issuer}/"
+            issuer == valid_issuer || issuer.start_with?(prefix)
+          end
+
+          def jwks_mutex
+            @jwks_mutex ||= Mutex.new
+          end
         end
       end
     end

data/lib/legion/gaia/channels/teams/webhook_handler.rb

@@ -91,7 +91,8 @@ module Legion
           end
 
           def error_response(type, detail)
-            { status: 401, type: type, detail: detail }
+            status = %i[missing_auth auth_failed].include?(type) ? 401 : 400
+            { status: status, type: type, detail: detail }
           end
         end
       end

data/lib/legion/gaia/intent_classifier.rb

@@ -17,7 +17,7 @@ module Legion
       module_function
 
       def classify(content)
-        log.unknown "classify(#{content})"
+        log.debug "classify(#{content})"
         text = content.to_s.strip
         return :casual if text.empty?
 
@@ -31,12 +31,12 @@ module Legion
       end
 
       def direct_engage?(content)
-        log.unknown "direct_engage?(#{content})"
+        log.debug "direct_engage?(#{content})"
         content.to_s.match?(DIRECT_ADDRESS_PATTERN)
       end
 
       def classify_with_engagement(content)
-        log.unknown "classify_with_engagement(#{content})"
+        log.debug "classify_with_engagement(#{content})"
         { intent: classify(content), direct_engage: direct_engage?(content) }
       end
     end

data/lib/legion/gaia/notification_gate/behavioral_evaluator.rb

@@ -25,14 +25,14 @@ module Legion
           signals << arousal_signal if @arousal
           signals << idle_signal if @idle_seconds
 
-          return 1.0 if signals.empty?
+          return 0.0 if signals.empty?
 
           signals.sum / signals.size
         end
 
         def should_deliver?(priority: :normal)
           base = PRIORITY_BASE_THRESHOLD[priority] || PRIORITY_BASE_THRESHOLD[:normal]
-          effective_threshold = base + ((1.0 - notification_score) * THRESHOLD_MODIFIER)
+          effective_threshold = base + (notification_score * THRESHOLD_MODIFIER)
           priority_value(priority) >= effective_threshold
         end
 

data/lib/legion/gaia/notification_gate/delay_queue.rb

@@ -22,6 +22,15 @@ module Legion
           end
         end
 
+        def requeue(entry)
+          @mutex.synchronize do
+            evicted = nil
+            evicted = @entries.shift if @entries.size >= @max_size
+            @entries << entry.merge(retry_count: entry[:retry_count].to_i + 1)
+            evicted
+          end
+        end
+
         def size
           @mutex.synchronize { @entries.size }
         end

data/lib/legion/gaia/notification_gate/schedule_evaluator.rb

@@ -39,6 +39,10 @@ module Legion
           Australia/Sydney Australia/Melbourne Pacific/Auckland
         ].freeze
 
+        SOUTHERN_DST_ZONES = %w[
+          Australia/Sydney Australia/Melbourne Pacific/Auckland
+        ].freeze
+
         def initialize(schedule: [])
           @schedule = normalize_schedule(schedule)
         end
@@ -88,22 +92,22 @@ module Legion
         def localize(time, timezone)
           return time unless timezone
 
-          offset = tz_offset(timezone)
+          offset = tz_offset(timezone, time)
           offset ? time.getlocal(offset) : time
         end
 
-        def tz_offset(timezone)
+        def tz_offset(timezone, time = Time.now)
           return nil unless timezone
-          return tzinfo_offset(timezone) if defined?(TZInfo)
+          return tzinfo_offset(timezone, time) if defined?(TZInfo)
 
           base = STANDARD_OFFSETS[timezone]
           return nil unless base
 
-          dst_active? && DST_ZONES.include?(timezone) ? dst_shift(base) : base
+          dst_active?(timezone, time) && DST_ZONES.include?(timezone) ? dst_shift(base) : base
         end
 
-        def tzinfo_offset(timezone)
-          hours = TZInfo::Timezone.get(timezone).current_period.utc_total_offset / 3600.0
+        def tzinfo_offset(timezone, time)
+          hours = TZInfo::Timezone.get(timezone).period_for_utc(time.utc).utc_total_offset / 3600.0
           sign = hours.negative? ? '-' : '+'
           abs_h = hours.abs.to_i
           abs_m = ((hours.abs % 1) * 60).round
@@ -124,9 +128,11 @@ module Legion
           format('%<sign>s%<h>02d:%<m>02d', sign: new_sign, h: abs_total / 60, m: abs_total % 60)
         end
 
-        def dst_active?
-          m = Time.now.utc.month
-          m.between?(3, 11)
+        def dst_active?(timezone, time)
+          month = time.utc.month
+          return month >= 10 || month <= 4 if SOUTHERN_DST_ZONES.include?(timezone)
+
+          month.between?(3, 11)
         end
       end
     end

data/lib/legion/gaia/notification_gate.rb

@@ -54,14 +54,22 @@ module Legion
       end
 
       def process_delayed
-        expired = @delay_queue.drain_expired
-        deliverable = expired.map { |e| e[:frame] }
+        candidates = @delay_queue.drain_expired
 
         unless @schedule_evaluator.quiet?
           flushed = @delay_queue.flush
-          deliverable.concat(flushed.map { |e| e[:frame] })
+          candidates.concat(flushed)
         end
 
+        deliverable = []
+        candidates.each do |entry|
+          frame = entry[:frame]
+          if evaluate(frame) == :deliver
+            deliverable << frame
+          else
+            @delay_queue.requeue(entry)
+          end
+        end
         deliverable
       end
 

data/lib/legion/gaia/offline_handler.rb

@@ -21,37 +21,41 @@ module Legion
         end
 
         def agent_online?(worker_id)
-          presence = presence_store[worker_id]
+          presence = mutex.synchronize { presence_store[worker_id] }
           return false unless presence
 
           (Time.now - presence[:last_seen]) < offline_threshold
         end
 
         def record_presence(worker_id)
-          presence_store[worker_id] = { last_seen: Time.now }
+          mutex.synchronize { presence_store[worker_id] = { last_seen: Time.now } }
           log.debug("OfflineHandler recorded presence worker_id=#{worker_id}")
         end
 
         def pending_count(worker_id)
-          pending_store[worker_id]&.size || 0
+          mutex.synchronize { pending_store[worker_id]&.size || 0 }
         end
 
         def drain_pending(worker_id)
-          drained = pending_store.delete(worker_id) || []
+          drained = mutex.synchronize { pending_store.delete(worker_id) || [] }
           log.info("OfflineHandler drained pending worker_id=#{worker_id} count=#{drained.size}") if drained.any?
           drained
         end
 
         def reset!
-          @presence_store = {}
-          @pending_store = {}
+          mutex.synchronize do
+            @presence_store = {}
+            @pending_store = {}
+          end
         end
 
         private
 
         def queue_message(frame, worker_id)
-          pending_store[worker_id] ||= []
-          pending_store[worker_id] << { frame: frame, queued_at: Time.now }
+          mutex.synchronize do
+            pending_store[worker_id] ||= []
+            pending_store[worker_id] << { frame: frame, queued_at: Time.now }
+          end
         end
 
         def notify_sender(frame)
@@ -92,6 +96,10 @@ module Legion
         def pending_store
           @pending_store ||= {}
         end
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
       end
     end
   end

data/lib/legion/gaia/phase_wiring.rb

@@ -201,18 +201,21 @@ module Legion
       }.freeze
 
       @previous_reflection = {}
+      @previous_reflection_mutex = Mutex.new
 
       module_function
 
       def previous_reflection
-        @previous_reflection || {}
+        @previous_reflection_mutex.synchronize { @previous_reflection || {} }
       end
 
       def capture_tick_results(results)
         return unless results.is_a?(Hash)
 
         refl = results[:post_tick_reflection]
-        @previous_reflection = refl if refl.is_a?(Hash) && refl[:status] != :skipped
+        @previous_reflection_mutex.synchronize do
+          @previous_reflection = refl if refl.is_a?(Hash) && refl[:status] != :skipped
+        end
       end
 
       def build_cognitive_state(prior_results)

data/lib/legion/gaia/proactive_dispatcher.rb

@@ -23,43 +23,57 @@ module Legion
         @dispatch_log    = []
         @pending_buffer  = []
         @last_ignored_at = nil
+        @mutex           = Mutex.new
       end
 
       def can_dispatch?
-        prune_old_dispatches!
-        return false if @dispatch_log.size >= @max_per_day
-        return false if @dispatch_log.any? && (Time.now.utc - @dispatch_log.last[:at]) < @min_interval
-        return false if @last_ignored_at && (Time.now.utc - @last_ignored_at) < @ignore_cooldown
+        @mutex.synchronize do
+          prune_old_dispatches!
+          return false if @dispatch_log.size >= @max_per_day
+          return false if @dispatch_log.any? && (Time.now.utc - @dispatch_log.last[:at]) < @min_interval
+          return false if @last_ignored_at && (Time.now.utc - @last_ignored_at) < @ignore_cooldown
+        end
 
         true
       end
 
       def record_dispatch!
-        prune_old_dispatches!
-        @dispatch_log << { at: Time.now.utc }
-        log.info("ProactiveDispatcher recorded dispatch count=#{@dispatch_log.size}")
+        count = @mutex.synchronize do
+          prune_old_dispatches!
+          @dispatch_log << { at: Time.now.utc }
+          @dispatch_log.size
+        end
+        log.info("ProactiveDispatcher recorded dispatch count=#{count}")
       end
 
       def record_ignored!
-        @last_ignored_at = Time.now.utc
+        @mutex.synchronize { @last_ignored_at = Time.now.utc }
         log.info('ProactiveDispatcher recorded ignored interaction')
       end
 
       def dispatches_today
-        prune_old_dispatches!
-        @dispatch_log.size
+        @mutex.synchronize do
+          prune_old_dispatches!
+          @dispatch_log.size
+        end
       end
 
       def queue_intent(intent)
-        @pending_buffer << intent
-        @pending_buffer.shift while @pending_buffer.size > MAX_PENDING
+        pending = @mutex.synchronize do
+          @pending_buffer << intent
+          @pending_buffer.shift while @pending_buffer.size > MAX_PENDING
+          @pending_buffer.size
+        end
         log.info("ProactiveDispatcher queued intent reason=#{intent.dig(:trigger,
-                                                                        :reason)} pending=#{@pending_buffer.size}")
+                                                                        :reason)} pending=#{pending}")
       end
 
       def drain_pending
-        drained = @pending_buffer.dup
-        @pending_buffer.clear
+        drained = @mutex.synchronize do
+          copy = @pending_buffer.dup
+          @pending_buffer.clear
+          copy
+        end
         log.info("ProactiveDispatcher drained pending count=#{drained.size}") if drained.any?
         drained
       end

data/lib/legion/gaia/router/router_bridge.rb

@@ -11,8 +11,8 @@ module Legion
         attr_reader :worker_routing, :channel_registry, :started
 
         def initialize(channel_registry:, worker_routing: nil, allowed_worker_ids: [])
-          log.unknown "initialize(channel_registry: #{channel_registry}, " \
-                      "worker_routing: #{worker_routing}, allowed_worker_ids: #{allowed_worker_ids}"
+          log.debug "initialize(channel_registry: #{channel_registry}, " \
+                    "worker_routing: #{worker_routing}, allowed_worker_ids: #{allowed_worker_ids}"
           @channel_registry = channel_registry
           @worker_routing = worker_routing || WorkerRouting.new(allowed_worker_ids: allowed_worker_ids)
           @started = false
@@ -20,10 +20,12 @@ module Legion
 
         def start
           @started = true
+          subscribe_outbound if transport_available?
           log.info("RouterBridge started workers=#{@worker_routing.size}")
         end
 
         def stop
+          @outbound_consumer&.cancel if @outbound_consumer.respond_to?(:cancel)
           @started = false
           log.info('RouterBridge stopped')
         end
@@ -33,7 +35,7 @@ module Legion
         end
 
         def route_inbound(input_frame)
-          log.unknown "route_inbound(input_frame: #{input_frame})"
+          log.debug "route_inbound(input_frame: #{input_frame})"
           return { routed: false, reason: :not_started } unless started?
 
           identity = extract_identity(input_frame)
@@ -47,7 +49,7 @@ module Legion
         end
 
         def route_outbound(payload)
-          log.unknown "route_outbound(payload: #{payload})"
+          log.debug "route_outbound(payload: #{payload})"
           return { delivered: false, reason: :not_started } unless started?
 
           frame = reconstruct_output_frame(payload)
@@ -82,6 +84,31 @@ module Legion
 
         private
 
+        def subscribe_outbound
+          queue = Transport::Queues::Outbound.new
+          @outbound_consumer = queue.subscribe(manual_ack: true, block: false) do |delivery_info, _metadata, payload|
+            message = decode_payload(payload)
+            unless message
+              queue.reject(delivery_info.delivery_tag, requeue: false)
+              next
+            end
+
+            delivery_result = route_outbound(message)
+            if delivery_result.is_a?(Hash) && delivery_result[:delivered] == true && !delivery_result[:error]
+              queue.acknowledge(delivery_info.delivery_tag)
+            else
+              log.warn(
+                'RouterBridge outbound delivery not acknowledged ' \
+                "reason=#{delivery_result[:reason] || delivery_result[:error] || :unknown}"
+              )
+              queue.reject(delivery_info.delivery_tag, requeue: true)
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'gaia.router.router_bridge.subscribe_outbound')
+            queue.reject(delivery_info.delivery_tag, requeue: false)
+          end
+        end
+
         def extract_identity(input_frame)
           input_frame.auth_context[:principal_id] ||
             input_frame.auth_context[:aad_object_id] ||
@@ -108,15 +135,25 @@ module Legion
 
         def offline_response(input_frame)
           identity = extract_identity(input_frame)
+          offline_result = OfflineHandler.handle_offline_delivery(input_frame, worker_id: identity || :unassigned)
           log.warn("RouterBridge could not route inbound frame_id=#{input_frame.id} identity=#{identity}")
           {
             routed: false,
             reason: :worker_not_found,
             identity: identity,
-            frame_id: input_frame.id
+            frame_id: input_frame.id,
+            queued: offline_result[:queued]
           }
         end
 
+        def decode_payload(raw)
+          parsed = Legion::JSON.load(raw)
+          parsed.is_a?(Hash) ? parsed : nil
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'gaia.router.router_bridge.decode_payload')
+          nil
+        end
+
         def reconstruct_output_frame(payload)
           OutputFrame.new(
             id: payload[:id],

data/lib/legion/gaia/router/worker_routing.rb

@@ -9,7 +9,7 @@ module Legion
         attr_reader :allowed_worker_ids
 
         def initialize(allowed_worker_ids: [])
-          log.unknown "initialize(allowed_worker_ids: #{allowed_worker_ids})"
+          log.debug "initialize(allowed_worker_ids: #{allowed_worker_ids})"
           @routes = {}
           @allowed_worker_ids = allowed_worker_ids
           @mutex = Mutex.new

data/lib/legion/gaia/routes.rb

@@ -10,7 +10,7 @@
 module Legion
   module Gaia
     module Routes
-      def self.registered(app)
+      def self.registered(app) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         app.helpers do # rubocop:disable Metrics/BlockLength
           unless method_defined?(:gaia_available?)
             define_method(:gaia_available?) do
@@ -47,9 +47,9 @@ module Legion
           end
 
           unless method_defined?(:json_error)
-            define_method(:json_error) do |code, message, status_code: 400|
+            define_method(:json_error) do |code, message, status_code: nil|
               content_type :json
-              status status_code
+              status status_code if status_code
               Legion::JSON.dump({ error: { code: code, message: message } })
             end
           end
@@ -76,7 +76,7 @@ module Legion
 
       def self.register_ticks_route(app)
         app.get '/api/gaia/ticks' do
-          halt 503, json_error('gaia_unavailable', 'gaia is not started', status_code: 503) unless gaia_available?
+          halt 503, json_error('gaia_unavailable', 'gaia is not started') unless gaia_available?
 
           max_limit =
             if defined?(Legion::Gaia::TickHistory) && Legion::Gaia::TickHistory.const_defined?(:MAX_ENTRIES)
@@ -93,7 +93,7 @@ module Legion
 
       def self.register_channels_route(app)
         app.get '/api/gaia/channels' do
-          halt 503, json_error('gaia_unavailable', 'gaia is not started', status_code: 503) unless gaia_available?
+          halt 503, json_error('gaia_unavailable', 'gaia is not started') unless gaia_available?
 
           registry = Legion::Gaia.channel_registry
           return json_response({ channels: [] }) unless registry
@@ -109,7 +109,7 @@ module Legion
 
       def self.register_buffer_route(app)
         app.get '/api/gaia/buffer' do
-          halt 503, json_error('gaia_unavailable', 'gaia is not started', status_code: 503) unless gaia_available?
+          halt 503, json_error('gaia_unavailable', 'gaia is not started') unless gaia_available?
 
           buffer = Legion::Gaia.sensory_buffer
           json_response({
@@ -122,7 +122,7 @@ module Legion
 
       def self.register_sessions_route(app)
         app.get '/api/gaia/sessions' do
-          halt 503, json_error('gaia_unavailable', 'gaia is not started', status_code: 503) unless gaia_available?
+          halt 503, json_error('gaia_unavailable', 'gaia is not started') unless gaia_available?
 
           store = Legion::Gaia.session_store
           json_response({
@@ -176,14 +176,14 @@ module Legion
 
       def self.register_ingest_route(app)
         app.post '/api/gaia/ingest' do
-          halt 503, json_error('gaia_unavailable', 'gaia is not started', status_code: 503) unless gaia_available?
+          halt 503, json_error('gaia_unavailable', 'gaia is not started') unless gaia_available?
 
           body = Legion::JSON.load(request.body.read)
           content  = body[:content] || body['content']
           identity = body[:identity] || body['identity'] || 'unknown'
           channel  = (body[:channel_id] || body['channel_id'] || 'cli').to_sym
 
-          halt 400, json_error('missing_content', 'content is required', status_code: 400) if content.to_s.empty?
+          halt 400, json_error('missing_content', 'content is required') if content.to_s.empty?
 
           frame = Legion::Gaia::InputFrame.new(
             content: content,

data/lib/legion/gaia/session_store.rb

@@ -110,7 +110,7 @@ module Legion
         # during the migration window.
         @identity_index[normalized_identity] = old_session_id
         @canonical_to_uuid[canonical_key] = normalized_identity
-        (@session_identity_index[old_session_id] ||= []) << normalized_identity
+        (@session_identity_index[old_session_id] ||= []).push(canonical_key, normalized_identity).uniq!
         old_session_id
       end
 

data/lib/legion/gaia/tick_history.rb

@@ -17,12 +17,12 @@ module Legion
       def record(tick_result)
         return unless tick_result.is_a?(Hash) && tick_result[:results].is_a?(Hash)
 
-        timestamp = Time.now.utc.iso8601
+        timestamp = Time.now.utc.iso8601(3).freeze
         new_events = tick_result[:results].filter_map do |phase_name, phase_data|
           next unless phase_data.is_a?(Hash)
 
           {
-            timestamp: timestamp.freeze,
+            timestamp: timestamp,
             phase: phase_name.to_s.freeze,
             duration_ms: phase_data[:elapsed_ms] || phase_data[:duration_ms] || 0.0,
             status: phase_data[:status] || :completed

data/lib/legion/gaia/tracker_persistence.rb

@@ -12,13 +12,15 @@ module Legion
       module_function
 
       def register_tracker(name, tracker:, tags:)
-        @trackers ||= {}
-        @trackers[name] = { tracker: tracker, tags: tags }
+        mutex.synchronize do
+          @trackers ||= {}
+          @trackers[name] = { tracker: tracker, tags: tags }
+        end
         log.info("TrackerPersistence registered tracker=#{name} tags=#{Array(tags).join(',')}")
       end
 
       def registered_trackers
-        @trackers || {}
+        mutex.synchronize { (@trackers || {}).dup }
       end
 
       def flush_dirty(store: nil)
@@ -26,7 +28,8 @@ module Legion
 
         failed = false
         flushed = 0
-        registered_trackers.each_value do |entry|
+        entries = registered_trackers.values
+        entries.each do |entry|
           tracker = entry[:tracker]
           next unless tracker.dirty?
 
@@ -36,7 +39,7 @@ module Legion
             failed = true
           end
         end
-        @last_flush_at = Time.now.utc unless failed
+        mutex.synchronize { @last_flush_at = Time.now.utc } unless failed
         if failed
           log.warn("TrackerPersistence flush_dirty completed with errors flushed=#{flushed}")
         else
@@ -50,11 +53,12 @@ module Legion
         return unless store
 
         failed = false
-        registered_trackers.each_value do |entry|
+        entries = registered_trackers.values
+        entries.each do |entry|
           failed ||= !flush_tracker(entry[:tracker], store: store)
         end
-        @last_flush_at = Time.now.utc unless failed
-        log.info("TrackerPersistence flushed all trackers count=#{registered_trackers.size}")
+        mutex.synchronize { @last_flush_at = Time.now.utc } unless failed
+        log.info("TrackerPersistence flushed all trackers count=#{entries.size}")
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.tracker_persistence.flush_all')
       end
@@ -71,18 +75,22 @@ module Legion
       end
 
       def last_flush_at
-        @last_flush_at
+        mutex.synchronize { @last_flush_at }
       end
 
       def should_flush?
-        return true if @last_flush_at.nil?
+        mutex.synchronize do
+          return true if @last_flush_at.nil?
 
-        (Time.now.utc - @last_flush_at) >= FLUSH_INTERVAL
+          (Time.now.utc - @last_flush_at) >= FLUSH_INTERVAL
+        end
       end
 
       def reset!
-        @trackers = {}
-        @last_flush_at = nil
+        mutex.synchronize do
+          @trackers = {}
+          @last_flush_at = nil
+        end
       end
 
       def flush_tracker(tracker, store:)
@@ -118,6 +126,11 @@ module Legion
         true
       end
       private_class_method :upsert_succeeded?
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+      private_class_method :mutex
     end
   end
 end

data/lib/legion/gaia/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Gaia
-    VERSION = '0.9.51'
+    VERSION = '0.9.52'
   end
 end

data/lib/legion/gaia/workflow/instance.rb

@@ -51,16 +51,18 @@ module Legion
           self
         end
 
-        # Non-raising variant — returns true on success, false on guard/checkpoint failure.
-        # Unknown-state and invalid-transition errors still propagate.
+        # Non-raising variant — returns true on success, false on transition failure.
+        # Pass strict: true to propagate unknown-state and invalid-transition errors.
         #
         # @param to_state [Symbol]
         # @param ctx [Hash]
         # @return [Boolean]
-        def transition(to_state, **ctx)
+        def transition(to_state, strict: false, **ctx)
           transition!(to_state, **ctx)
           true
-        rescue GuardRejected, CheckpointBlocked => e
+        rescue GuardRejected, CheckpointBlocked, UnknownState, InvalidTransition => e
+          raise if strict && (e.is_a?(UnknownState) || e.is_a?(InvalidTransition))
+
           handle_exception(e, level: :debug, operation: 'gaia.workflow.instance.transition',
                               workflow: definition.name, to_state: to_state)
           false

data/lib/legion/gaia.rb

@@ -206,6 +206,10 @@ module Legion
         session = @session_store&.find_or_create(identity: identity || :anonymous)
         @session_store&.touch(session.id, channel_id: input_frame.channel_id) if session
 
+        if identity
+          BondRegistry.record_channel(identity.to_s, channel_id: input_frame.channel_id,
+                                                     channel_identity: channel_identity(input_frame))
+        end
         observe_interlocutor(input_frame, identity) if identity && identity != :anonymous
 
         log.info(
@@ -387,8 +391,6 @@ module Legion
       end
 
       def boot_agent_bridge
-        return unless settings&.dig(:router, :mode)
-
         worker_id = settings&.dig(:router, :worker_id)
         return unless worker_id
 
@@ -499,6 +501,11 @@ module Legion
           ctx[:user_id]
       end
 
+      def channel_identity(input_frame)
+        ctx = input_frame.auth_context || {}
+        ctx[:channel_identity] || ctx[:user_id] || ctx[:identity]
+      end
+
       def observe_interlocutor(input_frame, identity)
         role = BondRegistry.bond(identity.to_s)
 
@@ -544,7 +551,7 @@ module Legion
           },
           domain_tags: ['partner_interaction', observation[:channel].to_s],
           origin: :direct_experience,
-          emotional_valence: @last_valences&.dig(0, :urgency).to_s,
+          emotional_valence: @last_valences&.first&.inspect,
           emotional_intensity: 0.5,
           confidence: 0.8
         )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.51
+  version: 0.9.52
 platform: ruby
 authors:
 - Esity