Module: Legion::Extensions::Agentic::Executive::GoalManagement::Runners::GoalManagement

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb

Instance Method Summary collapse

Instance Method Details

#abandon_goal(goal_id:) ⇒ Object 



61
62
63
64
65
66
67
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 61

def abandon_goal(goal_id:, **)
  log.debug "[goal_management] runner abandon_goal id=#{goal_id}"
  engine.abandon_goal(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] abandon_goal error: #{e.message}"
  { success: false, error: e.message }
end

#activate_goal(goal_id:) ⇒ Object 



45
46
47
48
49
50
51
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 45

def activate_goal(goal_id:, **)
  log.debug "[goal_management] runner activate_goal id=#{goal_id}"
  engine.activate_goal(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] activate_goal error: #{e.message}"
  { success: false, error: e.message }
end

#add_goal(content:, parent_id: nil, domain: :general, priority: Helpers::Constants::DEFAULT_PRIORITY, deadline: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 13

def add_goal(content:, parent_id: nil, domain: :general,
             priority: Helpers::Constants::DEFAULT_PRIORITY, deadline: nil, **)
  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
  log.error "[goal_management] add_goal error: #{e.message}"
  { success: false, error: e.message }
end

#advance_goal_progress(goal_id:, amount:) ⇒ Object 



85
86
87
88
89
90
91
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 85

def advance_goal_progress(goal_id:, 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
  log.error "[goal_management] advance_goal_progress error: #{e.message}"
  { success: false, error: e.message }
end

#auto_decompose_goal(goal_id:, strategy: :heuristic) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 31

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

#block_goal(goal_id:) ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 69

def block_goal(goal_id:, **)
  log.debug "[goal_management] runner block_goal id=#{goal_id}"
  engine.block_goal(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] block_goal error: #{e.message}"
  { success: false, error: e.message }
end

#complete_goal(goal_id:) ⇒ Object 



53
54
55
56
57
58
59
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 53

def complete_goal(goal_id:, **)
  log.debug "[goal_management] runner complete_goal id=#{goal_id}"
  engine.complete_goal(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] complete_goal error: #{e.message}"
  { success: false, error: e.message }
end

#decay_priorities ⇒ Object 



154
155
156
157
158
159
160
161
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 154

def decay_priorities(**)
  result = engine.decay_all_priorities!
  log.debug "[goal_management] decay_priorities decayed=#{result[:decayed]}"
  result.merge(success: true)
rescue StandardError => e
  log.error "[goal_management] decay_priorities error: #{e.message}"
  { success: false, error: e.message }
end

#decompose_goal(goal_id:, sub_goals:) ⇒ Object 



23
24
25
26
27
28
29
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 23

def decompose_goal(goal_id:, sub_goals:, **)
  log.debug "[goal_management] runner decompose_goal parent=#{goal_id}"
  engine.decompose(goal_id: goal_id, sub_goals: sub_goals)
rescue StandardError => e
  log.error "[goal_management] decompose_goal error: #{e.message}"
  { success: false, error: e.message }
end

#detect_goal_conflicts(goal_id:) ⇒ Object 



93
94
95
96
97
98
99
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 93

def detect_goal_conflicts(goal_id:, **)
  log.debug "[goal_management] runner detect_goal_conflicts id=#{goal_id}"
  engine.detect_conflicts(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] detect_goal_conflicts error: #{e.message}"
  { success: false, error: e.message }
end

#dispatch_leaf_goals ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 172

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

#get_goal_tree(goal_id:) ⇒ Object 



137
138
139
140
141
142
143
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 137

def get_goal_tree(goal_id:, **)
  log.debug "[goal_management] runner get_goal_tree id=#{goal_id}"
  engine.goal_tree(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] get_goal_tree error: #{e.message}"
  { success: false, error: e.message }
end

#goal_status ⇒ Object 



163
164
165
166
167
168
169
170
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 163

def goal_status(**)
  report = engine.goal_report
  log.debug "[goal_management] goal_status total=#{report[:total]}"
  { success: true }.merge(report)
rescue StandardError => e
  log.error "[goal_management] goal_status error: #{e.message}"
  { success: false, error: e.message }
end

#highest_priority_goals(limit: 5) ⇒ Object 



145
146
147
148
149
150
151
152
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 145

def highest_priority_goals(limit: 5, **)
  goals = engine.highest_priority(limit: limit)
  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
  log.error "[goal_management] highest_priority_goals error: #{e.message}"
  { success: false, error: e.message }
end

#list_active_goals ⇒ Object 



101
102
103
104
105
106
107
108
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 101

def list_active_goals(**)
  goals = engine.active_goals
  log.debug "[goal_management] list_active_goals count=#{goals.size}"
  { success: true, goals: goals.map(&:to_h), count: goals.size }
rescue StandardError => e
  log.error "[goal_management] list_active_goals error: #{e.message}"
  { success: false, error: e.message }
end

#list_blocked_goals ⇒ Object 



110
111
112
113
114
115
116
117
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 110

def list_blocked_goals(**)
  goals = engine.blocked_goals
  log.debug "[goal_management] list_blocked_goals count=#{goals.size}"
  { success: true, goals: goals.map(&:to_h), count: goals.size }
rescue StandardError => e
  log.error "[goal_management] list_blocked_goals error: #{e.message}"
  { success: false, error: e.message }
end

#list_completed_goals ⇒ Object 



128
129
130
131
132
133
134
135
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 128

def list_completed_goals(**)
  goals = engine.completed_goals
  log.debug "[goal_management] list_completed_goals count=#{goals.size}"
  { success: true, goals: goals.map(&:to_h), count: goals.size }
rescue StandardError => e
  log.error "[goal_management] list_completed_goals error: #{e.message}"
  { success: false, error: e.message }
end

#list_overdue_goals ⇒ Object 



119
120
121
122
123
124
125
126
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 119

def list_overdue_goals(**)
  goals = engine.overdue_goals
  log.debug "[goal_management] list_overdue_goals count=#{goals.size}"
  { success: true, goals: goals.map(&:to_h), count: goals.size }
rescue StandardError => e
  log.error "[goal_management] list_overdue_goals error: #{e.message}"
  { success: false, error: e.message }
end

#start_feedback_listener ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 202

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

#unblock_goal(goal_id:) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 77

def unblock_goal(goal_id:, **)
  log.debug "[goal_management] runner unblock_goal id=#{goal_id}"
  engine.unblock_goal(goal_id: goal_id)
rescue StandardError => e
  log.error "[goal_management] unblock_goal error: #{e.message}"
  { success: false, error: e.message }
end

#update_goal_from_task(task_id:, status:, result: nil) ⇒ Object 



195
196
197
198
199
200
 
# File 'lib/legion/extensions/agentic/executive/goal_management/runners/goal_management.rb', line 195

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