Module: Legion::Extensions::Agentic::Executive::ProspectiveMemory::Runners::ProspectiveMemory

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

Instance Method Summary collapse

Instance Method Details

#cancel_intention(intention_id:) ⇒ Object 



65
66
67
68
69
70
71
72
73
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 65

def cancel_intention(intention_id:, **)
  intention = prospective_engine.cancel_intention(intention_id: intention_id)
  if intention
    Legion::Logging.debug "[prospective_memory] cancelled intention id=#{intention_id[0..7]}"
    { success: true, updated: true, intention: intention.to_h }
  else
    { success: false, updated: false, reason: :not_found }
  end
end

#check_expirations ⇒ Object 



75
76
77
78
79
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 75

def check_expirations(**)
  expired_count = prospective_engine.check_expirations
  Legion::Logging.debug "[prospective_memory] expiration check expired=#{expired_count}"
  { success: true, expired_count: expired_count }
end

#create_intention(description:, trigger_type:, trigger_condition:, urgency: Helpers::Constants::DEFAULT_URGENCY, domain: nil, expires_at: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 13

def create_intention(description:, trigger_type:, trigger_condition:,
                     urgency: Helpers::Constants::DEFAULT_URGENCY,
                     domain: nil, expires_at: nil, **)
  unless Helpers::Constants::TRIGGER_TYPES.include?(trigger_type)
    return { success: false, error: :invalid_trigger_type, valid_types: Helpers::Constants::TRIGGER_TYPES }
  end

  intention = prospective_engine.create_intention(
    description:       description,
    trigger_type:      trigger_type,
    trigger_condition: trigger_condition,
    urgency:           urgency,
    domain:            domain,
    expires_at:        expires_at
  )

  Legion::Logging.debug "[prospective_memory] created intention id=#{intention.id[0..7]} " \
                        "type=#{trigger_type} urgency=#{intention.urgency.round(2)}"

  { success: true, created: true, intention: intention.to_h }
end

#decay_urgency ⇒ Object 



117
118
119
120
121
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 117

def decay_urgency(**)
  prospective_engine.decay_all_urgency
  Legion::Logging.debug '[prospective_memory] urgency decay cycle complete'
  { success: true, decayed: true }
end

#execute_intention(intention_id:) ⇒ Object 



55
56
57
58
59
60
61
62
63
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 55

def execute_intention(intention_id:, **)
  intention = prospective_engine.execute_intention(intention_id: intention_id)
  if intention
    Legion::Logging.info "[prospective_memory] executed intention id=#{intention_id[0..7]}"
    { success: true, updated: true, intention: intention.to_h }
  else
    { success: false, updated: false, reason: :not_found }
  end
end

#execution_rate ⇒ Object 



123
124
125
126
127
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 123

def execution_rate(**)
  rate = prospective_engine.execution_rate
  Legion::Logging.debug "[prospective_memory] execution_rate=#{rate.round(4)}"
  { success: true, execution_rate: rate }
end

#intention_report ⇒ Object 



129
130
131
132
133
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 129

def intention_report(**)
  report = prospective_engine.intention_report
  Legion::Logging.debug "[prospective_memory] report total=#{report[:total]}"
  { success: true }.merge(report)
end

#intentions_by_domain(domain:) ⇒ Object 



99
100
101
102
103
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 99

def intentions_by_domain(domain:, **)
  intentions = prospective_engine.by_domain(domain: domain)
  Legion::Logging.debug "[prospective_memory] by_domain domain=#{domain} count=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size, domain: domain }
end

#intentions_by_urgency(min_urgency: 0.5) ⇒ Object 



105
106
107
108
109
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 105

def intentions_by_urgency(min_urgency: 0.5, **)
  intentions = prospective_engine.by_urgency(min_urgency: min_urgency)
  Legion::Logging.debug "[prospective_memory] by_urgency min=#{min_urgency} count=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size }
end

#monitor_intention(intention_id:) ⇒ Object 



35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 35

def monitor_intention(intention_id:, **)
  intention = prospective_engine.monitor_intention(intention_id: intention_id)
  if intention
    Legion::Logging.debug "[prospective_memory] monitoring intention id=#{intention_id[0..7]}"
    { success: true, updated: true, intention: intention.to_h }
  else
    { success: false, updated: false, reason: :not_found }
  end
end

#monitoring_intentions ⇒ Object 



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

def monitoring_intentions(**)
  intentions = prospective_engine.monitoring_intentions
  Legion::Logging.debug "[prospective_memory] monitoring count=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size }
end

#most_urgent_intentions(limit: 5) ⇒ Object 



111
112
113
114
115
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 111

def most_urgent_intentions(limit: 5, **)
  intentions = prospective_engine.most_urgent(limit: limit)
  Legion::Logging.debug "[prospective_memory] most_urgent limit=#{limit} found=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size }
end

#pending_intentions ⇒ Object 



81
82
83
84
85
 
# File 'lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb', line 81

def pending_intentions(**)
  intentions = prospective_engine.pending_intentions
  Legion::Logging.debug "[prospective_memory] pending count=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size }
end

#trigger_intention(intention_id:) ⇒ Object 



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

def trigger_intention(intention_id:, **)
  intention = prospective_engine.trigger_intention(intention_id: intention_id)
  if intention
    Legion::Logging.info "[prospective_memory] triggered intention id=#{intention_id[0..7]}"
    { success: true, updated: true, intention: intention.to_h }
  else
    { success: false, updated: false, reason: :not_found }
  end
end

#triggered_intentions ⇒ Object 



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

def triggered_intentions(**)
  intentions = prospective_engine.triggered_intentions
  Legion::Logging.debug "[prospective_memory] triggered count=#{intentions.size}"
  { success: true, intentions: intentions.map(&:to_h), count: intentions.size }
end