lex-agentic-executive 0.1.11 → 0.2.0

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module GoalManagement
+          module Helpers
+            class GoalPersistence
+              include Legion::Cache::Helper if defined?(Legion::Cache::Helper)
+              include Legion::JSON::Helper if defined?(Legion::JSON::Helper)
+
+              GOAL_TTL = 86_400
+              INDEX_KEY_SUFFIX = ':index'
+              BRIDGE_KEY_SUFFIX = ':bridge'
+
+              def initialize(namespace: 'legion_goals')
+                @namespace = namespace
+              end
+
+              def save_goal(goal_hash)
+                return false unless persistence_available?
+
+                cache_set(goal_key(goal_hash[:id]), json_dump(goal_hash), ttl: GOAL_TTL)
+                update_index(goal_hash[:id], :add)
+                true
+              rescue StandardError => e
+                log.error "[goal_persistence] save_goal failed: #{e.message}"
+                false
+              end
+
+              def load_goal(id)
+                return nil unless persistence_available?
+
+                raw = cache_get(goal_key(id))
+                return nil unless raw
+
+                json_load(raw)
+              rescue StandardError => e
+                log.error "[goal_persistence] load_goal failed: #{e.message}"
+                nil
+              end
+
+              def delete_goal(id)
+                return false unless persistence_available?
+
+                cache_delete(goal_key(id))
+                update_index(id, :remove)
+                true
+              rescue StandardError => e
+                log.error "[goal_persistence] delete_goal failed: #{e.message}"
+                false
+              end
+
+              def save_all(goals_hash)
+                return false unless persistence_available?
+
+                goals_hash.each_value { |g| save_goal(g.is_a?(Hash) ? g : g.to_h) }
+                true
+              rescue StandardError => e
+                log.error "[goal_persistence] save_all failed: #{e.message}"
+                false
+              end
+
+              def load_all
+                return {} unless persistence_available?
+
+                ids = load_index
+                return {} if ids.empty?
+
+                goals = ids.each_with_object({}) do |id, result|
+                  goal = load_goal(id)
+                  result[id] = goal if goal
+                end
+                log.info "[goal_persistence] rehydrated #{goals.size} goals from cache"
+                goals
+              rescue StandardError => e
+                log.error "[goal_persistence] load_all failed: #{e.message}"
+                {}
+              end
+
+              def save_bridge_state(bridge_hash)
+                return false unless persistence_available?
+
+                cache_set(bridge_key, json_dump(bridge_hash), ttl: GOAL_TTL)
+                true
+              rescue StandardError => e
+                log.error "[goal_persistence] save_bridge_state failed: #{e.message}"
+                false
+              end
+
+              def load_bridge_state
+                return {} unless persistence_available?
+
+                raw = cache_get(bridge_key)
+                return {} unless raw
+
+                json_load(raw)
+              rescue StandardError => e
+                log.error "[goal_persistence] load_bridge_state failed: #{e.message}"
+                {}
+              end
+
+              private
+
+              def log
+                Legion::Logging
+              end
+
+              def persistence_available?
+                respond_to?(:cache_connected?) && cache_connected?
+              rescue StandardError => e
+                log.debug "[goal_persistence] cache not available: #{e.message}"
+                false
+              end
+
+              def goal_key(id) = "#{@namespace}:goal:#{id}"
+              def index_key = "#{@namespace}#{INDEX_KEY_SUFFIX}"
+              def bridge_key = "#{@namespace}#{BRIDGE_KEY_SUFFIX}"
+
+              def update_index(id, operation)
+                ids = load_index
+                case operation
+                when :add    then ids << id unless ids.include?(id)
+                when :remove then ids.delete(id)
+                end
+                cache_set(index_key, json_dump(ids), ttl: GOAL_TTL)
+              end
+
+              def load_index
+                raw = cache_get(index_key)
+                return [] unless raw
+
+                json_load(raw)
+              rescue StandardError => e
+                log.error "[goal_persistence] load_index failed: #{e.message}"
+                []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module GoalManagement
+          module Helpers
+            class TaskDispatcher
+              DOMAIN_RUNNERS = {
+                safety:        { runner_class: 'Legion::Extensions::MindGrowth::Runners::Monitor',
+                                 function:     :health_check,
+                                 args_builder: ->(goal) { { extension: goal[:domain].to_s } } },
+                cognition:     { runner_class: 'Legion::Extensions::MindGrowth::Runners::Analyzer',
+                                 function:     :recommend_priorities,
+                                 args_builder: ->(_goal) { { existing_extensions: [] } } },
+                perception:    { client_class: 'Legion::Extensions::Agentic::Learning::Curiosity::Client',
+                                 function:     :detect_gaps,
+                                 args_builder: ->(_goal) { { prior_results: {} } } },
+                introspection: { client_class: 'Legion::Extensions::Agentic::Executive::Volition::Client',
+                                 function:     :volition_status,
+                                 args_builder: ->(_goal) { {} } }
+              }.freeze
+
+              def dispatch_goal(goal:)
+                domain  = goal[:domain]&.to_sym
+                mapping = DOMAIN_RUNNERS[domain]
+
+                return unroutable(goal, domain) unless mapping
+                return unroutable_not_loaded(goal, domain) unless runner_class_loaded?(mapping)
+
+                execute_dispatch(goal: goal, mapping: mapping)
+              rescue StandardError => e
+                log.error "[task_dispatcher] dispatch error goal=#{goal[:id]} #{e.message}"
+                { dispatched: false, error: e.message, goal_id: goal[:id] }
+              end
+
+              private
+
+              def runner_class_loaded?(mapping)
+                class_name = mapping[:runner_class] || mapping[:client_class]
+                Kernel.const_get(class_name)
+                true
+              rescue NameError => e
+                log.debug "[task_dispatcher] runner not loaded: #{e.message}"
+                false
+              end
+
+              def execute_dispatch(goal:, mapping:)
+                function = mapping[:function]
+                args     = mapping[:args_builder].call(goal)
+
+                result = if mapping.key?(:client_class)
+                           dispatch_via_client(mapping[:client_class], function, args)
+                         else
+                           dispatch_via_runner(mapping[:runner_class], function, args)
+                         end
+
+                success    = result[:status] == 'task.completed'
+                task_id    = result[:task_id]
+                runner_key = mapping[:runner_class] || mapping[:client_class]
+
+                log.info "[task_dispatcher] dispatched goal=#{goal[:id]} runner=#{runner_key} function=#{function}"
+
+                {
+                  dispatched:     true,
+                  success:        success,
+                  task_id:        task_id,
+                  runner_mapping: runner_key,
+                  result:         result,
+                  goal_id:        goal[:id]
+                }
+              end
+
+              def dispatch_via_runner(runner_class, function, args)
+                Legion::Runner.run(
+                  runner_class:  runner_class,
+                  function:      function,
+                  args:          args,
+                  generate_task: true,
+                  check_subtask: true
+                )
+              end
+
+              def dispatch_via_client(client_class, function, args)
+                client = Kernel.const_get(client_class).new
+                client.send(function, **args)
+              end
+
+              def log
+                Legion::Logging
+              end
+
+              def unroutable(goal, domain)
+                log.debug "[task_dispatcher] no runner for domain=#{domain} goal=#{goal[:id]}"
+                { dispatched: false, reason: :no_runner, domain: domain, goal_id: goal[:id] }
+              end
+
+              def unroutable_not_loaded(goal, domain)
+                log.debug "[task_dispatcher] runner not loaded for domain=#{domain} goal=#{goal[:id]}"
+                { dispatched: false, reason: :runner_not_loaded, domain: domain, goal_id: goal[:id] }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb

@@ -7,151 +7,203 @@ module Legion
         module GoalManagement
           module Runners
             module GoalManagement
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def add_goal(content:, parent_id: nil, domain: :general,
                            priority: Helpers::Constants::DEFAULT_PRIORITY, deadline: nil, **)
-                Legion::Logging.debug "[goal_management] runner add_goal domain=#{domain}"
+                log.debug "[goal_management] runner add_goal domain=#{domain}"
                 engine.add_goal(content: content, parent_id: parent_id, domain: domain,
                                 priority: priority, deadline: deadline)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] add_goal error: #{e.message}"
+                log.error "[goal_management] add_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def decompose_goal(goal_id:, sub_goals:, **)
-                Legion::Logging.debug "[goal_management] runner decompose_goal parent=#{goal_id}"
+                log.debug "[goal_management] runner decompose_goal parent=#{goal_id}"
                 engine.decompose(goal_id: goal_id, sub_goals: sub_goals)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] decompose_goal error: #{e.message}"
+                log.error "[goal_management] decompose_goal error: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def auto_decompose_goal(goal_id:, strategy: :heuristic, **)
+                goal_data = engine.goals[goal_id]
+                return { success: false, error: :not_found } unless goal_data
+
+                decomp = Helpers::Decomposer.decompose(goal: goal_data.to_h, strategy: strategy)
+                return decomp unless decomp[:success]
+
+                result = engine.decompose(goal_id: goal_id, sub_goals: decomp[:sub_goals])
+                result.merge(strategy_used: decomp[:strategy_used])
+              rescue StandardError => e
+                log.error "[goal_management] auto_decompose_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def activate_goal(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner activate_goal id=#{goal_id}"
+                log.debug "[goal_management] runner activate_goal id=#{goal_id}"
                 engine.activate_goal(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] activate_goal error: #{e.message}"
+                log.error "[goal_management] activate_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def complete_goal(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner complete_goal id=#{goal_id}"
+                log.debug "[goal_management] runner complete_goal id=#{goal_id}"
                 engine.complete_goal(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] complete_goal error: #{e.message}"
+                log.error "[goal_management] complete_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def abandon_goal(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner abandon_goal id=#{goal_id}"
+                log.debug "[goal_management] runner abandon_goal id=#{goal_id}"
                 engine.abandon_goal(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] abandon_goal error: #{e.message}"
+                log.error "[goal_management] abandon_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def block_goal(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner block_goal id=#{goal_id}"
+                log.debug "[goal_management] runner block_goal id=#{goal_id}"
                 engine.block_goal(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] block_goal error: #{e.message}"
+                log.error "[goal_management] block_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def unblock_goal(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner unblock_goal id=#{goal_id}"
+                log.debug "[goal_management] runner unblock_goal id=#{goal_id}"
                 engine.unblock_goal(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] unblock_goal error: #{e.message}"
+                log.error "[goal_management] unblock_goal error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def advance_goal_progress(goal_id:, amount:, **)
-                Legion::Logging.debug "[goal_management] runner advance_goal_progress id=#{goal_id} amount=#{amount}"
+                log.debug "[goal_management] runner advance_goal_progress id=#{goal_id} amount=#{amount}"
                 engine.advance_progress(goal_id: goal_id, amount: amount)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] advance_goal_progress error: #{e.message}"
+                log.error "[goal_management] advance_goal_progress error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def detect_goal_conflicts(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner detect_goal_conflicts id=#{goal_id}"
+                log.debug "[goal_management] runner detect_goal_conflicts id=#{goal_id}"
                 engine.detect_conflicts(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] detect_goal_conflicts error: #{e.message}"
+                log.error "[goal_management] detect_goal_conflicts error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def list_active_goals(**)
                 goals = engine.active_goals
-                Legion::Logging.debug "[goal_management] list_active_goals count=#{goals.size}"
+                log.debug "[goal_management] list_active_goals count=#{goals.size}"
                 { success: true, goals: goals.map(&:to_h), count: goals.size }
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] list_active_goals error: #{e.message}"
+                log.error "[goal_management] list_active_goals error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def list_blocked_goals(**)
                 goals = engine.blocked_goals
-                Legion::Logging.debug "[goal_management] list_blocked_goals count=#{goals.size}"
+                log.debug "[goal_management] list_blocked_goals count=#{goals.size}"
                 { success: true, goals: goals.map(&:to_h), count: goals.size }
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] list_blocked_goals error: #{e.message}"
+                log.error "[goal_management] list_blocked_goals error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def list_overdue_goals(**)
                 goals = engine.overdue_goals
-                Legion::Logging.debug "[goal_management] list_overdue_goals count=#{goals.size}"
+                log.debug "[goal_management] list_overdue_goals count=#{goals.size}"
                 { success: true, goals: goals.map(&:to_h), count: goals.size }
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] list_overdue_goals error: #{e.message}"
+                log.error "[goal_management] list_overdue_goals error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def list_completed_goals(**)
                 goals = engine.completed_goals
-                Legion::Logging.debug "[goal_management] list_completed_goals count=#{goals.size}"
+                log.debug "[goal_management] list_completed_goals count=#{goals.size}"
                 { success: true, goals: goals.map(&:to_h), count: goals.size }
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] list_completed_goals error: #{e.message}"
+                log.error "[goal_management] list_completed_goals error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def get_goal_tree(goal_id:, **)
-                Legion::Logging.debug "[goal_management] runner get_goal_tree id=#{goal_id}"
+                log.debug "[goal_management] runner get_goal_tree id=#{goal_id}"
                 engine.goal_tree(goal_id: goal_id)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] get_goal_tree error: #{e.message}"
+                log.error "[goal_management] get_goal_tree error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def highest_priority_goals(limit: 5, **)
                 goals = engine.highest_priority(limit: limit)
-                Legion::Logging.debug "[goal_management] highest_priority_goals limit=#{limit} count=#{goals.size}"
+                log.debug "[goal_management] highest_priority_goals limit=#{limit} count=#{goals.size}"
                 { success: true, goals: goals.map(&:to_h), count: goals.size }
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] highest_priority_goals error: #{e.message}"
+                log.error "[goal_management] highest_priority_goals error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def decay_priorities(**)
                 result = engine.decay_all_priorities!
-                Legion::Logging.debug "[goal_management] decay_priorities decayed=#{result[:decayed]}"
+                log.debug "[goal_management] decay_priorities decayed=#{result[:decayed]}"
                 result.merge(success: true)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] decay_priorities error: #{e.message}"
+                log.error "[goal_management] decay_priorities error: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def goal_status(**)
                 report = engine.goal_report
-                Legion::Logging.debug "[goal_management] goal_status total=#{report[:total]}"
+                log.debug "[goal_management] goal_status total=#{report[:total]}"
                 { success: true }.merge(report)
               rescue StandardError => e
-                Legion::Logging.error "[goal_management] goal_status error: #{e.message}"
+                log.error "[goal_management] goal_status error: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def dispatch_leaf_goals(**)
+                dispatcher = Helpers::TaskDispatcher.new
+                engine.goals.each_value do |g|
+                  engine.activate_goal(goal_id: g.id) if g.leaf? && g.status == :proposed
+                end
+                leaves  = engine.active_goals.select(&:leaf?)
+                results = leaves.reject(&:task_id).map do |goal|
+                  dispatch = dispatcher.dispatch_goal(goal: goal.to_h)
+                  if dispatch[:dispatched] && dispatch[:task_id]
+                    engine.assign_task_to_goal(goal_id:        goal.id,
+                                               task_id:        dispatch[:task_id],
+                                               runner_mapping: dispatch[:runner_mapping])
+                  end
+                  { goal_id: goal.id, dispatch: dispatch }
+                end
+                dispatched_count = results.count { |r| r[:dispatch][:dispatched] }
+                log.debug "[goal_management] dispatch_leaf_goals dispatched=#{dispatched_count} total=#{results.size}"
+                { success: true, dispatched: dispatched_count, total: results.size, results: results }
+              rescue StandardError => e
+                log.error "[goal_management] dispatch_leaf_goals error: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def update_goal_from_task(task_id:, status:, result: nil, **)
+                engine.update_from_task_event(task_id: task_id, status: status, result: result)
+              rescue StandardError => e
+                log.error "[goal_management] update_goal_from_task error: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def start_feedback_listener(**)
+                feedback_listener.start_listening
+                { success: true, listening: feedback_listener.listening? }
+              rescue StandardError => e
+                log.error "[goal_management] start_feedback_listener error: #{e.message}"
                 { success: false, error: e.message }
               end
 
@@ -160,6 +212,14 @@ module Legion
               def engine
                 @engine ||= Helpers::GoalEngine.new
               end
+
+              def feedback_listener
+                @feedback_listener ||= Helpers::FeedbackListener.new(engine: engine)
+              end
+
+              def log
+                Legion::Logging
+              end
             end
           end
         end

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

@@ -3,7 +3,10 @@
 require 'legion/extensions/agentic/executive/goal_management/version'
 require 'legion/extensions/agentic/executive/goal_management/helpers/constants'
 require 'legion/extensions/agentic/executive/goal_management/helpers/goal'
+require 'legion/extensions/agentic/executive/goal_management/helpers/goal_persistence'
 require 'legion/extensions/agentic/executive/goal_management/helpers/goal_engine'
+require 'legion/extensions/agentic/executive/goal_management/helpers/task_dispatcher'
+require 'legion/extensions/agentic/executive/goal_management/helpers/decomposer'
 require 'legion/extensions/agentic/executive/goal_management/runners/goal_management'
 require 'legion/extensions/agentic/executive/goal_management/client'
 

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

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

data/lib/legion/extensions/agentic/executive/volition/client.rb

@@ -4,6 +4,7 @@ require 'legion/extensions/agentic/executive/volition/helpers/constants'
 require 'legion/extensions/agentic/executive/volition/helpers/intention'
 require 'legion/extensions/agentic/executive/volition/helpers/intention_stack'
 require 'legion/extensions/agentic/executive/volition/helpers/drive_synthesizer'
+require 'legion/extensions/agentic/executive/volition/helpers/goal_bridge'
 require 'legion/extensions/agentic/executive/volition/runners/volition'
 
 module Legion
@@ -16,8 +17,9 @@ module Legion
 
             attr_reader :intention_stack
 
-            def initialize(stack: nil, **)
+            def initialize(stack: nil, goal_bridge: nil, **)
               @intention_stack = stack || Helpers::IntentionStack.new
+              @goal_bridge = goal_bridge
             end
           end
         end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/goal_management/helpers/goal_persistence'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Volition
+          module Helpers
+            class GoalBridge
+              def initialize(goal_client:, persistence: nil)
+                @goal_client = goal_client
+                @persistence = persistence || default_persistence
+                @bridged_intentions = @persistence&.load_bridge_state || {}
+                @mutex = Mutex.new
+              end
+
+              def bridge_intentions(intentions)
+                result = { bridged: 0, skipped: 0, duplicates: 0, goal_ids: [], errors: [] }
+                return result if intentions.nil? || intentions.empty?
+
+                intentions.each do |intention|
+                  outcome = bridge_one(intention)
+                  case outcome[:status]
+                  when :bridged
+                    result[:bridged] += 1
+                    result[:goal_ids] << outcome[:goal_id]
+                  when :skipped   then result[:skipped] += 1
+                  when :duplicate then result[:duplicates] += 1
+                  when :error     then result[:errors] << outcome[:error]
+                  end
+                end
+
+                persist_bridge_state
+                log.info "[goal_bridge] bridged #{result[:bridged]} intentions to goals"
+                result
+              end
+
+              private
+
+              def log
+                Legion::Logging
+              end
+
+              def default_persistence
+                GoalManagement::Helpers::GoalPersistence.new
+              rescue StandardError => e
+                log.error "GoalBridge: #{e.message}"
+                nil
+              end
+
+              def persist_bridge_state
+                @persistence&.save_bridge_state(@bridged_intentions)
+              end
+
+              def bridge_one(intention)
+                return { status: :skipped } unless intention[:state] == :active
+
+                intent_key = "#{intention[:drive]}:#{intention[:domain]}:#{intention[:goal]}"
+                @mutex.synchronize do
+                  return { status: :duplicate } if @bridged_intentions.key?(intent_key)
+
+                  goal_result = @goal_client.add_goal(
+                    content:   intention[:goal],
+                    parent_id: nil,
+                    domain:    intention[:domain],
+                    priority:  intention[:salience],
+                    deadline:  nil
+                  )
+
+                  if goal_result[:success]
+                    @bridged_intentions[intent_key] = goal_result[:goal][:id]
+                    { status: :bridged, goal_id: goal_result[:goal][:id] }
+                  else
+                    { status: :error, error: goal_result[:error] }
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end