Module: Legion::Extensions::Agentic::Executive::Planning::Runners::Planning

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

Instance Method Summary collapse

Instance Method Details

#abandon_plan(plan_id:, reason: nil) ⇒ Object 



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

def abandon_plan(plan_id:, reason: nil, **)
  outcome = plan_store.abandon_plan(plan_id: plan_id, reason: reason)
  Legion::Logging.info "[planning] abandoned plan=#{plan_id} reason=#{reason}"
  outcome
end

#active_plans ⇒ Object 



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

def active_plans(**)
  plans = plan_store.active_plans
  Legion::Logging.debug "[planning] active_plans=#{plans.size}"
  {
    plans: plans.map(&:to_h),
    count: plans.size
  }
end

#advance_plan(plan_id:, step_id:, result: {}) ⇒ Object 



40
41
42
43
44
 
# File 'lib/legion/extensions/agentic/executive/planning/runners/planning.rb', line 40

def advance_plan(plan_id:, step_id:, result: {}, **)
  outcome = plan_store.advance_step(plan_id: plan_id, step_id: step_id, result: result)
  Legion::Logging.debug "[planning] advance plan=#{plan_id} step=#{step_id} outcome=#{outcome[:plan_status]}"
  outcome
end

#create_plan(goal:, steps: [], priority: :medium, contingencies: {}, parent_plan_id: nil) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/legion/extensions/agentic/executive/planning/runners/planning.rb', line 27

def create_plan(goal:, steps: [], priority: :medium, contingencies: {}, parent_plan_id: nil, **)
  steps_data = steps.map { |s| s.is_a?(Hash) ? s : s.to_h }
  plan = plan_store.create_plan(
    goal:           goal,
    steps:          steps_data,
    priority:       priority,
    contingencies:  contingencies,
    parent_plan_id: parent_plan_id
  )
  Legion::Logging.info "[planning] created plan=#{plan.id} goal=#{goal} steps=#{plan.steps.size}"
  { success: true, plan_id: plan.id, goal: goal, steps: plan.steps.size }
end

#fail_plan_step(plan_id:, step_id:, reason: nil) ⇒ Object 



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

def fail_plan_step(plan_id:, step_id:, reason: nil, **)
  outcome = plan_store.fail_step(plan_id: plan_id, step_id: step_id, reason: reason)
  Legion::Logging.warn "[planning] step failed plan=#{plan_id} step=#{step_id} reason=#{reason}"
  outcome
end

#plan_status(plan_id:) ⇒ Object 



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

def plan_status(plan_id:, **)
  outcome = plan_store.plan_progress(plan_id)
  Legion::Logging.debug "[planning] status plan=#{plan_id} progress=#{outcome[:progress]}"
  outcome
end

#planning_stats ⇒ Object 



84
85
86
87
88
 
# File 'lib/legion/extensions/agentic/executive/planning/runners/planning.rb', line 84

def planning_stats(**)
  stats = plan_store.stats
  Legion::Logging.debug "[planning] stats=#{stats}"
  stats
end

#replan(plan_id:, new_steps: [], reason: nil) ⇒ Object 



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

def replan(plan_id:, new_steps: [], reason: nil, **)
  steps_data = new_steps.map { |s| s.is_a?(Hash) ? s : s.to_h }
  outcome = plan_store.replan(plan_id: plan_id, new_steps: steps_data, reason: reason)
  if outcome[:success]
    Legion::Logging.info "[planning] replan plan=#{plan_id} count=#{outcome[:replan_count]} reason=#{reason}"
  else
    Legion::Logging.warn "[planning] replan rejected plan=#{plan_id} reason=#{outcome[:error]}"
  end
  outcome
end

#update_planning(tick_results: {}) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/legion/extensions/agentic/executive/planning/runners/planning.rb', line 13

def update_planning(tick_results: {}, **)
  check_stale_plans
  advance_ready_steps(tick_results)

  active = plan_store.active_plans
  Legion::Logging.debug "[planning] active_plans=#{active.size} stats=#{plan_store.stats[:by_status]}"

  {
    active_plans:  active.size,
    total_steps:   active.sum { |p| p.steps.size },
    stale_checked: true
  }
end