legionio 1.6.12 → 1.6.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a59ac2f5a5fd0220dcbb5b9831e61219dc4668b8e9d8f65fcbe32be1ed372d1
-  data.tar.gz: 9452932592be1ff4be051490a444880d1974aca50c7f6ca815fe001213998c52
+  metadata.gz: 8682edaf8eaf214c03e6dca287e4298260dde6482506bacee7c6ef247ad1fc8f
+  data.tar.gz: 3f045eec756ee09f7d15ea25c7d40709fd95dd71d6e277845e400c4c6be19f98
 SHA512:
-  metadata.gz: ca9715429a537318d634c59bf3d706656a07bdbbdda1348e675677078e0e714bc6c3c82f659ff17e36da03eeaca1c5128a4e439c89646633cbd9527e04f4f29a
-  data.tar.gz: c9042fc99b86aef9fbd239597736dffa29497850ef8b9e6694aabb0a73b25861196ca73e57febfa7e313f82ba5a0421d0a68d562dd738f1496091c08a5fedaaf
+  metadata.gz: b41ad3b698ae6318ae2a6e7f1c3e0f1d34a46df6dcc183bcf644f5850d458c0d5c1ca080ddee2f81d69dce7a8d5ecdcbb7ae509295a7fd56f852e8f5af8aa189
+  data.tar.gz: 860b776fc04f33f031f07c1969058f4278b8c6a124c09920a54c40b808bdbf708454b8062be32d3960741e8cef5afd1c2c38bb546ad382dd98e528c806a46bf4

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [1.6.13] - 2026-03-27
+
+### Added
+- `DigitalWorker.heartbeat` method for updating worker health status and last heartbeat timestamp
+- `DigitalWorker.detect_orphans` method to find workers with stale or nil heartbeats
+- `DigitalWorker.pause_orphans!` method to auto-pause orphaned workers with event emission
+- Consent tier sync on lifecycle transitions: `worker.update` now includes `consent_tier` from `CONSENT_MAPPING`
+- `Lifecycle.sync_consent_tier` calls `lex-consent` runner when available, graceful degradation when not
+- Per-worker SSE events at `/api/workers/:id/events?stream=true` with queue-per-client filtering
+- Polling fallback for per-worker events via ring buffer filtering (default mode)
+
 ## [1.6.11] - 2026-03-26
 
 ### Added

data/lib/legion/api/workers.rb

@@ -120,7 +120,7 @@ module Legion
           end
         end
 
-        def self.register_sub_resources(app) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def self.register_sub_resources(app) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           app.get '/api/workers/:id/health' do
             require_data!
             worker = Legion::Data::Model::DigitalWorker.first(worker_id: params[:id])
@@ -155,11 +155,39 @@ module Legion
             worker = Legion::Data::Model::DigitalWorker.first(worker_id: params[:id])
             halt 404, json_error('not_found', "Worker #{params[:id]} not found", status_code: 404) if worker.nil?
 
-            json_response({
-                            worker_id: params[:id],
-                            events:    [],
-                            note:      'lifecycle event persistence is not yet implemented'
-                          })
+            if params[:stream] == 'true' && defined?(Legion::Events)
+              content_type 'text/event-stream'
+              headers 'Cache-Control'     => 'no-cache',
+                      'Connection'        => 'keep-alive',
+                      'X-Accel-Buffering' => 'no'
+
+              queue = Queue.new
+              listener = Legion::Events.on('*') do |event|
+                queue.push(event) if event[:worker_id] == params[:id]
+              end
+
+              stream do |out|
+                Thread.new do
+                  loop do
+                    event = queue.pop
+                    data = Legion::JSON.dump({ **event.transform_keys(&:to_s) })
+                    out << "event: #{event[:event]}\ndata: #{data}\n\n"
+                  rescue IOError, Errno::EPIPE
+                    break
+                  end
+                ensure
+                  Legion::Events.off('*', listener)
+                end
+
+                out.callback { Legion::Events.off('*', listener) }
+                out.errback { Legion::Events.off('*', listener) }
+              end
+            else
+              count = (params[:count] || 25).to_i
+              all_events = Routes::Events.recent_events([count * 4, 100].min)
+              filtered = all_events.select { |e| e['worker_id'] == params[:id] || e[:worker_id] == params[:id] }
+              json_response({ worker_id: params[:id], events: filtered.last(count) })
+            end
           end
 
           app.get '/api/workers/:id/costs' do

data/lib/legion/digital_worker/lifecycle.rb

@@ -107,13 +107,16 @@ module Legion
           end
         end
 
+        new_consent = CONSENT_MAPPING[to_state]
         worker.update(
           lifecycle_state: to_state,
+          consent_tier:    new_consent ? new_consent.to_s : worker.consent_tier,
           updated_at:      Time.now.utc,
           retired_at:      %w[retired terminated].include?(to_state) ? Time.now.utc : worker.retired_at,
           retired_by:      %w[retired terminated].include?(to_state) ? by : worker.retired_by,
           retired_reason:  reason || worker.retired_reason
         )
+        sync_consent_tier(worker, new_consent) if new_consent
 
         if defined?(Legion::Events)
           Legion::Events.emit('worker.lifecycle', {
@@ -167,6 +170,18 @@ module Legion
       def self.consent_tier(state)
         CONSENT_MAPPING.fetch(state, :consult)
       end
+
+      def self.sync_consent_tier(worker, tier)
+        return unless defined?(Legion::Extensions::Consent::Runners::Consent)
+
+        Legion::Extensions::Consent::Runners::Consent.update_tier(
+          worker_id: worker.worker_id,
+          tier:      tier.to_s
+        )
+      rescue StandardError => e
+        Legion::Logging.debug("[Lifecycle] consent sync failed for #{worker.worker_id}: #{e.message}") if defined?(Legion::Logging)
+      end
+      private_class_method :sync_consent_tier
     end
   end
 end

data/lib/legion/digital_worker.rb

@@ -43,6 +43,48 @@ module Legion
         Legion::Data::Model::DigitalWorker.where(team: team)
       end
 
+      def heartbeat(worker_id:, health_status: 'healthy', health_node: nil)
+        worker = Legion::Data::Model::DigitalWorker.first(worker_id: worker_id)
+        return nil unless worker
+
+        updates = { last_heartbeat_at: Time.now.utc, health_status: health_status }
+        updates[:health_node] = health_node if health_node
+        worker.update(updates)
+        worker
+      end
+
+      def detect_orphans(stale_days: 7)
+        cutoff = Time.now.utc - (stale_days * 86_400)
+        active = Legion::Data::Model::DigitalWorker.where(lifecycle_state: 'active')
+        active.all.select do |w|
+          w.last_heartbeat_at.nil? || w.last_heartbeat_at < cutoff
+        end
+      end
+
+      def pause_orphans!(stale_days: 7, by: 'system:orphan_detection')
+        orphans = detect_orphans(stale_days: stale_days)
+        orphans.each do |worker|
+          Lifecycle.transition!(
+            worker,
+            to_state:           'paused',
+            by:                 by,
+            reason:             "no heartbeat for #{stale_days}+ days",
+            authority_verified: true
+          )
+          if defined?(Legion::Events)
+            Legion::Events.emit('worker.orphan_detected', {
+                                  worker_id:         worker.worker_id,
+                                  owner_msid:        worker.owner_msid,
+                                  last_heartbeat_at: worker.last_heartbeat_at,
+                                  at:                Time.now.utc
+                                })
+          end
+        rescue Lifecycle::InvalidTransition => e
+          Legion::Logging.debug("[OrphanDetection] skip #{worker.worker_id}: #{e.message}") if defined?(Legion::Logging)
+        end
+        orphans
+      end
+
       def active_local_ids
         return [] unless defined?(Registry)
 

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.12'
+  VERSION = '1.6.13'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.12
+  version: 1.6.13
 platform: ruby
 authors:
 - Esity