lex-agentic-executive 0.1.12 → 0.2.0

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.12'
+        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

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

@@ -17,10 +17,10 @@ module Legion
                 )
 
                 new_intentions = Helpers::DriveSynthesizer.generate_intentions(drives, cognitive_state: cognitive_state)
-                pushed = 0
+                pushed_intentions = []
                 new_intentions.each do |intention|
-                  result = intention_stack.push(intention)
-                  pushed += 1 if result == :pushed
+                  outcome = intention_stack.push(intention)
+                  pushed_intentions << intention if outcome == :pushed
                 end
 
                 expired = intention_stack.decay_all
@@ -28,18 +28,25 @@ module Legion
                 current = intention_stack.top
                 proactive = evaluate_proactive_outreach(tick_results, bond_state)
 
-                log.debug "[volition] drives=#{format_drives(drives)} pushed=#{pushed} expired=#{expired} " \
+                log.debug "[volition] drives=#{format_drives(drives)} pushed=#{pushed_intentions.size} expired=#{expired} " \
                           "active=#{intention_stack.active_count} top=#{current&.dig(:goal)}"
 
-                {
+                result = {
                   drives:             drives,
                   dominant_drive:     dominant,
-                  new_intentions:     pushed,
+                  new_intentions:     pushed_intentions.map { |i| format_intention(i) },
                   expired:            expired,
                   active_intentions:  intention_stack.active_count,
                   current_intention:  format_intention(current),
                   proactive_outreach: proactive
                 }
+
+                if defined?(@goal_bridge) && @goal_bridge
+                  bridge_result = @goal_bridge.bridge_intentions(pushed_intentions)
+                  result[:bridge_result] = bridge_result
+                end
+
+                result
               end
 
               def current_intention(**)

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

@@ -5,6 +5,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'
 require 'legion/extensions/agentic/executive/volition/client'
 

data/spec/integration/autonomous_goal_pipeline_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Autonomous Goal Pipeline Integration' do
+  let(:goal_client) { Legion::Extensions::Agentic::Executive::GoalManagement::Client.new }
+  let(:bridge) do
+    Legion::Extensions::Agentic::Executive::Volition::Helpers::GoalBridge.new(
+      goal_client: goal_client
+    )
+  end
+  let(:volition_client) do
+    Legion::Extensions::Agentic::Executive::Volition::Client.new(
+      stack:       Legion::Extensions::Agentic::Executive::Volition::Helpers::IntentionStack.new,
+      goal_bridge: bridge
+    )
+  end
+
+  let(:tick_results) do
+    { working_memory_integration: { curiosity: { intensity: 0.9, count: 5 } } }
+  end
+  let(:cognitive_state) do
+    { health: 0.6, pending_goals: 0, arousal: 0.5, gut: { signal: :explore },
+      confidence: 0.4, pending_questions: 3, peer_interactions: 0,
+      trust: { avg_composite: 0.5 } }
+  end
+  let(:bond_state) { {} }
+
+  it 'flows from intention through goal to dispatch-ready state' do
+    # Step 1: Form intentions (triggers goal bridge)
+    volition_result = volition_client.form_intentions(
+      tick_results: tick_results, cognitive_state: cognitive_state, bond_state: bond_state
+    )
+    expect(volition_result[:bridge_result][:bridged]).to be >= 1
+
+    # Step 2: Verify goals were created
+    goal_ids = volition_result[:bridge_result][:goal_ids]
+    expect(goal_ids).not_to be_empty
+
+    # Step 3: Auto-decompose the first goal
+    first_goal_id = goal_ids.first
+    goal_client.activate_goal(goal_id: first_goal_id)
+    decomp = goal_client.auto_decompose_goal(goal_id: first_goal_id, strategy: :heuristic)
+    expect(decomp[:success]).to be true
+
+    # Step 4: Verify goal tree has children
+    tree = goal_client.get_goal_tree(goal_id: first_goal_id)
+    expect(tree[:tree]).not_to be_nil
+
+    # Step 5: Check goal status shows goals exist
+    status = goal_client.goal_status
+    expect(status[:total]).to be >= 1
+  end
+
+  it 'updates goal on simulated task completion' do
+    # Create and activate a leaf goal with task assignment
+    add_result = goal_client.add_goal(
+      content: 'simple leaf goal', domain: :general, priority: 0.5,
+      parent_id: nil, deadline: nil
+    )
+    goal_id = add_result[:goal][:id]
+    goal_client.activate_goal(goal_id: goal_id)
+
+    engine = goal_client.send(:engine)
+    goal = engine.goals[goal_id]
+    goal.assign_task!(task_id: 'task-sim-001', runner_mapping: { runner_class: 'Test', function: :test })
+
+    # Simulate task completion
+    update = engine.update_from_task_event(task_id: 'task-sim-001', status: 'task.completed')
+    expect(update[:found]).to be true
+    expect(update[:new_status]).to eq(:completed)
+    expect(goal.progress).to eq(1.0)
+  end
+
+  it 'blocks goal on simulated task failure' do
+    add_result = goal_client.add_goal(
+      content: 'failing goal', domain: :general, priority: 0.5,
+      parent_id: nil, deadline: nil
+    )
+    goal_id = add_result[:goal][:id]
+    goal_client.activate_goal(goal_id: goal_id)
+
+    engine = goal_client.send(:engine)
+    goal = engine.goals[goal_id]
+    goal.assign_task!(task_id: 'task-fail-001', runner_mapping: { runner_class: 'Test', function: :test })
+
+    update = engine.update_from_task_event(task_id: 'task-fail-001', status: 'task.exception')
+    expect(update[:found]).to be true
+    expect(update[:new_status]).to eq(:blocked)
+  end
+
+  it 'reprioritizes goals on urgency signal' do
+    goal_client.add_goal(content: 'safety issue', domain: :safety, priority: 0.4, parent_id: nil, deadline: nil)
+    goal_client.add_goal(content: 'general task', domain: :general, priority: 0.4, parent_id: nil, deadline: nil)
+
+    # Activate both
+    engine = goal_client.send(:engine)
+    engine.goals.each_value(&:activate!)
+
+    result = engine.reprioritize!(signal: { domain: :safety, urgency: :critical })
+    expect(result[:adjusted]).to eq(1)
+
+    safety = engine.goals.values.find { |g| g.domain == :safety }
+    general = engine.goals.values.find { |g| g.domain == :general }
+    expect(safety.priority).to be > general.priority
+  end
+end