lex-agentic-executive 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaa8f955fd551b961fd735e5bbf9a0dc33b54134b4d5e2ab1506221687aa3195
-  data.tar.gz: 862042eb5a340dcacce8ec8f2c7cb5f2b9501640ca3d0f39e3307ab69c87d571
+  metadata.gz: 0ac4e5f2b4c752913d15a4d25240de021a5e7821b2b50be4dd474b1a51ab482f
+  data.tar.gz: 9c407b92da789b2f6a11c340b921d772f32fdc5617b968ed5a3dad01c680ce53
 SHA512:
-  metadata.gz: 51cbce9e25c1edb78855eeb7304663855d5f3b4cfc0072b074476f16c230786ea9bd7dfff15c43f10a55558463642218835d3ed3e9f1fcc7a444fbcce1893a74
-  data.tar.gz: 69f0e5e91e4f98c9b2a46d518301674bedf0bedf7ee04adb4a8b5117c450afedf0ebbe8dc2eef73143a6773e96df5bf2a13e6cdf0ab9c4a590b97c4af821559a
+  metadata.gz: 558348baa035852ac306d07d992a3fb8c65263e87bad2d359dfa3c6ab611a25c5c6477ab02cd5d6776f81cd5b5e648f6bcd5583a4984705ca52f587e41304f4d
+  data.tar.gz: 9c0eb7766904360b3c679c3357fb94006f24841f3eb392e9dcf7690e6282a4d65f67150b4cc204f0c67d7bafd67f1299ce5dcb2eccaed0e5ed50697d8b634fa8

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.2] - 2026-05-08
+### Fixed
+- `Decomposer#parse_sub_goals` now accesses JSON sub-goal hashes using string keys (with symbol fallback), preventing LLM-decomposed goals from getting empty content/default domain/0.5 priority.
+- `ExecutiveController#common_ef_level` formula corrected — blends minimum effective capacity (weighted 0.6) with average (weighted 0.4) instead of computing a no-op `avg * 0.6 + avg * 0.4`.
+- `FeedbackListener` tracks event handler references, enabling `stop_listening` and `restart_listening` to prevent duplicate handler accumulation on repeated start calls.
+
+## [0.2.1] - 2026-05-07
+
+### Fixed
+- Goal decomposer LLM strategy now parses native `Legion::LLM.chat` hash responses without requiring a legacy chat session.
+- Added regression coverage for cognition-domain dispatch to the MindGrowth analyzer.
+
 ## [0.2.0] - 2026-04-21
 ### Added
 - **Autonomous Goal-Setting Pipeline (G1-G5)** — GAIA can now convert intentions into goals, decompose them, dispatch execution, and receive feedback with no human intervention

data/lib/legion/extensions/agentic/executive/executive_function/helpers/executive_controller.rb

@@ -72,8 +72,9 @@ module Legion
 
               def common_ef_level
                 values = @components.values.map(&:effective_capacity)
+                min    = values.min
                 avg    = values.sum / values.size.to_f
-                (avg * (1.0 - COMMON_EF_WEIGHT)) + (avg * COMMON_EF_WEIGHT)
+                (avg * (1.0 - COMMON_EF_WEIGHT)) + (min * COMMON_EF_WEIGHT)
               end
 
               def can_inhibit?

data/lib/legion/extensions/agentic/executive/goal_management/helpers/decomposer.rb

@@ -48,9 +48,10 @@ module Legion
 
                 prompt   = build_decomposition_prompt(goal)
                 response = Legion::LLM.chat(
-                  caller: { extension: 'lex-agentic-executive', operation: 'decompose' }
-                ).ask(prompt)
-                parse_sub_goals(response.content, goal[:domain])
+                  message: prompt,
+                  caller:  { extension: 'lex-agentic-executive', operation: 'decompose' }
+                )
+                parse_sub_goals(extract_response_content(response, prompt), goal[:domain])
               rescue StandardError => e
                 log.error "Decomposer#decompose_with_llm: #{e.message}"
                 nil
@@ -83,21 +84,39 @@ module Legion
               end
 
               def parse_sub_goals(content, domain)
+                return nil unless content
+
                 cleaned = content.gsub(/```(?:json)?\s*\n?/, '').strip
                 data = json_load(cleaned)
                 return nil unless data.is_a?(Array) && !data.empty?
 
                 data.map do |sg|
                   {
-                    content:  sg[:content].to_s,
-                    domain:   (sg[:domain] || domain).to_sym,
-                    priority: (sg[:priority] || 0.5).to_f.clamp(0.0, 1.0)
+                    content:  sg.fetch('content', sg.fetch(:content, '')).to_s,
+                    domain:   sg.fetch('domain', sg.fetch(:domain, domain)).to_sym,
+                    priority: sg.fetch('priority', sg.fetch(:priority, 0.5)).to_f.clamp(0.0, 1.0)
                   }
                 end
               rescue StandardError => e
                 log.error "Decomposer#parse_sub_goals: #{e.message}"
                 nil
               end
+
+              def extract_response_content(response, prompt)
+                return response.strip if response.is_a?(String)
+                return response.content if response.respond_to?(:content)
+
+                if response.respond_to?(:ask)
+                  asked = response.ask(prompt)
+                  return extract_response_content(asked, prompt)
+                end
+
+                return nil unless response.is_a?(Hash)
+
+                response[:content] || response['content'] ||
+                  response.dig(:message, :content) || response.dig('message', 'content') ||
+                  response[:response] || response['response']
+              end
             end
           end
         end

data/lib/legion/extensions/agentic/executive/goal_management/helpers/feedback_listener.rb

@@ -10,6 +10,7 @@ module Legion
               def initialize(engine:)
                 @engine    = engine
                 @listening = false
+                @handlers  = []
               end
 
               def handle_task_event(task_id:, status:, result: nil)
@@ -26,7 +27,7 @@ module Legion
                 return if @listening
                 return unless defined?(Legion::Events)
 
-                Legion::Events.on('task.completed') do |event|
+                handler_completed = Legion::Events.on('task.completed') do |event|
                   handle_task_event(
                     task_id: event[:task_id],
                     status:  event[:status] || 'task.completed',
@@ -34,7 +35,7 @@ module Legion
                   )
                 end
 
-                Legion::Events.on('task.failed') do |event|
+                handler_failed = Legion::Events.on('task.failed') do |event|
                   handle_task_event(
                     task_id: event[:task_id],
                     status:  event[:status] || 'task.failed',
@@ -42,9 +43,28 @@ module Legion
                   )
                 end
 
+                @handlers << { event: 'task.completed', block: handler_completed }
+                @handlers << { event: 'task.failed', block: handler_failed }
                 @listening = true
               end
 
+              def stop_listening
+                return unless @listening
+
+                @handlers.each do |entry|
+                  Legion::Events.off(entry[:event], entry[:block])
+                rescue StandardError => e
+                  log.debug "[feedback_listener] stop_listening cleanup failed: #{e.message}"
+                end
+                @handlers.clear
+                @listening = false
+              end
+
+              def restart_listening
+                stop_listening
+                start_listening
+              end
+
               def listening?
                 @listening
               end

data/lib/legion/extensions/agentic/executive/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Executive
-        VERSION = '0.2.0'
+        VERSION = '0.2.2'
       end
     end
   end

data/spec/legion/extensions/agentic/executive/goal_management/helpers/decomposer_spec.rb

@@ -33,6 +33,21 @@ RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::
         expect(result[:success]).to be true
         expect(result[:strategy_used]).to eq(:heuristic)
       end
+
+      it 'parses native hash responses from Legion::LLM.chat' do
+        llm = Module.new
+        llm.define_singleton_method(:chat) do |message:, **|
+          raise 'missing prompt' if message.to_s.empty?
+
+          { content: '[{"content":"inspect controls","domain":"safety","priority":0.8}]' }
+        end
+        stub_const('Legion::LLM', llm)
+
+        result = described_class.decompose(goal: goal_hash, strategy: :llm)
+
+        expect(result[:strategy_used]).to eq(:llm)
+        expect(result[:sub_goals].first[:content]).to eq('inspect controls')
+      end
     end
 
     context 'with default strategy' do

data/spec/legion/extensions/agentic/executive/goal_management/helpers/feedback_listener_spec.rb

@@ -101,4 +101,71 @@ RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::
       expect(listener.listening?).to be false
     end
   end
+
+  describe '#stop_listening' do
+    it 'removes registered handlers and resets listening state' do
+      events_spy = Class.new do
+        attr_reader :registered, :removed
+
+        def initialize
+          @registered = []
+          @removed = []
+        end
+
+        def on(event, &block)
+          @registered << { event: event, block: block }
+          block
+        end
+
+        def off(event, block)
+          @removed << { event: event, block: block }
+        end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      listener.start_listening
+      expect(listener.listening?).to be true
+
+      listener.stop_listening
+      expect(listener.listening?).to be false
+      expect(events_spy.removed.size).to eq(2)
+      removed_events = events_spy.removed.map { |r| r[:event] }
+      expect(removed_events).to include('task.completed')
+      expect(removed_events).to include('task.failed')
+    end
+
+    it 'does nothing when not listening' do
+      expect { listener.stop_listening }.not_to raise_error
+      expect(listener.listening?).to be false
+    end
+  end
+
+  describe '#restart_listening' do
+    it 'stops and starts listening' do
+      events_spy = Class.new do
+        attr_reader :registered, :removed
+
+        def initialize
+          @registered = []
+          @removed = []
+        end
+
+        def on(event, &block)
+          @registered << { event: event, block: block }
+          block
+        end
+
+        def off(event, block)
+          @removed << { event: event, block: block }
+        end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      listener.start_listening
+
+      listener.restart_listening
+      expect(listener.listening?).to be true
+      # Original handlers removed, new ones registered
+      expect(events_spy.removed.size).to eq(2)
+      expect(events_spy.registered.size).to eq(4) # 2 original + 2 new
+    end
+  end
 end

data/spec/legion/extensions/agentic/executive/goal_management/helpers/task_dispatcher_spec.rb

@@ -80,6 +80,14 @@ RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::
         expect(result[:runner_mapping]).to eq('Legion::Extensions::MindGrowth::Runners::Monitor')
       end
 
+      it 'dispatches cognition goals to the current MindGrowth analyzer runner' do
+        stub_const('Legion::Extensions::MindGrowth::Runners::Analyzer', Module.new)
+        result = dispatcher.dispatch_goal(goal: goal_hash.merge(domain: :cognition))
+
+        expect(result[:dispatched]).to be true
+        expect(result[:runner_mapping]).to eq('Legion::Extensions::MindGrowth::Runners::Analyzer')
+      end
+
       it 'includes goal_id in the response' do
         result = dispatcher.dispatch_goal(goal: goal_hash)
         expect(result[:goal_id]).to eq('goal-123')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-executive
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Esity