lex-cognitive-flexibility-training 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98e8996718c4d5c31b8cdb2661bdd30aa5e96eb600819f40486a2f3c5113fe5c
+  data.tar.gz: 6d17b53b34d6f6de2db677c277ba0fdcbef55fe71387ad3351f1a2231c1df46c
+SHA512:
+  metadata.gz: 17990736352966d80c2eff0c13513c5b5bbbe3de945529427ea01e94d0c13d907fd14fde319ff42f55a47ab021a62dc66197c07f7bbed7523a71dfb01e1dff12
+  data.tar.gz: f5d7c7bf3201b1f8ed7f5060e716640e37dc1c63f8e5fe1ed1d1c207b02b2eaf3547298ec127c3dc702ff4db397b694751f3752b62ed8f90b5d930dc4f805483

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.75', require: false
+gem 'rubocop-rspec', require: false
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Esity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# lex-cognitive-flexibility-training
+
+Structured cognitive flexibility training with switch cost measurement for brain-modeled agentic AI in the LegionIO ecosystem.
+
+## What It Does
+
+Measures and reduces the cost of switching between cognitive tasks through deliberate practice. Tasks are registered with a domain and difficulty level. Switch trials between task pairs compute a cost based on domain compatibility, difficulty gap, accumulated practice, and fatigue. Over many trials, improvement rate tracks whether switch costs are declining. Sessions group trials for structured training runs.
+
+## Usage
+
+```ruby
+require 'legion/extensions/cognitive_flexibility_training'
+
+client = Legion::Extensions::CognitiveFlexibilityTraining::Client.new
+
+# Register tasks to train on
+r1 = client.register_task(name: 'categorize_inputs', domain: :logical, difficulty: 0.4)
+r2 = client.register_task(name: 'generate_responses', domain: :creative, difficulty: 0.6)
+task_a = r1[:task][:id]
+task_b = r2[:task][:id]
+
+# Start a training session
+client.start_training_session
+
+# Run switch trials
+client.perform_switch(from_task_id: task_a, to_task_id: task_b)
+client.perform_switch(from_task_id: task_b, to_task_id: task_a)
+
+# End session
+client.end_training_session
+# => { success: true, status: :session_ended, trial_count: 2 }
+
+# Check improvement
+client.flexibility_score
+# => { success: true, flexibility_score: 0.72, label: :flexible }
+
+client.improvement_rate
+# => { success: true, improvement_rate: 0.0 }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-flexibility-training.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_flexibility_training/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-flexibility-training'
+  spec.version       = Legion::Extensions::CognitiveFlexibilityTraining::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Flexibility Training'
+  spec.description   = 'Active improvement of task-switching ability through deliberate practice for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-flexibility-training'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = 'https://github.com/LegionIO/lex-cognitive-flexibility-training'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-cognitive-flexibility-training'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-cognitive-flexibility-training'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-cognitive-flexibility-training/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-cognitive-flexibility-training.gemspec Gemfile LICENSE README.md]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/cognitive_flexibility_training/client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_flexibility_training/helpers/constants'
+require 'legion/extensions/cognitive_flexibility_training/helpers/training_task'
+require 'legion/extensions/cognitive_flexibility_training/helpers/switch_trial'
+require 'legion/extensions/cognitive_flexibility_training/helpers/flexibility_engine'
+require 'legion/extensions/cognitive_flexibility_training/runners/cognitive_flexibility_training'
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      class Client
+        include Runners::CognitiveFlexibilityTraining
+
+        def initialize(engine: nil, **)
+          @flexibility_engine = engine || Helpers::FlexibilityEngine.new
+        end
+
+        private
+
+        attr_reader :flexibility_engine
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/helpers/constants.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      module Helpers
+        module Constants
+          MAX_TASKS    = 100
+          MAX_TRIALS   = 1000
+          MAX_SESSIONS = 50
+
+          DEFAULT_SWITCH_COST = 0.3
+          IMPROVEMENT_RATE    = 0.02
+          FATIGUE_RATE        = 0.01
+
+          DIFFICULTY_LEVELS = %i[trivial easy moderate hard extreme].freeze
+          TASK_DOMAINS      = %i[linguistic spatial numerical logical emotional social creative].freeze
+
+          SWITCH_COST_LABELS = {
+            (0.8..)     => :severe,
+            (0.6...0.8) => :high,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :low,
+            (..0.2)     => :minimal
+          }.freeze
+
+          FLEXIBILITY_LABELS = {
+            (0.8..)     => :highly_flexible,
+            (0.6...0.8) => :flexible,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :rigid,
+            (..0.2)     => :inflexible
+          }.freeze
+
+          PROGRESS_LABELS = {
+            (0.8..)     => :mastered,
+            (0.6...0.8) => :proficient,
+            (0.4...0.6) => :developing,
+            (0.2...0.4) => :novice,
+            (..0.2)     => :beginner
+          }.freeze
+
+          module_function
+
+          def label_for(value, label_map)
+            label_map.each { |range, label| return label if range.cover?(value) }
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/helpers/flexibility_engine.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      module Helpers
+        class FlexibilityEngine
+          attr_reader :tasks, :trials, :sessions
+
+          def initialize
+            @tasks           = {}
+            @trials          = []
+            @sessions        = []
+            @current_session = nil
+          end
+
+          def register_task(name:, domain:, difficulty: 0.5)
+            return { error: :max_tasks_reached } if @tasks.size >= Constants::MAX_TASKS
+            return { error: :invalid_domain } unless Constants::TASK_DOMAINS.include?(domain)
+
+            task = TrainingTask.new(name: name, domain: domain, difficulty: difficulty)
+            @tasks[task.id] = task
+            task
+          end
+
+          def perform_switch(from_task_id:, to_task_id:)
+            return { error: :max_trials_reached } if @trials.size >= Constants::MAX_TRIALS
+
+            from_task = @tasks[from_task_id]
+            to_task   = @tasks[to_task_id]
+
+            return { error: :task_not_found, missing: :from } unless from_task
+            return { error: :task_not_found, missing: :to }   unless to_task
+
+            cost     = compute_switch_cost(from_task, to_task)
+            accuracy = compute_accuracy(to_task, cost)
+
+            trial = SwitchTrial.new(
+              from_task_id: from_task_id,
+              to_task_id:   to_task_id,
+              switch_cost:  cost,
+              accuracy:     accuracy
+            )
+
+            @trials << trial
+            @current_session << trial if @current_session
+
+            from_task.practice!
+            to_task.practice!
+
+            trial
+          end
+
+          def start_session
+            @current_session = []
+            self
+          end
+
+          def end_session
+            return nil unless @current_session
+
+            session = @current_session.dup
+            @sessions << session
+            @sessions.shift while @sessions.size > Constants::MAX_SESSIONS
+            @current_session = nil
+            session
+          end
+
+          def average_switch_cost(window: 50)
+            recent = @trials.last(window)
+            return 0.0 if recent.empty?
+
+            (recent.sum(&:switch_cost) / recent.size).round(10)
+          end
+
+          def switch_cost_between(from_id:, to_id:)
+            pair_trials = @trials.select { |t| t.from_task_id == from_id && t.to_task_id == to_id }
+            return 0.0 if pair_trials.empty?
+
+            (pair_trials.sum(&:switch_cost) / pair_trials.size).round(10)
+          end
+
+          def improvement_rate
+            return 0.0 if @trials.size < 4
+
+            half   = @trials.size / 2
+            early  = @trials.first(half)
+            recent = @trials.last(half)
+
+            early_avg  = early.sum(&:switch_cost) / early.size.to_f
+            recent_avg = recent.sum(&:switch_cost) / recent.size.to_f
+
+            ((early_avg - recent_avg) / early_avg.clamp(0.001, 1.0)).round(10)
+          end
+
+          def flexibility_score
+            (1.0 - average_switch_cost).round(10)
+          end
+
+          def hardest_switches(limit: 5)
+            pair_averages.sort_by { |_, cost| -cost }.first(limit).map do |pair, cost|
+              { from_task_id: pair[0], to_task_id: pair[1], average_switch_cost: cost.round(10) }
+            end
+          end
+
+          def easiest_switches(limit: 5)
+            pair_averages.sort_by { |_, cost| cost }.first(limit).map do |pair, cost|
+              { from_task_id: pair[0], to_task_id: pair[1], average_switch_cost: cost.round(10) }
+            end
+          end
+
+          def training_report
+            {
+              task_count:             @tasks.size,
+              trial_count:            @trials.size,
+              session_count:          @sessions.size,
+              average_switch_cost:    average_switch_cost,
+              flexibility_score:      flexibility_score,
+              improvement_rate:       improvement_rate,
+              flexibility_label:      Constants.label_for(flexibility_score, Constants::FLEXIBILITY_LABELS),
+              progress_label:         Constants.label_for(1.0 - average_switch_cost, Constants::PROGRESS_LABELS),
+              costly_trial_ratio:     costly_ratio,
+              successful_trial_ratio: success_ratio
+            }
+          end
+
+          def to_h
+            {
+              tasks:    @tasks.transform_values(&:to_h),
+              trials:   @trials.map(&:to_h),
+              sessions: @sessions.map { |s| s.map(&:to_h) },
+              report:   training_report
+            }
+          end
+
+          private
+
+          def compute_switch_cost(from_task, to_task)
+            domain_penalty    = from_task.domain == to_task.domain ? 0.0 : 0.2
+            difficulty_gap    = (to_task.difficulty - from_task.difficulty).abs * 0.3
+            practice_discount = [from_task.practice_count * 0.005, 0.15].min
+            fatigue_penalty   = [@trials.size * Constants::FATIGUE_RATE * 0.01, 0.1].min
+
+            raw = Constants::DEFAULT_SWITCH_COST + domain_penalty + difficulty_gap - practice_discount + fatigue_penalty
+            raw.clamp(0.0, 1.0).round(10)
+          end
+
+          def compute_accuracy(to_task, switch_cost)
+            base     = to_task.baseline_performance
+            penalty  = switch_cost * 0.4
+            (base - penalty).clamp(0.0, 1.0).round(10)
+          end
+
+          def pair_averages
+            grouped = @trials.group_by { |t| [t.from_task_id, t.to_task_id] }
+            grouped.transform_values { |ts| ts.sum(&:switch_cost) / ts.size.to_f }
+          end
+
+          def costly_ratio
+            return 0.0 if @trials.empty?
+
+            (@trials.count(&:costly?).to_f / @trials.size).round(10)
+          end
+
+          def success_ratio
+            return 0.0 if @trials.empty?
+
+            (@trials.count(&:successful?).to_f / @trials.size).round(10)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/helpers/switch_trial.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      module Helpers
+        class SwitchTrial
+          attr_reader :id, :from_task_id, :to_task_id, :switch_cost, :accuracy, :created_at
+
+          def initialize(from_task_id:, to_task_id:, switch_cost:, accuracy:)
+            @id           = SecureRandom.uuid
+            @from_task_id = from_task_id
+            @to_task_id   = to_task_id
+            @switch_cost  = switch_cost.clamp(0.0, 1.0).round(10)
+            @accuracy     = accuracy.clamp(0.0, 1.0).round(10)
+            @created_at   = Time.now.utc
+          end
+
+          def costly?
+            @switch_cost > 0.5
+          end
+
+          def successful?
+            @accuracy > 0.7
+          end
+
+          def switch_cost_label
+            Constants.label_for(@switch_cost, Constants::SWITCH_COST_LABELS)
+          end
+
+          def to_h
+            {
+              id:                @id,
+              from_task_id:      @from_task_id,
+              to_task_id:        @to_task_id,
+              switch_cost:       @switch_cost,
+              accuracy:          @accuracy,
+              costly:            costly?,
+              successful:        successful?,
+              switch_cost_label: switch_cost_label,
+              created_at:        @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/helpers/training_task.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      module Helpers
+        class TrainingTask
+          attr_reader :id, :name, :domain, :difficulty, :baseline_performance, :practice_count, :created_at
+
+          def initialize(name:, domain:, difficulty:)
+            @id                   = SecureRandom.uuid
+            @name                 = name
+            @domain               = domain
+            @difficulty           = difficulty.clamp(0.0, 1.0).round(10)
+            @baseline_performance = (1.0 - (@difficulty * 0.4)).clamp(0.0, 1.0).round(10)
+            @practice_count       = 0
+            @created_at           = Time.now.utc
+          end
+
+          def practice!
+            @practice_count += 1
+            improvement = (Constants::IMPROVEMENT_RATE / (1.0 + (@practice_count * 0.1))).round(10)
+            @baseline_performance = [(@baseline_performance + improvement), 1.0].min.round(10)
+            self
+          end
+
+          def difficulty_label
+            index = (@difficulty * (Constants::DIFFICULTY_LEVELS.size - 1)).round
+            Constants::DIFFICULTY_LEVELS[index]
+          end
+
+          def to_h
+            {
+              id:                   @id,
+              name:                 @name,
+              domain:               @domain,
+              difficulty:           @difficulty,
+              baseline_performance: @baseline_performance,
+              practice_count:       @practice_count,
+              difficulty_label:     difficulty_label,
+              created_at:           @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/runners/cognitive_flexibility_training.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      module Runners
+        module CognitiveFlexibilityTraining
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          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
+
+          def list_tasks(engine: nil, **)
+            eng = engine || flexibility_engine
+            { success: true, tasks: eng.tasks.values.map(&:to_h), count: eng.tasks.size }
+          end
+
+          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
+
+          def list_trials(engine: nil, **)
+            eng = engine || flexibility_engine
+            { success: true, trials: eng.trials.map(&:to_h), count: eng.trials.size }
+          end
+
+          private
+
+          def flexibility_engine
+            @flexibility_engine ||= Helpers::FlexibilityEngine.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/cognitive_flexibility_training.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_flexibility_training/version'
+require 'legion/extensions/cognitive_flexibility_training/helpers/constants'
+require 'legion/extensions/cognitive_flexibility_training/helpers/training_task'
+require 'legion/extensions/cognitive_flexibility_training/helpers/switch_trial'
+require 'legion/extensions/cognitive_flexibility_training/helpers/flexibility_engine'
+require 'legion/extensions/cognitive_flexibility_training/runners/cognitive_flexibility_training'
+
+module Legion
+  module Extensions
+    module CognitiveFlexibilityTraining
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

data/spec/legion/extensions/cognitive_flexibility_training/client_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_flexibility_training/client'
+
+RSpec.describe Legion::Extensions::CognitiveFlexibilityTraining::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:register_task)
+    expect(client).to respond_to(:perform_switch)
+    expect(client).to respond_to(:start_training_session)
+    expect(client).to respond_to(:end_training_session)
+    expect(client).to respond_to(:average_switch_cost)
+    expect(client).to respond_to(:switch_cost_between)
+    expect(client).to respond_to(:flexibility_score)
+    expect(client).to respond_to(:improvement_rate)
+    expect(client).to respond_to(:hardest_switches)
+    expect(client).to respond_to(:easiest_switches)
+    expect(client).to respond_to(:training_report)
+    expect(client).to respond_to(:list_tasks)
+    expect(client).to respond_to(:get_task)
+    expect(client).to respond_to(:list_trials)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::CognitiveFlexibilityTraining::Helpers::FlexibilityEngine.new
+    client = described_class.new(engine: engine)
+    result = client.register_task(name: 'Test', domain: :logical, difficulty: 0.5, engine: engine)
+    expect(result[:success]).to be true
+    expect(engine.tasks.size).to eq(1)
+  end
+
+  it 'creates its own engine when none injected' do
+    client1 = described_class.new
+    client2 = described_class.new
+    client1.register_task(name: 'T1', domain: :logical, difficulty: 0.2)
+    result = client2.list_tasks
+    expect(result[:count]).to eq(0)
+  end
+end