lex-agentic-executive 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a52da834db3ad024167228f957b019bfc33bb0a1cc86cc1cb58feabe4aa1bec4
-  data.tar.gz: 16f3a79dee77a608932cb3b837ee55aac9bc4cfbd596beb42f29582b530c1b54
+  metadata.gz: 96780b1afcbb05fed19728d4ff7ce759d554c3f546341ae529fc858207c9d7d8
+  data.tar.gz: 240e134b5429af9de0ca9783f8632418b6968742b4921f9100acf857762d9909
 SHA512:
-  metadata.gz: e44439bae29cbf8793b0f69ece036bb097051f0434b4d33f4e373f661c5203b51beabb58d9b9f78f17ab9b0fc0041c0565dfbd7d6b11804707e39aa0ef78784a
-  data.tar.gz: 596a167041a980a4151babe00df9b876a0ebe647929fcea48e0cebe8b9b6704621a5499fcebde0494a8a9c3fff3000b22b2e29ce2da658f481a3ad1350400cd3
+  metadata.gz: 32967c12a79d49227bc65e8ad400ab36aafde6f52b306792df60d5c1655c895bb42c3cb135e9903cd6a4d993538f9ba5bc916763c097e17dd7407730ccec371a
+  data.tar.gz: 5c3c763991e6145292134255689f0defb9ee4b565be8098bd1a1d223b5f726d55c3774be7696b6591d8ca1bdf839ca420e7def0db7d22bccdd2717f883a425a7

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
+## [0.2.3] - 2026-10-29
+### Fixed
+- Reject unattributed goal feedback and preserve terminal goals and ancestor state when delayed task outcomes arrive.
+- Reclaim completed intention history at capacity without discarding active or suspended commitments.
+
+## [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.

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for executive function, goal management, planning, and
 ## Overview
 
 **Gem**: `lex-agentic-executive`
-**Version**: 0.1.12
+**Version**: 0.2.3
 **Namespace**: `Legion::Extensions::Agentic::Executive`
 
 ## Sub-Modules

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

@@ -92,9 +92,9 @@ module Legion
 
                 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

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

@@ -213,9 +213,15 @@ module Legion
               end
 
               def update_from_task_event(task_id:, status:, result: nil)
+                return { found: false } if task_id.nil?
+
                 @mutex.synchronize do
                   goal = @goals.values.find { |g| g.task_id == task_id }
                   return { found: false } unless goal
+                  if %i[completed abandoned].include?(goal.status)
+                    return { found: true, goal_id: goal.id, new_status: goal.status, progress: goal.progress,
+                             ignored: :terminal_goal }
+                  end
 
                   case status
                   when 'task.completed'
@@ -228,8 +234,8 @@ module Legion
                   when 'task.exception', 'task.failed'
                     goal.block!
                     persist_goal(goal)
-                    log.info "[goal_engine] goal status change goal=#{goal.id} transition=blocked"
-                    { found: true, goal_id: goal.id, new_status: :blocked, error: result }
+                    log.info "[goal_engine] goal status change goal=#{goal.id} transition=#{goal.status}"
+                    { found: true, goal_id: goal.id, new_status: goal.status, error: result }
                   else
                     { found: true, goal_id: goal.id, unhandled_status: status }
                   end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Executive
-        VERSION = '0.2.1'
+        VERSION = '0.2.3'
       end
     end
   end

data/lib/legion/extensions/agentic/executive/volition/helpers/intention_stack.rb

@@ -15,6 +15,12 @@ module Legion
 
               def push(intention)
                 return :duplicate if duplicate?(intention)
+
+                if @intentions.size >= Constants::MAX_INTENTIONS
+                  completed_index = @intentions.index { |entry| entry[:state] == :completed }
+                  @intentions.delete_at(completed_index) if completed_index
+                end
+
                 return :capacity_full if @intentions.size >= Constants::MAX_INTENTIONS
 
                 @intentions << intention

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

@@ -40,6 +40,41 @@ RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::
       result = listener.handle_task_event(task_id: 'task-123', status: 'task.failed', result: 'timeout')
       expect(result[:error]).to eq('timeout')
     end
+
+    it 'does not attribute an event without a task ID to an undispatched goal' do
+      undispatched = engine.add_goal(content: 'awaiting authorized dispatch')[:goal][:id]
+      engine.activate_goal(goal_id: undispatched)
+
+      result = listener.handle_task_event(task_id: nil, status: 'task.completed')
+
+      expect(result).to eq(found: false)
+      expect(engine.goal_tree(goal_id: undispatched)[:tree]).to include(status: :active, progress: 0.0)
+      expect(engine.goal_tree(goal_id: @goal_id)[:tree]).to include(status: :active, progress: 0.0)
+    end
+
+    it 'preserves completion when a delayed failure arrives for the same task' do
+      listener.handle_task_event(task_id: 'task-123', status: 'task.completed')
+
+      result = listener.handle_task_event(task_id: 'task-123', status: 'task.failed', result: 'late failure')
+
+      expect(result).to include(new_status: :completed, ignored: :terminal_goal)
+      expect(engine.goal_tree(goal_id: @goal_id)[:tree]).to include(status: :completed, progress: 1.0)
+    end
+
+    it 'does not credit an abandoned child or its parent for a late completion' do
+      parent = engine.add_goal(content: 'parent goal')[:goal][:id]
+      engine.activate_goal(goal_id: parent)
+      child = engine.add_goal(content: 'cancelled work', parent_id: parent)[:goal][:id]
+      engine.activate_goal(goal_id: child)
+      engine.assign_task_to_goal(goal_id: child, task_id: 'cancelled-task', runner_mapping: 'TestRunner')
+      engine.abandon_goal(goal_id: child)
+      before = engine.goal_tree(goal_id: parent)[:tree]
+
+      result = listener.handle_task_event(task_id: 'cancelled-task', status: 'task.completed')
+
+      expect(result).to include(new_status: :abandoned, ignored: :terminal_goal)
+      expect(engine.goal_tree(goal_id: parent)[:tree]).to eq(before)
+    end
   end
 
   describe '#start_listening' do
@@ -101,4 +136,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/volition/helpers/intention_stack_spec.rb

@@ -27,6 +27,22 @@ RSpec.describe Legion::Extensions::Agentic::Executive::Volition::Helpers::Intent
       expect(stack.push(make_intention(goal: 'overflow'))).to eq(:capacity_full)
     end
 
+    it 'reclaims completed history at capacity without losing pending commitments' do
+      limit = Legion::Extensions::Agentic::Executive::Volition::Helpers::Constants::MAX_INTENTIONS
+      intentions = Array.new(limit) { |i| make_intention(goal: "goal #{i}") }
+      intentions.each { |intention| stack.push(intention) }
+      stack.complete(intentions.first[:intention_id])
+      stack.suspend(intentions.last[:intention_id])
+      replacement = make_intention(goal: 'next commitment')
+
+      expect(stack.push(replacement)).to eq(:pushed)
+      expect(stack.size).to eq(limit)
+      expect(stack.active.map { |intention| intention[:goal] })
+        .to contain_exactly(*intentions[1...-1].map { |intention| intention[:goal] }, 'next commitment')
+      expect(stack.resume(intentions.last[:intention_id])).to eq(:resumed)
+      expect(stack.push(make_intention(goal: 'overflow'))).to eq(:capacity_full)
+    end
+
     it 'sorts by salience descending' do
       stack.push(make_intention(goal: 'low', salience: 0.3))
       stack.push(make_intention(goal: 'high', salience: 0.9))

metadata

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