Module: Legion::Extensions::Agentic::Self::Metacognition::Helpers::SelfModel

Defined in:
lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb

Class Method Summary collapse

Class Method Details

.build(subsystem_states: {}, tick_results: {}) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 12

def build(subsystem_states: {}, tick_results: {})
  loaded = discover_loaded_extensions
  capabilities = map_capabilities(loaded)

  {
    identity:     build_identity,
    architecture: build_architecture(loaded),
    capabilities: capabilities,
    subsystems:   build_subsystem_states(subsystem_states),
    cognitive:    build_cognitive_snapshot(tick_results),
    assembled_at: Time.now.utc
  }
end

.build_architecture(loaded_map) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 65

def build_architecture(loaded_map)
  total = loaded_map.size
  active = loaded_map.count { |_, v| v[:loaded] }

  {
    total_extensions: total,
    loaded_count:     active,
    unloaded_count:   total - active,
    loaded:           loaded_map.select { |_, v| v[:loaded] }.keys,
    unloaded:         loaded_map.reject { |_, v| v[:loaded] }.keys
  }
end

.build_cognitive_snapshot(tick_results) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 92

def build_cognitive_snapshot(tick_results)
  return { status: :no_tick_data } unless tick_results.is_a?(Hash) && !tick_results.empty?

  {
    mode:           extract_mode(tick_results),
    phases_run:     tick_results.keys.size,
    has_reflection: tick_results.key?(:post_tick_reflection),
    health:         extract_health(tick_results),
    active_drives:  extract_drives(tick_results),
    attention:      extract_attention(tick_results),
    curiosity:      extract_curiosity(tick_results),
    prediction:     extract_prediction(tick_results)
  }
end

.build_identity ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 56

def build_identity
  {
    framework:  'LegionIO',
    role:       :cognitive_agent,
    model:      :brain_modeled,
    extensions: Constants::EXTENSION_CAPABILITIES.size
  }
end

.build_subsystem_states(states) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 78

def build_subsystem_states(states)
  return {} unless states.is_a?(Hash)

  states.each_with_object({}) do |(key, state), acc|
    acc[key] = normalize_subsystem_state(state)
  end
end

.discover_loaded_extensions ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 38

def discover_loaded_extensions
  Constants::EXTENSION_CAPABILITIES.each_with_object({}) do |(ext_sym, _cat), acc|
    acc[ext_sym] = { loaded: extension_loaded?(ext_sym) }
  end
rescue StandardError => _e
  {}
end

.extension_loaded?(ext_sym) ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 26

def extension_loaded?(ext_sym)
  return true if Legion::Extensions.const_defined?(ext_sym, false)

  agentic = Legion::Extensions.const_get(:Agentic, false)
  agentic.constants(false).any? do |domain|
    ns = agentic.const_get(domain, false)
    ns.is_a?(Module) && ns.const_defined?(ext_sym, false)
  end
rescue StandardError => _e
  false
end

.extract_attention(tick_results) ⇒ Object 



125
126
127
128
129
130
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 125

def extract_attention(tick_results)
  attention = tick_results[:sensory_processing]
  return nil unless attention.is_a?(Hash)

  { spotlight: attention[:spotlight_count], total: attention[:total_signals] }
end

.extract_curiosity(tick_results) ⇒ Object 



132
133
134
135
136
137
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 132

def extract_curiosity(tick_results)
  curiosity = tick_results[:working_memory_integration]
  return nil unless curiosity.is_a?(Hash)

  { intensity: curiosity[:curiosity_intensity], open_wonders: curiosity[:open_wonders] }
end

.extract_drives(tick_results) ⇒ Object 



118
119
120
121
122
123
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 118

def extract_drives(tick_results)
  volition = tick_results[:action_selection]
  return [] unless volition.is_a?(Hash) && volition[:intentions].is_a?(Array)

  volition[:intentions].first(3).filter_map { |i| i[:drive] }
end

.extract_health(tick_results) ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 111

def extract_health(tick_results)
  reflection = tick_results[:post_tick_reflection]
  return nil unless reflection.is_a?(Hash)

  reflection[:cognitive_health]
end

.extract_mode(tick_results) ⇒ Object 



107
108
109
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 107

def extract_mode(tick_results)
  tick_results.dig(:tick_meta, :mode) || :unknown
end

.extract_prediction(tick_results) ⇒ Object 



139
140
141
142
143
144
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 139

def extract_prediction(tick_results)
  prediction = tick_results[:prediction_engine]
  return nil unless prediction.is_a?(Hash)

  { confidence: prediction[:confidence], mode: prediction[:mode] }
end

.health_label(score) ⇒ Object 



146
147
148
149
150
151
152
153
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 146

def health_label(score)
  return :unknown unless score.is_a?(Numeric)

  Constants::HEALTH_LABELS.each do |range, label|
    return label if range.include?(score)
  end
  :unknown
end

.map_capabilities(loaded_map) ⇒ Object 



46
47
48
49
50
51
52
53
54
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 46

def map_capabilities(loaded_map)
  active = loaded_map.select { |_, v| v[:loaded] }
  grouped = active.keys.group_by { |ext| Constants::EXTENSION_CAPABILITIES[ext] || :unknown }

  Constants::CAPABILITY_CATEGORIES.to_h do |cat|
    extensions = grouped[cat] || []
    [cat, { active: extensions.size.positive?, extensions: extensions }]
  end
end

.normalize_subsystem_state(state) ⇒ Object 



86
87
88
89
90
 
# File 'lib/legion/extensions/agentic/self/metacognition/helpers/self_model.rb', line 86

def normalize_subsystem_state(state)
  return { status: :unknown } unless state.is_a?(Hash)

  state.slice(:health, :status, :mode, :count, :active_count, :score)
end