Module: Legion::Extensions::Agentic::Affect::Resonance::Runners::CognitiveResonance

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb

Instance Method Summary collapse

Instance Method Details

#adjust_vigilance(amount:, engine: nil) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 47

def adjust_vigilance(amount:, engine: nil, **)
  resonance_engine = engine || default_engine
  clamped_amount   = amount.to_f.clamp(-1.0, 1.0)
  new_vigilance    = resonance_engine.adjust_vigilance(amount: clamped_amount)
  vigilance_label  = Helpers::Constants.vigilance_label(new_vigilance)

  log.debug("[cognitive_resonance] vigilance=#{new_vigilance.round(3)} label=#{vigilance_label}")
  {
    success:         true,
    vigilance:       new_vigilance,
    vigilance_label: vigilance_label,
    adjustment:      clamped_amount
  }
end

#category_count(engine: nil) ⇒ Object 



70
71
72
73
74
75
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 70

def category_count(engine: nil, **)
  resonance_engine = engine || default_engine
  count = resonance_engine.category_count
  log.debug("[cognitive_resonance] category_count=#{count}")
  { success: true, count: count }
end

#classify(input:, engine: nil) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 23

def classify(input:, engine: nil, **)
  resonance_engine = engine || default_engine
  return { success: false, error: :empty_input } if input.nil? || input.empty?

  normalized = input.map { |v| v.to_f.clamp(0.0, 1.0) }
  match = resonance_engine.best_match(normalized)

  if match
    quality_label = Helpers::Constants.match_label(match[:quality])
    log.debug("[cognitive_resonance] classify category=#{match[:id][0..7]} " \
              "quality=#{match[:quality].round(3)} label=#{quality_label}")
    {
      success:     true,
      found:       true,
      category_id: match[:id],
      quality:     match[:quality],
      label:       quality_label
    }
  else
    log.debug('[cognitive_resonance] classify found=false (no categories)')
    { success: true, found: false, category_id: nil, quality: 0.0, label: :none }
  end
end

#present_input(input:, engine: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 13

def present_input(input:, engine: nil, **)
  resonance_engine = engine || default_engine
  return { success: false, error: :empty_input } if input.nil? || input.empty?

  result = resonance_engine.present_input(input: input)
  log.debug("[cognitive_resonance] present_input outcome=#{result[:outcome]} " \
            "category=#{result[:category_id][0..7]}")
  { success: true }.merge(result)
end

#reset_engine ⇒ Object 



77
78
79
80
81
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 77

def reset_engine(**)
  @default_engine = nil
  log.debug('[cognitive_resonance] engine reset')
  { success: true, reset: true }
end

#resonance_report(engine: nil) ⇒ Object 



62
63
64
65
66
67
68
 
# File 'lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb', line 62

def resonance_report(engine: nil, **)
  resonance_engine = engine || default_engine
  report = resonance_engine.resonance_report
  log.debug("[cognitive_resonance] report categories=#{report[:category_count]} " \
            "vigilance=#{report[:vigilance].round(3)}")
  { success: true }.merge(report)
end