Module: Legion::Extensions::Agentic::Executive::WorkingMemory::Runners::WorkingMemory

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

Instance Method Summary collapse

Instance Method Details

#buffer ⇒ Object 



12
13
14
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 12

def buffer
  @buffer ||= Helpers::Buffer.new
end

#buffer_status ⇒ Object 



62
63
64
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 62

def buffer_status(**)
  { success: true, status: buffer.to_h }
end

#clear_buffer ⇒ Object 



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

def clear_buffer(**)
  buffer.clear
  Legion::Logging.debug '[working_memory] buffer cleared'
  { success: true }
end

#consolidation_candidates ⇒ Object 



66
67
68
69
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 66

def consolidation_candidates(**)
  candidates = buffer.consolidation_candidates
  { success: true, candidates: candidates.map(&:to_h), count: candidates.size }
end

#find_interference(id:) ⇒ Object 



89
90
91
92
93
94
95
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 89

def find_interference(id:, **)
  item = buffer.retrieve(id)
  return { success: false, reason: :not_found } unless item

  interfering = buffer.items.select { |other| other.id != id && item.interferes_with?(other) }
  { success: true, item_id: id, interfering: interfering.map(&:to_h), count: interfering.size }
end

#rehearse_item(id:) ⇒ Object 



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

def rehearse_item(id:, **)
  item = buffer.rehearse(id)
  return { success: false, reason: :not_found } unless item

  Legion::Logging.debug "[working_memory] rehearsed item=#{id} activation=#{item.activation.round(4)}"
  { success: true, item: item.to_h }
end

#remove_item(id:) ⇒ Object 



56
57
58
59
60
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 56

def remove_item(id:, **)
  buffer.remove(id)
  Legion::Logging.debug "[working_memory] removed item=#{id}"
  { success: true }
end

#retrieve_by_tag(tag:) ⇒ Object 



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

def retrieve_by_tag(tag:, **)
  items = buffer.retrieve_by_tag(tag)
  { success: true, items: items.map(&:to_h), count: items.size }
end

#retrieve_by_type(buffer_type:) ⇒ Object 



51
52
53
54
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 51

def retrieve_by_type(buffer_type:, **)
  items = buffer.retrieve_by_type(buffer_type)
  { success: true, items: items.map(&:to_h), count: items.size }
end

#retrieve_item(id:) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 31

def retrieve_item(id:, **)
  item = buffer.retrieve(id)
  return { success: false, reason: :not_found } unless item

  { success: true, item: item.to_h }
end

#store_item(content:, buffer_type: :episodic, priority: :normal, tags: []) ⇒ Object 



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

def store_item(content:, buffer_type: :episodic, priority: :normal, tags: [], **)
  Legion::Logging.debug '[working_memory] buffer full, eviction will occur' if buffer.full?

  item = buffer.store(content: content, buffer_type: buffer_type, priority: priority, tags: tags)
  Legion::Logging.debug "[working_memory] stored item=#{item.id} type=#{buffer_type} priority=#{priority}"
  { success: true, item: item.to_h }
end

#update_working_memory ⇒ Object 



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

def update_working_memory(**)
  buffer.tick_decay
  candidates = buffer.consolidation_candidates
  Legion::Logging.debug "[working_memory] tick: size=#{buffer.size} load=#{buffer.load_level} candidates=#{candidates.size}"
  { success: true, status: buffer.to_h, consolidation_candidates: candidates.map(&:to_h) }
end

#working_memory_stats ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/legion/extensions/agentic/executive/working_memory/runners/working_memory.rb', line 71

def working_memory_stats(**)
  {
    success:    true,
    size:       buffer.size,
    capacity:   buffer.capacity,
    load:       buffer.current_load.round(4),
    load_level: buffer.load_level,
    full:       buffer.full?,
    available:  buffer.available_slots
  }
end