Module: Legion::Extensions::Agentic::Executive::FlexibilityTraining::Runners::CognitiveFlexibilityTraining

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

Instance Method Summary collapse

Instance Method Details

#average_switch_cost(window: 50, engine: nil) ⇒ Object 



59
60
61
62
63
64
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 59

def average_switch_cost(window: 50, engine: nil, **)
  eng  = engine || flexibility_engine
  cost = eng.average_switch_cost(window: window)
  Legion::Logging.debug "[cft] average_switch_cost=#{cost.round(2)} window=#{window}"
  { success: true, average_switch_cost: cost, label: Helpers::Constants.label_for(cost, Helpers::Constants::SWITCH_COST_LABELS) }
end

#easiest_switches(limit: 5, engine: nil) ⇒ Object 



94
95
96
97
98
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 94

def easiest_switches(limit: 5, engine: nil, **)
  eng     = engine || flexibility_engine
  results = eng.easiest_switches(limit: limit)
  { success: true, switches: results, count: results.size }
end

#end_training_session(engine: nil) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 47

def end_training_session(engine: nil, **)
  eng     = engine || flexibility_engine
  session = eng.end_session

  if session
    Legion::Logging.debug "[cft] training session ended trial_count=#{session.size}"
    { success: true, status: :session_ended, trial_count: session.size }
  else
    { success: false, reason: :no_active_session }
  end
end

#flexibility_score(engine: nil) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 73

def flexibility_score(engine: nil, **)
  eng   = engine || flexibility_engine
  score = eng.flexibility_score
  Legion::Logging.debug "[cft] flexibility_score=#{score.round(2)}"
  { success: true, flexibility_score: score,
    label: Helpers::Constants.label_for(score, Helpers::Constants::FLEXIBILITY_LABELS) }
end

#get_task(task_id:, engine: nil) ⇒ Object 



112
113
114
115
116
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 112

def get_task(task_id:, engine: nil, **)
  eng  = engine || flexibility_engine
  task = eng.tasks[task_id]
  task ? { success: true, task: task.to_h } : { success: false, reason: :not_found }
end

#hardest_switches(limit: 5, engine: nil) ⇒ Object 



88
89
90
91
92
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 88

def hardest_switches(limit: 5, engine: nil, **)
  eng     = engine || flexibility_engine
  results = eng.hardest_switches(limit: limit)
  { success: true, switches: results, count: results.size }
end

#improvement_rate(engine: nil) ⇒ Object 



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

def improvement_rate(engine: nil, **)
  eng  = engine || flexibility_engine
  rate = eng.improvement_rate
  Legion::Logging.debug "[cft] improvement_rate=#{rate.round(2)}"
  { success: true, improvement_rate: rate }
end

#list_tasks(engine: nil) ⇒ Object 



107
108
109
110
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 107

def list_tasks(engine: nil, **)
  eng = engine || flexibility_engine
  { success: true, tasks: eng.tasks.values.map(&:to_h), count: eng.tasks.size }
end

#list_trials(engine: nil) ⇒ Object 



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

def list_trials(engine: nil, **)
  eng = engine || flexibility_engine
  { success: true, trials: eng.trials.map(&:to_h), count: eng.trials.size }
end

#perform_switch(from_task_id:, to_task_id:, engine: nil) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 26

def perform_switch(from_task_id:, to_task_id:, engine: nil, **)
  eng    = engine || flexibility_engine
  result = eng.perform_switch(from_task_id: from_task_id, to_task_id: to_task_id)

  if result.is_a?(Helpers::SwitchTrial)
    Legion::Logging.debug "[cft] switch trial cost=#{result.switch_cost.round(2)} " \
                          "accuracy=#{result.accuracy.round(2)} label=#{result.switch_cost_label}"
    { success: true, trial: result.to_h }
  else
    Legion::Logging.warn "[cft] perform_switch failed: #{result[:error]}"
    { success: false }.merge(result)
  end
end

#register_task(name:, domain:, difficulty: 0.5, engine: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 13

def register_task(name:, domain:, difficulty: 0.5, engine: nil, **)
  eng    = engine || flexibility_engine
  result = eng.register_task(name: name, domain: domain, difficulty: difficulty)

  if result.is_a?(Helpers::TrainingTask)
    Legion::Logging.debug "[cft] registered task name=#{name} domain=#{domain} difficulty=#{difficulty}"
    { success: true, task: result.to_h }
  else
    Legion::Logging.warn "[cft] register_task failed: #{result[:error]}"
    { success: false }.merge(result)
  end
end

#start_training_session(engine: nil) ⇒ Object 



40
41
42
43
44
45
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 40

def start_training_session(engine: nil, **)
  eng = engine || flexibility_engine
  eng.start_session
  Legion::Logging.debug '[cft] training session started'
  { success: true, status: :session_started }
end

#switch_cost_between(from_task_id:, to_task_id:, engine: nil) ⇒ Object 



66
67
68
69
70
71
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 66

def switch_cost_between(from_task_id:, to_task_id:, engine: nil, **)
  eng  = engine || flexibility_engine
  cost = eng.switch_cost_between(from_id: from_task_id, to_id: to_task_id)
  { success: true, from_task_id: from_task_id, to_task_id: to_task_id,
    average_switch_cost: cost, label: Helpers::Constants.label_for(cost, Helpers::Constants::SWITCH_COST_LABELS) }
end

#training_report(engine: nil) ⇒ Object 



100
101
102
103
104
105
 
# File 'lib/legion/extensions/agentic/executive/flexibility_training/runners/cognitive_flexibility_training.rb', line 100

def training_report(engine: nil, **)
  eng    = engine || flexibility_engine
  report = eng.training_report
  Legion::Logging.debug "[cft] training_report flexibility=#{report[:flexibility_score]&.round(2)}"
  { success: true, report: report }
end