Class: Legion::Extensions::Agentic::Self::SelfModel::Helpers::SelfModel

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb

Constant Summary

Constants included from Constants

Constants::CALIBRATION_ALPHA, Constants::CALIBRATION_LABELS, Constants::CAPABILITY_STATES, Constants::COMPETENCE_CEILING, Constants::COMPETENCE_FLOOR, Constants::CONFIDENCE_LABELS, Constants::DEFAULT_COMPETENCE, Constants::KNOWLEDGE_STATES, Constants::MAX_CAPABILITIES, Constants::MAX_HISTORY, Constants::MAX_KNOWLEDGE_DOMAINS, Constants::OVERCONFIDENCE_THRESHOLD, Constants::UNDERCONFIDENCE_THRESHOLD

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ SelfModel

Returns a new instance of SelfModel.



14
15
16
17
18
19
20
21
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 14

def initialize
  @capabilities      = {}
  @knowledge_domains = {}
  @predictions       = []
  @history           = []
  @cap_counter       = 0
  @dom_counter       = 0
end

Instance Attribute Details

#capabilities ⇒ Object (readonly)

Returns the value of attribute capabilities.



12
13
14
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 12

def capabilities
  @capabilities
end

#history ⇒ Object (readonly)

Returns the value of attribute history.



12
13
14
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 12

def history
  @history
end

#knowledge_domains ⇒ Object (readonly)

Returns the value of attribute knowledge_domains.



12
13
14
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 12

def knowledge_domains
  @knowledge_domains
end

#predictions ⇒ Object (readonly)

Returns the value of attribute predictions.



12
13
14
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 12

def predictions
  @predictions
end

Instance Method Details

#add_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE) ⇒ Object 



23
24
25
26
27
28
29
30
31
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 23

def add_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE)
  return nil if @capabilities.size >= MAX_CAPABILITIES

  @cap_counter += 1
  cap_id = :"cap_#{@cap_counter}"
  cap = Capability.new(id: cap_id, name: name, domain: domain, competence: competence)
  @capabilities[cap_id] = cap
  cap
end

#add_knowledge_domain(name:, depth: 0.0, breadth: 0.0) ⇒ Object 



33
34
35
36
37
38
39
40
41
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 33

def add_knowledge_domain(name:, depth: 0.0, breadth: 0.0)
  return nil if @knowledge_domains.size >= MAX_KNOWLEDGE_DOMAINS

  @dom_counter += 1
  dom_id = :"dom_#{@dom_counter}"
  dom = KnowledgeDomain.new(id: dom_id, name: name, depth: depth, breadth: breadth)
  @knowledge_domains[dom_id] = dom
  dom
end

#blind_spots ⇒ Object 



85
86
87
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 85

def blind_spots
  @capabilities.values.select(&:overconfident?)
end

#calibration_report ⇒ Object 



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

def calibration_report
  caps = @capabilities.values
  return { label: :uncalibrated, mean_error: 0.0, calibrated_count: 0, total: 0 } if caps.empty?

  errors = caps.map { |c| c.calibration_error.abs }
  mean_error = errors.sum / errors.size.to_f
  calibrated_count = caps.count(&:calibrated?)

  label = CALIBRATION_LABELS.each do |lbl, threshold|
    break lbl if mean_error <= threshold
  end
  label = :uncalibrated unless label.is_a?(Symbol)

  { label: label, mean_error: mean_error.round(4), calibrated_count: calibrated_count,
    total: caps.size }
end

#can_do?(capability_name) ⇒ Boolean

Returns:

  • (Boolean) 


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

def can_do?(capability_name)
  cap = @capabilities.values.find { |c| c.name == capability_name }
  return false unless cap

  cap.competence >= 0.5
end

#introspect ⇒ Object 



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

def introspect
  {
    overall_confidence: overall_confidence.round(4),
    strengths:          strengths.map(&:to_h),
    weaknesses:         weaknesses.map(&:to_h),
    blind_spots:        blind_spots.map(&:to_h),
    knowledge_gaps:     knowledge_gaps.map(&:to_h),
    calibration:        calibration_report
  }
end

#knowledge_gaps ⇒ Object 



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

def knowledge_gaps
  @knowledge_domains.values.select { |d| d.depth < 0.3 }
end

#knows_about?(domain_name) ⇒ Boolean

Returns:

  • (Boolean) 


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

def knows_about?(domain_name)
  dom = @knowledge_domains.values.find { |d| d.name == domain_name }
  return false unless dom

  dom.confidence >= 0.5
end

#overall_confidence ⇒ Object 



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

def overall_confidence
  return DEFAULT_COMPETENCE if @capabilities.empty?

  total = @capabilities.values.sum(&:competence)
  total / @capabilities.size.to_f
end

#predict_success(capability_id:) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 43

def predict_success(capability_id:)
  cap = @capabilities[capability_id]
  return nil unless cap

  prediction = { capability_id: capability_id, predicted_probability: cap.competence.round(4),
                 at: Time.now.utc }
  @predictions << prediction
  @predictions.shift while @predictions.size > MAX_HISTORY
  prediction
end

#record_outcome(capability_id:, predicted:, actual:) ⇒ Object 



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

def record_outcome(capability_id:, predicted:, actual:)
  cap = @capabilities[capability_id]
  return nil unless cap

  cap.record_attempt(predicted_success: predicted, actual_success: actual)
  event = { type: :outcome, capability_id: capability_id, predicted: predicted,
            actual: actual, at: Time.now.utc }
  @history << event
  @history.shift while @history.size > MAX_HISTORY
  event
end

#strengths ⇒ Object 



77
78
79
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 77

def strengths
  @capabilities.values.select { |c| c.competence > 0.7 }
end

#to_h ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 131

def to_h
  {
    capability_count:       @capabilities.size,
    knowledge_domain_count: @knowledge_domains.size,
    overall_confidence:     overall_confidence.round(4),
    strength_count:         strengths.size,
    weakness_count:         weaknesses.size,
    blind_spot_count:       blind_spots.size,
    knowledge_gap_count:    knowledge_gaps.size,
    prediction_count:       @predictions.size,
    history_size:           @history.size
  }
end

#weaknesses ⇒ Object 



81
82
83
 
# File 'lib/legion/extensions/agentic/self/self_model/helpers/self_model.rb', line 81

def weaknesses
  @capabilities.values.select { |c| c.competence < 0.3 }
end