Module: Legion::Extensions::Agentic::Homeostasis::Metabolism::Runners::CognitiveMetabolism

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb

Instance Method Summary collapse

Instance Method Details

#anabolize(reserve_id:, energy_cost: 5.0) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 50

def anabolize(reserve_id:, energy_cost: 5.0, **)
  result = engine.anabolize(reserve_id: reserve_id, energy_cost: energy_cost)
  log.debug("[cognitive_metabolism] anabolize: reserve=#{reserve_id} " \
            "cost=#{energy_cost} value=#{result[:structure_value]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end

#catabolize(reserve_id:, complexity: 1.0) ⇒ Object 



41
42
43
44
45
46
47
48
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 41

def catabolize(reserve_id:, complexity: 1.0, **)
  result = engine.catabolize(reserve_id: reserve_id, complexity: complexity)
  log.debug("[cognitive_metabolism] catabolize: reserve=#{reserve_id} " \
            "complexity=#{complexity} gained=#{result[:energy_gained]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end

#create_reserve(max_energy: Helpers::Constants::MAX_ENERGY, metabolic_rate: Helpers::Constants::RESTING_METABOLIC_RATE, efficiency: 1.0) ⇒ Object 



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

def create_reserve(max_energy: Helpers::Constants::MAX_ENERGY,
                   metabolic_rate: Helpers::Constants::RESTING_METABOLIC_RATE,
                   efficiency: 1.0, **)
  reserve = engine.create_reserve(max_energy: max_energy, metabolic_rate: metabolic_rate, efficiency: efficiency)
  log.debug("[cognitive_metabolism] reserve created: id=#{reserve.id} max_energy=#{reserve.max_energy}")
  { success: true, reserve: reserve.to_h }
rescue ArgumentError => e
  { success: false, error: e.message }
end

#metabolic_status(reserve_id:) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 59

def metabolic_status(reserve_id:, **)
  result = engine.metabolic_report(reserve_id: reserve_id)
  log.debug("[cognitive_metabolism] status: reserve=#{reserve_id} state=#{result[:reserve][:state]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end

#recover(reserve_id:, duration: 1.0) ⇒ Object 



32
33
34
35
36
37
38
39
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 32

def recover(reserve_id:, duration: 1.0, **)
  result = engine.recover(reserve_id: reserve_id, duration: duration)
  log.debug("[cognitive_metabolism] recover: reserve=#{reserve_id} " \
            "gained=#{result[:energy_gained]} state=#{result[:state]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end

#run_all_cycles ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 76

def run_all_cycles(**)
  reserves = engine.all_reserves
  if reserves.empty?
    log.info('[cognitive_metabolism] run_all_cycles: no reserves to cycle')
    return { success: true, cycled: 0, reserves: 0, results: [], failures: [] }
  end

  results  = []
  failures = []

  reserves.each_key do |id|
    result = engine.run_cycle(reserve_id: id, operations: [])
    log.debug("[cognitive_metabolism] auto-cycle: reserve=#{id} state=#{result[:reserve_state]}")
    results << result
  rescue StandardError => e
    log.error("[cognitive_metabolism] auto-cycle failed for reserve=#{id}: #{e.message}")
    failures << { reserve_id: id, error: e.message }
  end

  log.info("[cognitive_metabolism] run_all_cycles: #{results.size}/#{reserves.size} reserves cycled")
  { success: failures.empty?, cycled: results.size, reserves: reserves.size, results: results, failures: failures }
rescue StandardError => e
  log.error("[cognitive_metabolism] run_all_cycles failed: #{e.message}")
  { success: false, cycled: 0, reserves: 0, results: [], failures: [], error: e.message }
end

#run_cycle(reserve_id:, operations: []) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 67

def run_cycle(reserve_id:, operations: [], **)
  result = engine.run_cycle(reserve_id: reserve_id, operations: operations)
  log.debug("[cognitive_metabolism] cycle: reserve=#{reserve_id} " \
            "ops=#{result[:cycle_count]} spent=#{result[:energy_spent_this_cycle]} state=#{result[:reserve_state]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end

#spend_energy(reserve_id:, operation_type:) ⇒ Object 



23
24
25
26
27
28
29
30
 
# File 'lib/legion/extensions/agentic/homeostasis/metabolism/runners/cognitive_metabolism.rb', line 23

def spend_energy(reserve_id:, operation_type:, **)
  result = engine.spend_energy(reserve_id: reserve_id, operation_type: operation_type)
  log.debug("[cognitive_metabolism] spend: reserve=#{reserve_id} op=#{operation_type} " \
            "spent=#{result[:actual_spent]} state=#{result[:state]}")
  { success: true }.merge(result)
rescue ArgumentError => e
  { success: false, error: e.message }
end