lex-tick 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3be4c9e415b8ecb5f4bf87248edbc9d25192c1ad57892ed975ef722e517bc95
-  data.tar.gz: 4ddcbe7624bbab90a6fa463aa6c03cc36ae5ebe3efa9af121cc675fe3287e6cb
+  metadata.gz: 5c8a9b49e730209a458c58291781bc1973ce091b09363f5d530475632bccf177
+  data.tar.gz: 27e6ad3c2d0690b7258171affd31e43514090d824d66a153b16a1e57faa09f66
 SHA512:
-  metadata.gz: 9461d3f7247953b00d7a08263185128834584bc798877a120df3453773d9c0556f32777420cb4c9a9132c333544907009a6d8076681e2cc5c962cbe5ab369649
-  data.tar.gz: 379fbad5fccc9573de1a3b8ac0ccd660d918c86a5fc08858000b549cb341d925b98692a97e99eef4aab5a4ad13d73dcf31244725aef9b91edb13fc813dd76e23
+  metadata.gz: bd517d24eb257869fb775c52b7dd5448fdd140ad72899441edffe6ebd118888c91258b10052128f579b7dc6a747ad02721e897b76fb0db0c85fcdc3ec7d12368
+  data.tar.gz: d303fd69ff1ad994460a7531f32553cc80a14855cfbb0c3eb20b94c50a894b32a860de5dbdb217310c650d5b6ab9f33abdd7d86ba82e56e634fc2d7e462dfa30

data/lib/legion/extensions/tick/actors/tick.rb

@@ -19,10 +19,14 @@ module Legion
           end
 
           def runner_class
+            return Legion::Gaia if gaia_heartbeat_available?
+
             Legion::Extensions::Tick::Runners::Orchestrator
           end
 
           def runner_function
+            return 'heartbeat' if gaia_heartbeat_available?
+
             'execute_tick'
           end
 
@@ -51,11 +55,23 @@ module Legion
           end
 
           def args
+            return {} if gaia_heartbeat_available?
+
             { signals: [], phase_handlers: {} }
           end
 
           private
 
+          def gaia_heartbeat_available?
+            return false unless defined?(Legion::Gaia)
+            return false unless Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started?
+
+            !Legion::Gaia.respond_to?(:router_mode?) || !Legion::Gaia.router_mode?
+          rescue StandardError => e
+            log.debug "gaia_heartbeat_available? check failed: #{e.message}"
+            false
+          end
+
           def apply_initial_jitter
             return unless Helpers::Jitter.jitter_enabled?
 

data/lib/legion/extensions/tick/helpers/state.rb

@@ -18,9 +18,11 @@ module Legion
             @mode_history = [{ mode: mode, at: Time.now.utc }]
           end
 
-          def record_signal(salience: 0.0)
+          def record_signal(salience: 0.0, source_type: nil)
             @last_signal_at = Time.now.utc
-            @last_high_salience_at = Time.now.utc if salience >= Constants::HIGH_SALIENCE_THRESHOLD
+            return unless salience >= Constants::HIGH_SALIENCE_THRESHOLD || source_type == :human_direct
+
+            @last_high_salience_at = Time.now.utc
           end
 
           def record_phase(phase, result)
@@ -43,13 +45,13 @@ module Legion
           end
 
           def seconds_since_signal
-            return Float::INFINITY unless @last_signal_at
+            return 0.0 unless @last_signal_at
 
             Time.now.utc - @last_signal_at
           end
 
           def seconds_since_high_salience
-            return Float::INFINITY unless @last_high_salience_at
+            return 0.0 unless @last_high_salience_at
 
             Time.now.utc - @last_high_salience_at
           end

data/lib/legion/extensions/tick/runners/orchestrator.rb

@@ -12,16 +12,16 @@ module Legion
             false
           end
 
-          def execute_tick(signals: [], phase_handlers: {}, **)
+          def execute_tick(signals: [], phase_handlers: {}, **context)
             if defined?(Legion::Telemetry::OpenInference)
               state = tick_state
               Legion::Telemetry::OpenInference.agent_span(
                 name: "tick-#{state.tick_count + 1}", mode: state.mode,
                 phase_count: Helpers::Constants.phases_for_mode(state.mode).size,
                 budget_ms: (Helpers::Constants.tick_budget(state.mode) * 1000).round
-              ) { |_span| execute_tick_impl(signals: signals, phase_handlers: phase_handlers) }
+              ) { |_span| execute_tick_impl(signals: signals, phase_handlers: phase_handlers, **context) }
             else
-              execute_tick_impl(signals: signals, phase_handlers: phase_handlers)
+              execute_tick_impl(signals: signals, phase_handlers: phase_handlers, **context)
             end
           end
 
@@ -68,7 +68,7 @@ module Legion
                            :sentinel
                          end
                        when :full_active
-                         if state.seconds_since_high_salience >= Helpers::Constants::ACTIVE_TIMEOUT
+                         if full_active_cooldown_elapsed(state) >= Helpers::Constants::ACTIVE_TIMEOUT
                            :sentinel
                          else
                            :full_active
@@ -104,22 +104,28 @@ module Legion
 
           private
 
-          def execute_tick_impl(signals:, phase_handlers:)
+          def execute_tick_impl(signals:, phase_handlers:, **context)
             state = tick_state
             state.increment_tick
 
             max_salience = signals.map { |s| s.is_a?(Hash) ? (s[:salience] || 0.0) : 0.0 }.max || 0.0
-            state.record_signal(salience: max_salience) unless signals.empty?
+            has_human = signals.any? { |s| s.is_a?(Hash) && s[:source_type] == :human_direct }
+            state.record_signal(salience: max_salience, source_type: (has_human ? :human_direct : nil)) unless signals.empty?
 
             log.debug "[tick] ##{state.tick_count} starting | mode=#{state.mode} signals=#{signals.size} max_salience=#{max_salience.round(2)}"
 
-            transition = evaluate_mode_transition(signals: signals)
-            log.info "[tick] mode transition: #{transition[:previous_mode]} -> #{transition[:new_mode]} (#{transition[:reason]})" if transition[:transitioned]
+            evaluate_mode_transition(signals: signals)
 
             phases = Helpers::Constants.phases_for_mode(state.mode)
             budget = Helpers::Constants.tick_budget(state.mode)
             start_time = Time.now.utc
-            ctx = { budget: budget, start_time: start_time, phase_handlers: phase_handlers, signals: signals }
+            ctx = {
+              budget:         budget,
+              start_time:     start_time,
+              phase_handlers: phase_handlers,
+              signals:        signals,
+              context:        context
+            }
             results = run_phases(phases, state, ctx)
 
             total_elapsed = Time.now.utc - start_time
@@ -148,16 +154,16 @@ module Legion
                 break
               end
 
-              result = run_single_phase(phase, ctx[:phase_handlers][phase], state, ctx[:signals], results)
+              result = run_single_phase(phase, ctx[:phase_handlers][phase], state, ctx[:signals], results, **ctx[:context])
               state.record_phase(phase, result)
               results[phase] = result
             end
             results
           end
 
-          def run_single_phase(phase, handler, state, signals, results)
+          def run_single_phase(phase, handler, state, signals, results, **context)
             phase_start = Time.now.utc
-            result = handler ? handler.call(state: state, signals: signals, prior_results: results) : { status: :no_handler }
+            result = handler ? handler.call(state: state, signals: signals, prior_results: results, **context) : { status: :no_handler }
             phase_elapsed = ((Time.now.utc - phase_start) * 1000).round(1)
             status = result.is_a?(Hash) ? (result[:status] || :ok) : :ok
             log.debug "[tick] ##{state.tick_count} phase=#{phase} status=#{status} (#{phase_elapsed}ms)"
@@ -171,6 +177,16 @@ module Legion
                       "elapsed=#{(total_elapsed * 1000).round(1)}ms#{skipped_suffix}"
           end
 
+          def full_active_cooldown_elapsed(state)
+            if state.last_high_salience_at
+              state.seconds_since_high_salience
+            elsif state.last_signal_at
+              state.seconds_since_signal
+            else
+              Helpers::Constants::ACTIVE_TIMEOUT
+            end
+          end
+
           def tick_state
             @tick_state ||= Helpers::State.new
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Tick
-      VERSION = '0.1.12'
+      VERSION = '0.1.13'
     end
   end
 end

data/spec/legion/extensions/tick/actors/tick_spec.rb

@@ -58,15 +58,45 @@ RSpec.describe Legion::Extensions::Tick::Actor::Tick do
   end
 
   describe '#runner_class' do
-    it 'returns the Orchestrator module' do
+    it 'returns the Orchestrator module by default' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Tick::Runners::Orchestrator)
+    end
+
+    it 'returns Legion::Gaia when Gaia is running in agent mode' do
+      stub_const('Legion::Gaia', Module.new do
+        def self.started? = true
+
+        def self.router_mode? = false
+      end)
+
+      expect(actor.runner_class).to eq(Legion::Gaia)
+    end
+
+    it 'falls back to the Orchestrator module when Gaia is running in router mode' do
+      stub_const('Legion::Gaia', Module.new do
+        def self.started? = true
+
+        def self.router_mode? = true
+      end)
+
       expect(actor.runner_class).to eq(Legion::Extensions::Tick::Runners::Orchestrator)
     end
   end
 
   describe '#runner_function' do
-    it 'returns execute_tick' do
+    it 'returns execute_tick by default' do
       expect(actor.runner_function).to eq('execute_tick')
     end
+
+    it 'returns heartbeat when Gaia is running in agent mode' do
+      stub_const('Legion::Gaia', Module.new do
+        def self.started? = true
+
+        def self.router_mode? = false
+      end)
+
+      expect(actor.runner_function).to eq('heartbeat')
+    end
   end
 
   describe '#time' do
@@ -100,9 +130,19 @@ RSpec.describe Legion::Extensions::Tick::Actor::Tick do
   end
 
   describe '#args' do
-    it 'returns a hash with empty signals and phase_handlers' do
+    it 'returns a hash with empty signals and phase_handlers by default' do
       expect(actor.args).to eq({ signals: [], phase_handlers: {} })
     end
+
+    it 'returns empty args when Gaia is running in agent mode' do
+      stub_const('Legion::Gaia', Module.new do
+        def self.started? = true
+
+        def self.router_mode? = false
+      end)
+
+      expect(actor.args).to eq({})
+    end
   end
 
   describe 'initial jitter behavior' do

data/spec/legion/extensions/tick/helpers/state_spec.rb

@@ -28,6 +28,11 @@ RSpec.describe Legion::Extensions::Tick::Helpers::State do
       state.record_signal(salience: 0.3)
       expect(state.last_high_salience_at).to be_nil
     end
+
+    it 'updates last_high_salience_at for human direct signals' do
+      state.record_signal(salience: 0.3, source_type: :human_direct)
+      expect(state.last_high_salience_at).not_to be_nil
+    end
   end
 
   describe '#increment_tick' do
@@ -43,6 +48,18 @@ RSpec.describe Legion::Extensions::Tick::Helpers::State do
     end
   end
 
+  describe '#seconds_since_signal' do
+    it 'treats a fresh boot as recently active' do
+      expect(state.seconds_since_signal).to eq(0.0)
+    end
+  end
+
+  describe '#seconds_since_high_salience' do
+    it 'treats missing high-salience history as recent, not infinite' do
+      expect(state.seconds_since_high_salience).to eq(0.0)
+    end
+  end
+
   describe '#transition_to' do
     it 'changes mode' do
       state.transition_to(:sentinel)

data/spec/legion/extensions/tick/runners/orchestrator_spec.rb

@@ -40,6 +40,23 @@ RSpec.describe Legion::Extensions::Tick::Runners::Orchestrator do
       expect(handler_called).to be true
     end
 
+    it 'passes extra execution context through to phase handlers' do
+      seen = nil
+      handlers = {
+        memory_consolidation: lambda { |partner_observations: nil, **|
+          seen = partner_observations
+          { status: :ok }
+        }
+      }
+
+      client.execute_tick(
+        phase_handlers:       handlers,
+        partner_observations: [{ identity: 'partner-1' }]
+      )
+
+      expect(seen).to eq([{ identity: 'partner-1' }])
+    end
+
     it 'reports no_handler for unhandled phases' do
       result = client.execute_tick
       expect(result[:results][:memory_consolidation][:status]).to eq(:no_handler)
@@ -86,6 +103,12 @@ RSpec.describe Legion::Extensions::Tick::Runners::Orchestrator do
       expect(result[:transitioned]).to be false
     end
 
+    it 'does not enter dormant_active immediately on fresh boot' do
+      result = client.evaluate_mode_transition
+      expect(result[:transitioned]).to be false
+      expect(result[:current_mode]).to eq(:dormant)
+    end
+
     context 'dormant_active transitions' do
       it 'transitions dormant -> dormant_active after DREAM_IDLE_THRESHOLD with no signals' do
         state = client.send(:tick_state)
@@ -135,6 +158,21 @@ RSpec.describe Legion::Extensions::Tick::Runners::Orchestrator do
         expect(result[:new_mode]).to eq(:dormant_active)
       end
     end
+
+    context 'full_active cooldown' do
+      it 'demotes full_active after ACTIVE_TIMEOUT when only human-direct signal history exists' do
+        client.set_mode(mode: :full_active)
+        state = client.send(:tick_state)
+        allow(state).to receive(:last_high_salience_at).and_return(nil)
+        allow(state).to receive(:last_signal_at).and_return(Time.now.utc - 301)
+        allow(state).to receive(:seconds_since_signal).and_return(301.0)
+
+        result = client.evaluate_mode_transition
+
+        expect(result[:transitioned]).to be true
+        expect(result[:new_mode]).to eq(:sentinel)
+      end
+    end
   end
 
   describe '#set_mode' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-tick
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Esity