lex-agentic-executive 0.1.12 → 0.2.1

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

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::Decomposer do
+  describe '.decompose' do
+    let(:goal_hash) do
+      { id: 'goal-001', content: 'fix degraded safety monitor', domain: :safety, priority: 0.7, status: :active }
+    end
+
+    context 'with heuristic strategy' do
+      it 'returns sub-goals array' do
+        result = described_class.decompose(goal: goal_hash, strategy: :heuristic)
+        expect(result[:success]).to be true
+        expect(result[:sub_goals]).to be_an(Array)
+        expect(result[:sub_goals]).not_to be_empty
+        expect(result[:sub_goals].first).to have_key(:content)
+        expect(result[:sub_goals].first).to have_key(:domain)
+      end
+
+      it 'preserves parent domain' do
+        result = described_class.decompose(goal: goal_hash, strategy: :heuristic)
+        result[:sub_goals].each { |sg| expect(sg[:domain]).to eq(:safety) }
+      end
+
+      it 'reports heuristic as strategy_used' do
+        result = described_class.decompose(goal: goal_hash, strategy: :heuristic)
+        expect(result[:strategy_used]).to eq(:heuristic)
+      end
+    end
+
+    context 'with llm strategy when llm unavailable' do
+      it 'falls back to heuristic' do
+        result = described_class.decompose(goal: goal_hash, strategy: :llm)
+        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
+      it 'uses heuristic when strategy is omitted' do
+        result = described_class.decompose(goal: goal_hash)
+        expect(result[:success]).to be true
+        expect(result[:strategy_used]).to eq(:heuristic)
+      end
+    end
+  end
+
+  describe '.decompose_heuristic' do
+    context 'with a known domain' do
+      it 'uses the safety domain template' do
+        goal = { content: 'monitor failure', domain: :safety, priority: 0.8 }
+        steps = described_class.decompose_heuristic(goal)
+        expect(steps.size).to eq(3)
+        expect(steps.map { |s| s[:content] }).to all(be_a(String))
+      end
+
+      it 'uses the cognition domain template' do
+        goal = { content: 'knowledge gap', domain: :cognition, priority: 0.6 }
+        steps = described_class.decompose_heuristic(goal)
+        expect(steps.size).to eq(3)
+      end
+
+      it 'uses the perception domain template' do
+        goal = { content: 'sensor drift', domain: :perception, priority: 0.5 }
+        steps = described_class.decompose_heuristic(goal)
+        expect(steps.size).to eq(3)
+      end
+    end
+
+    context 'with an unknown domain' do
+      it 'falls back to default four-step template' do
+        goal = { content: 'unknown task', domain: :general, priority: 0.5 }
+        steps = described_class.decompose_heuristic(goal)
+        expect(steps.size).to eq(4)
+      end
+    end
+
+    it 'sets priority from parent goal' do
+      goal = { content: 'some task', domain: :safety, priority: 0.9 }
+      steps = described_class.decompose_heuristic(goal)
+      steps.each { |s| expect(s[:priority]).to eq(0.9) }
+    end
+
+    it 'defaults priority to 0.5 when not provided' do
+      goal = { content: 'some task', domain: :general }
+      steps = described_class.decompose_heuristic(goal)
+      steps.each { |s| expect(s[:priority]).to eq(0.5) }
+    end
+  end
+
+  describe '.decompose_by_domain' do
+    it 'returns nil for unknown domain' do
+      result = described_class.decompose_by_domain('content', :unknown)
+      expect(result).to be_nil
+    end
+
+    it 'returns array of strings for known domain' do
+      result = described_class.decompose_by_domain('test content', :safety)
+      expect(result).to be_an(Array)
+      expect(result).to all(be_a(String))
+    end
+  end
+
+  describe '.default_steps' do
+    it 'returns four steps' do
+      steps = described_class.default_steps('do something')
+      expect(steps.size).to eq(4)
+    end
+
+    it 'interpolates content into each step' do
+      steps = described_class.default_steps('repair the system')
+      expect(steps).to all(include('repair the system'))
+    end
+  end
+
+  describe '.parse_sub_goals' do
+    it 'parses valid JSON array' do
+      json = '[{"content":"step one","domain":"safety","priority":0.8}]'
+      result = described_class.parse_sub_goals(json, :safety)
+      expect(result).to be_an(Array)
+      expect(result.first[:content]).to eq('step one')
+      expect(result.first[:domain]).to eq(:safety)
+      expect(result.first[:priority]).to eq(0.8)
+    end
+
+    it 'returns nil for invalid JSON' do
+      expect(described_class.parse_sub_goals('not json', :general)).to be_nil
+    end
+
+    it 'returns nil for empty array' do
+      expect(described_class.parse_sub_goals('[]', :general)).to be_nil
+    end
+
+    it 'strips markdown code fences' do
+      json = "```json\n[{\"content\":\"step\",\"domain\":\"general\",\"priority\":0.5}]\n```"
+      result = described_class.parse_sub_goals(json, :general)
+      expect(result).not_to be_nil
+      expect(result.first[:content]).to eq('step')
+    end
+
+    it 'clamps priority to 0.0..1.0' do
+      json = '[{"content":"x","priority":2.5}]'
+      result = described_class.parse_sub_goals(json, :general)
+      expect(result.first[:priority]).to eq(1.0)
+    end
+
+    it 'uses fallback domain when sub-goal omits domain' do
+      json = '[{"content":"x"}]'
+      result = described_class.parse_sub_goals(json, :cognition)
+      expect(result.first[:domain]).to eq(:cognition)
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::FeedbackListener do
+  let(:engine) { Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::GoalEngine.new }
+  let(:listener) { described_class.new(engine: engine) }
+
+  describe '#handle_task_event' do
+    before do
+      result = engine.add_goal(content: 'test goal', domain: :general, priority: 0.5, parent_id: nil, deadline: nil)
+      @goal_id = result[:goal][:id]
+      goal = engine.goals[@goal_id]
+      goal.activate!
+      goal.instance_variable_set(:@task_id, 'task-123')
+    end
+
+    it 'completes goal on task.completed' do
+      result = listener.handle_task_event(task_id: 'task-123', status: 'task.completed')
+      expect(result[:found]).to be true
+      expect(result[:new_status]).to eq(:completed)
+    end
+
+    it 'blocks goal on task.exception' do
+      result = listener.handle_task_event(task_id: 'task-123', status: 'task.exception')
+      expect(result[:found]).to be true
+      expect(result[:new_status]).to eq(:blocked)
+    end
+
+    it 'blocks goal on task.failed' do
+      result = listener.handle_task_event(task_id: 'task-123', status: 'task.failed')
+      expect(result[:found]).to be true
+      expect(result[:new_status]).to eq(:blocked)
+    end
+
+    it 'returns not found for unknown task_id' do
+      result = listener.handle_task_event(task_id: 'unknown', status: 'task.completed')
+      expect(result[:found]).to be false
+    end
+
+    it 'passes result through on failure status' do
+      result = listener.handle_task_event(task_id: 'task-123', status: 'task.failed', result: 'timeout')
+      expect(result[:error]).to eq('timeout')
+    end
+  end
+
+  describe '#start_listening' do
+    it 'registers event listeners when Legion::Events is available' do
+      events_spy = Class.new do
+        attr_reader :registered
+
+        def initialize
+          @registered = []
+        end
+
+        def on(event, &block)
+          @registered << { event: event, block: block }
+        end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      listener.start_listening
+      event_names = events_spy.registered.map { |r| r[:event] }
+      expect(event_names).to include('task.completed')
+      expect(event_names).to include('task.failed')
+    end
+
+    it 'sets listening? to true after start' do
+      events_spy = Class.new do
+        def on(_event, &); end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      listener.start_listening
+      expect(listener.listening?).to be true
+    end
+
+    it 'does not register twice if called again' do
+      events_spy = Class.new do
+        attr_reader :registered
+
+        def initialize
+          @registered = []
+        end
+
+        def on(event, &block)
+          @registered << { event: event, block: block }
+        end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      listener.start_listening
+      listener.start_listening
+      expect(events_spy.registered.size).to eq(2)
+    end
+
+    it 'does nothing when Legion::Events is not defined' do
+      hide_const('Legion::Events') if defined?(Legion::Events)
+      expect { listener.start_listening }.not_to raise_error
+      expect(listener.listening?).to be false
+    end
+  end
+
+  describe '#listening?' do
+    it 'returns false before start_listening' do
+      expect(listener.listening?).to be false
+    end
+  end
+end

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

@@ -318,6 +318,38 @@ RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::
     end
   end
 
+  describe '#reprioritize!' do
+    let(:engine) { described_class.new }
+
+    before do
+      result = engine.add_goal(content: 'low priority task', domain: :general, priority: 0.3, parent_id: nil,
+                               deadline: nil)
+      engine.activate_goal(goal_id: result[:goal][:id])
+      result = engine.add_goal(content: 'safety monitor degraded', domain: :safety, priority: 0.5, parent_id: nil,
+                               deadline: nil)
+      engine.activate_goal(goal_id: result[:goal][:id])
+    end
+
+    it 'boosts goals matching the signal domain' do
+      safety_goal = engine.active_goals.find { |g| g.domain == :safety }
+      old_priority = safety_goal.priority
+      engine.reprioritize!(signal: { domain: :safety, urgency: :critical })
+      expect(safety_goal.priority).to be > old_priority
+    end
+
+    it 'does not affect goals in other domains' do
+      general_goal = engine.active_goals.find { |g| g.domain == :general }
+      old_priority = general_goal.priority
+      engine.reprioritize!(signal: { domain: :safety, urgency: :critical })
+      expect(general_goal.priority).to eq(old_priority)
+    end
+
+    it 'handles unknown domains gracefully' do
+      result = engine.reprioritize!(signal: { domain: :unknown, urgency: :low })
+      expect(result[:adjusted]).to eq(0)
+    end
+  end
+
   describe '#goal_report' do
     it 'reports total goal count' do
       3.times { engine.add_goal(content: 'goal') }

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::GoalManagement::Helpers::GoalPersistence do
+  let(:persistence) { described_class.new(namespace: 'test_goals') }
+
+  before do
+    stub_const('Legion::Cache', Class.new do
+      def self.connected? = true
+      def self.get(key) = (@store ||= {})[key]
+      def self.set(key, value, **_opts) = ((@store ||= {})[key] = value)
+      def self.set_sync(key, value, **_opts) = ((@store ||= {})[key] = value)
+      def self.delete(key, **_opts) = (@store ||= {}).delete(key)
+      def self.delete_sync(key) = (@store ||= {}).delete(key)
+      def self.flush = (@store = {})
+    end)
+    Legion::Cache.flush
+  end
+
+  describe '#save_goal / #load_goal' do
+    it 'round-trips a goal hash' do
+      goal_hash = { id: 'g-001', content: 'test', domain: :safety, priority: 0.7,
+                    status: :active, progress: 0.0, sub_goal_ids: [] }
+      persistence.save_goal(goal_hash)
+      loaded = persistence.load_goal('g-001')
+      expect(loaded[:content]).to eq('test')
+      # JSON round-trip: symbol values become strings; Goal.from_h re-symbolizes via to_sym
+      expect(loaded[:domain].to_sym).to eq(:safety)
+    end
+
+    it 'returns nil for missing goal' do
+      expect(persistence.load_goal('nonexistent')).to be_nil
+    end
+
+    it 'updates the index on save' do
+      persistence.save_goal({ id: 'g-idx', content: 'indexed', domain: :general,
+                              priority: 0.5, status: :proposed, progress: 0.0, sub_goal_ids: [] })
+      all = persistence.load_all
+      expect(all.keys).to include('g-idx')
+    end
+  end
+
+  describe '#save_all / #load_all' do
+    it 'round-trips multiple goals' do
+      goals = {
+        'g-001' => { id: 'g-001', content: 'goal one', domain: :safety, priority: 0.5,
+                     status: :active, progress: 0.0, sub_goal_ids: [] },
+        'g-002' => { id: 'g-002', content: 'goal two', domain: :cognition, priority: 0.8,
+                     status: :proposed, progress: 0.0, sub_goal_ids: [] }
+      }
+      persistence.save_all(goals)
+      loaded = persistence.load_all
+      expect(loaded.size).to eq(2)
+      expect(loaded['g-001'][:content]).to eq('goal one')
+    end
+
+    it 'returns empty hash when nothing saved' do
+      expect(persistence.load_all).to eq({})
+    end
+  end
+
+  describe '#delete_goal' do
+    it 'removes a goal from cache' do
+      persistence.save_goal({ id: 'g-del', content: 'delete me', domain: :general,
+                              priority: 0.5, status: :active, progress: 0.0, sub_goal_ids: [] })
+      persistence.delete_goal('g-del')
+      expect(persistence.load_goal('g-del')).to be_nil
+    end
+
+    it 'removes the goal id from the index' do
+      persistence.save_goal({ id: 'g-rm', content: 'remove from index', domain: :general,
+                              priority: 0.5, status: :active, progress: 0.0, sub_goal_ids: [] })
+      persistence.delete_goal('g-rm')
+      all = persistence.load_all
+      expect(all.keys).not_to include('g-rm')
+    end
+  end
+
+  describe '#save_bridge_state / #load_bridge_state' do
+    it 'round-trips bridge tracking hash' do
+      # JSON round-trip with symbolize_names: true turns string keys into symbols
+      state = { 'curiosity:cognition:explore gaps' => 'g-001' }
+      persistence.save_bridge_state(state)
+      loaded = persistence.load_bridge_state
+      expect(loaded.values.first).to eq('g-001')
+    end
+
+    it 'returns empty hash when nothing saved' do
+      expect(persistence.load_bridge_state).to eq({})
+    end
+  end
+
+  describe 'when cache unavailable' do
+    before { allow(Legion::Cache).to receive(:connected?).and_return(false) }
+
+    it 'returns nil on load_goal' do
+      expect(persistence.load_goal('g-001')).to be_nil
+    end
+
+    it 'returns false on save_goal' do
+      expect(persistence.save_goal({ id: 'g-001', content: 'x' })).to be false
+    end
+
+    it 'returns empty hash on load_all' do
+      expect(persistence.load_all).to eq({})
+    end
+
+    it 'returns empty hash on load_bridge_state' do
+      expect(persistence.load_bridge_state).to eq({})
+    end
+
+    it 'returns false on save_bridge_state' do
+      expect(persistence.save_bridge_state({ 'k' => 'v' })).to be false
+    end
+
+    it 'returns false on delete_goal' do
+      expect(persistence.delete_goal('g-001')).to be false
+    end
+  end
+end