Module: Legion::Extensions::Agentic::Homeostasis::Tide::Runners::CognitiveTide

Extended by:
CognitiveTide
Includes:
Helpers::Lex
Included in:
Client, CognitiveTide
Defined in:
lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb

Instance Method Summary collapse

Instance Method Details

#add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0, phase_offset: 0.0, engine: nil) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 15

def add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
                   phase_offset: 0.0, engine: nil, **)
  eng = engine || tide_engine
  osc = eng.add_oscillator(
    oscillator_type: oscillator_type.to_sym,
    period:          period,
    amplitude:       amplitude,
    phase_offset:    phase_offset
  )
  log.debug("[cognitive_tide] oscillator added: type=#{oscillator_type} " \
            "period=#{period} amplitude=#{amplitude}")
  { success: true, oscillator: osc.to_h }
rescue ArgumentError => e
  log.error("[cognitive_tide] add_oscillator failed: #{e.message}")
  { success: false, error: e.message }
end

#check_tide(engine: nil) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 32

def check_tide(engine: nil, **)
  eng   = engine || tide_engine
  level = eng.composite_tide_level
  phase = eng.current_phase
  label = Helpers::Constants::TIDE_LABELS.find { |tl| tl[:range].cover?(level) }&.fetch(:label, 'ebb')
  log.debug("[cognitive_tide] check_tide: level=#{level.round(3)} phase=#{phase} label=#{label}")
  {
    success: true,
    level:   level,
    phase:   phase,
    label:   label
  }
rescue ArgumentError => e
  log.error("[cognitive_tide] check_tide failed: #{e.message}")
  { success: false, error: e.message }
end

#deposit_idea(domain:, idea:, capacity: 20, tide_threshold: nil, engine: nil) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 49

def deposit_idea(domain:, idea:, capacity: 20, tide_threshold: nil, engine: nil, **)
  eng = engine || tide_engine

  if tide_threshold
    level = eng.composite_tide_level
    if level > tide_threshold
      log.debug("[cognitive_tide] deposit_idea skipped: tide=#{level.round(3)} above threshold=#{tide_threshold}")
      return { success: false, reason: :tide_too_high, level: level }
    end
  end

  deposited = eng.deposit_to_pool(domain: domain, item: idea, capacity: capacity)
  log.debug("[cognitive_tide] deposit_idea: domain=#{domain} deposited=#{deposited}")
  { success: deposited, domain: domain }
rescue ArgumentError => e
  log.error("[cognitive_tide] deposit_idea failed: #{e.message}")
  { success: false, error: e.message }
end

#harvest(min_depth: 0.0, engine: nil) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 68

def harvest(min_depth: 0.0, engine: nil, **)
  eng    = engine || tide_engine
  result = eng.harvest_pools(min_depth: min_depth.to_f)
  total  = result.values.sum(&:size)
  log.debug("[cognitive_tide] harvest: domains=#{result.keys.size} total_items=#{total}")
  { success: true, harvested: result, total_items: total }
rescue ArgumentError => e
  log.error("[cognitive_tide] harvest failed: #{e.message}")
  { success: false, error: e.message }
end

#tide_forecast(duration: 86_400, engine: nil) ⇒ Object 



79
80
81
82
83
84
85
86
87
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 79

def tide_forecast(duration: 86_400, engine: nil, **)
  eng      = engine || tide_engine
  forecast = eng.tide_forecast(duration)
  log.debug("[cognitive_tide] tide_forecast: duration=#{duration} steps=#{forecast.size}")
  { success: true, forecast: forecast, duration: duration }
rescue ArgumentError => e
  log.error("[cognitive_tide] tide_forecast failed: #{e.message}")
  { success: false, error: e.message }
end

#tide_maintenance(engine: nil) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 100

def tide_maintenance(engine: nil, **)
  eng = engine || tide_engine
  eng.evaporate_all!
  eng.oscillators.each(&:tick!)
  pools_maintained = eng.pools.size
  phase            = eng.current_phase
  level            = eng.composite_tide_level
  log.debug("[tide] maintenance: pools=#{pools_maintained} phase=#{phase} level=#{level}")
  { pools_maintained: pools_maintained, current_phase: phase, tide_level: level }
end

#tide_status(engine: nil) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
 
# File 'lib/legion/extensions/agentic/homeostasis/tide/runners/cognitive_tide.rb', line 89

def tide_status(engine: nil, **)
  eng    = engine || tide_engine
  report = eng.tide_report
  log.debug("[cognitive_tide] tide_status: level=#{report[:level].round(3)} " \
            "phase=#{report[:phase]} pools=#{report[:pool_count]}")
  report.merge(success: true)
rescue ArgumentError => e
  log.error("[cognitive_tide] tide_status failed: #{e.message}")
  { success: false, error: e.message }
end