lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/procedural/runners/procedural_learning_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Procedural::Runners::ProceduralLearning do
+  let(:runner_host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#create_skill' do
+    it 'creates a skill' do
+      result = runner_host.create_skill(name: 'api_retry', domain: :http)
+      expect(result[:success]).to be true
+      expect(result[:skill_id]).to be_a(String)
+    end
+  end
+
+  describe '#add_skill_production' do
+    it 'adds a production to a skill' do
+      created = runner_host.create_skill(name: 'test', domain: :test)
+      result = runner_host.add_skill_production(
+        skill_id: created[:skill_id], condition: 'if_error',
+        action: 'retry', domain: :test
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#practice_skill' do
+    it 'increases proficiency' do
+      created = runner_host.create_skill(name: 'test', domain: :test)
+      result = runner_host.practice_skill(skill_id: created[:skill_id], success: true)
+      expect(result[:success]).to be true
+      expect(result[:proficiency]).to be > 0.1
+    end
+  end
+
+  describe '#execute_production' do
+    it 'executes a production' do
+      created = runner_host.create_skill(name: 'test', domain: :test)
+      prod = runner_host.add_skill_production(
+        skill_id: created[:skill_id], condition: 'test',
+        action: 'act', domain: :test
+      )
+      result = runner_host.execute_production(production_id: prod[:production_id], success: true)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#skill_assessment' do
+    it 'returns skill assessment' do
+      created = runner_host.create_skill(name: 'test', domain: :test)
+      result = runner_host.skill_assessment(skill_id: created[:skill_id])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#compiled_skills' do
+    it 'returns compiled skills' do
+      result = runner_host.compiled_skills
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#autonomous_skills' do
+    it 'returns autonomous skills' do
+      result = runner_host.autonomous_skills
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#most_practiced_skills' do
+    it 'returns most practiced skills' do
+      result = runner_host.most_practiced_skills(limit: 3)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#update_procedural_learning' do
+    it 'runs decay and prune cycle' do
+      result = runner_host.update_procedural_learning
+      expect(result[:success]).to be true
+      expect(result).to include(:pruned)
+    end
+  end
+
+  describe '#procedural_learning_stats' do
+    it 'returns stats' do
+      result = runner_host.procedural_learning_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_skills, :total_productions)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/scaffolding/client_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/scaffolding/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Scaffolding::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:create_scaffold)
+    expect(client).to respond_to(:attempt_scaffolded_task)
+    expect(client).to respond_to(:recommend_scaffolded_task)
+    expect(client).to respond_to(:mastered_scaffolded_skills)
+    expect(client).to respond_to(:zpd_skills)
+    expect(client).to respond_to(:domain_scaffolds)
+    expect(client).to respond_to(:adjust_scaffold_support)
+    expect(client).to respond_to(:overall_scaffolded_competence)
+    expect(client).to respond_to(:update_cognitive_scaffolding)
+    expect(client).to respond_to(:cognitive_scaffolding_stats)
+  end
+end

data/spec/legion/extensions/agentic/learning/scaffolding/helpers/constants_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Constants do
+  let(:constants) { described_class }
+
+  it 'defines SUPPORT_LEVELS as frozen array of symbols' do
+    expect(constants::SUPPORT_LEVELS).to eq(%i[full guided prompted independent])
+    expect(constants::SUPPORT_LEVELS).to be_frozen
+  end
+
+  it 'defines ZONE_LABELS covering 0..1 range' do
+    all_covered = [0.0, 0.1, 0.3, 0.5, 0.85, 1.0].all? do |val|
+      constants::ZONE_LABELS.any? { |range, _| range.cover?(val) }
+    end
+    expect(all_covered).to be true
+  end
+
+  it 'defines competence bounds' do
+    expect(constants::COMPETENCE_FLOOR).to eq(0.0)
+    expect(constants::COMPETENCE_CEILING).to eq(1.0)
+  end
+
+  it 'defines ZPD bounds within 0..1' do
+    expect(constants::ZPD_LOWER).to be >= 0.0
+    expect(constants::ZPD_UPPER).to be <= 1.0
+    expect(constants::ZPD_LOWER).to be < constants::ZPD_UPPER
+  end
+
+  it 'LEARNING_GAIN > FAILURE_SETBACK' do
+    expect(constants::LEARNING_GAIN).to be > constants::FAILURE_SETBACK
+  end
+
+  it 'MASTERY_THRESHOLD is above ZPD_UPPER' do
+    expect(constants::MASTERY_THRESHOLD).to be >= constants::ZPD_UPPER
+  end
+end

data/spec/legion/extensions/agentic/learning/scaffolding/helpers/scaffold_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Scaffold do
+  let(:constants) { Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Constants }
+
+  subject(:scaffold) { described_class.new(skill_name: 'algebra', domain: :math) }
+
+  describe '#initialize' do
+    it 'assigns an id' do
+      expect(scaffold.id).to be_a(String)
+      expect(scaffold.id).not_to be_empty
+    end
+
+    it 'sets default competence' do
+      expect(scaffold.competence).to eq(constants::DEFAULT_COMPETENCE)
+    end
+
+    it 'sets skill_name and domain' do
+      expect(scaffold.skill_name).to eq('algebra')
+      expect(scaffold.domain).to eq(:math)
+    end
+
+    it 'starts with no practice' do
+      expect(scaffold.practice_count).to eq(0)
+      expect(scaffold.task_history).to be_empty
+    end
+
+    it 'clamps competence to valid range' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: 2.5)
+      expect(s.competence).to eq(1.0)
+    end
+  end
+
+  describe '#current_zone' do
+    it 'returns :zpd for default competence' do
+      expect(scaffold.current_zone).to eq(:zpd)
+    end
+
+    it 'returns :mastered when competence >= MASTERY_THRESHOLD' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: constants::MASTERY_THRESHOLD)
+      expect(s.current_zone).to eq(:mastered)
+    end
+
+    it 'returns :beyond_reach for low competence' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: 0.1)
+      expect(s.current_zone).to eq(:beyond_reach)
+    end
+  end
+
+  describe '#mastered?' do
+    it 'returns false at default competence' do
+      expect(scaffold.mastered?).to be false
+    end
+
+    it 'returns true at mastery threshold' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: constants::MASTERY_THRESHOLD)
+      expect(s.mastered?).to be true
+    end
+  end
+
+  describe '#in_zpd?' do
+    it 'returns true at default competence' do
+      expect(scaffold.in_zpd?).to be true
+    end
+
+    it 'returns false below ZPD_LOWER' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: 0.1)
+      expect(s.in_zpd?).to be false
+    end
+
+    it 'returns false at or above ZPD_UPPER' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: constants::ZPD_UPPER)
+      expect(s.in_zpd?).to be false
+    end
+  end
+
+  describe '#recommended_difficulty' do
+    it 'returns a value above current competence' do
+      expect(scaffold.recommended_difficulty).to be >= scaffold.competence
+    end
+
+    it 'is within valid competence bounds' do
+      expect(scaffold.recommended_difficulty).to be_between(constants::COMPETENCE_FLOOR, constants::COMPETENCE_CEILING)
+    end
+  end
+
+  describe '#attempt_task' do
+    context 'success in ZPD' do
+      it 'increases competence by LEARNING_GAIN' do
+        before = scaffold.competence
+        difficulty = 0.5
+        scaffold.attempt_task(difficulty: difficulty, success: true)
+        expect(scaffold.competence).to be > before
+      end
+    end
+
+    context 'success below ZPD' do
+      it 'increases competence by half LEARNING_GAIN' do
+        s = described_class.new(skill_name: 'x', domain: :test, competence: 0.15)
+        before = s.competence
+        s.attempt_task(difficulty: 0.1, success: true)
+        expect(s.competence - before).to be_within(0.001).of(constants::LEARNING_GAIN / 2.0)
+      end
+    end
+
+    context 'failure' do
+      it 'decreases competence by FAILURE_SETBACK' do
+        before = scaffold.competence
+        scaffold.attempt_task(difficulty: 0.5, success: false)
+        expect(scaffold.competence).to eq((before - constants::FAILURE_SETBACK).clamp(0.0, 1.0))
+      end
+    end
+
+    it 'increments practice_count' do
+      scaffold.attempt_task(difficulty: 0.5, success: true)
+      expect(scaffold.practice_count).to eq(1)
+    end
+
+    it 'records task in history' do
+      scaffold.attempt_task(difficulty: 0.5, success: true)
+      expect(scaffold.task_history.size).to eq(1)
+      expect(scaffold.task_history.last[:success]).to be true
+    end
+
+    it 'clamps competence at COMPETENCE_CEILING' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: 0.99)
+      10.times { s.attempt_task(difficulty: 0.5, success: true) }
+      expect(s.competence).to be <= constants::COMPETENCE_CEILING
+    end
+
+    it 'clamps competence at COMPETENCE_FLOOR' do
+      s = described_class.new(skill_name: 'x', domain: :test, competence: 0.01)
+      10.times { s.attempt_task(difficulty: 0.5, success: false) }
+      expect(s.competence).to be >= constants::COMPETENCE_FLOOR
+    end
+  end
+
+  describe '#fade_support!' do
+    it 'moves toward independent' do
+      scaffold.instance_variable_set(:@support_level, :full)
+      scaffold.fade_support!
+      expect(scaffold.support_level).to eq(:guided)
+    end
+
+    it 'does not go beyond independent' do
+      scaffold.instance_variable_set(:@support_level, :independent)
+      scaffold.fade_support!
+      expect(scaffold.support_level).to eq(:independent)
+    end
+  end
+
+  describe '#increase_support!' do
+    it 'moves toward full' do
+      scaffold.instance_variable_set(:@support_level, :independent)
+      scaffold.increase_support!
+      expect(scaffold.support_level).to eq(:prompted)
+    end
+
+    it 'does not go beyond full' do
+      scaffold.instance_variable_set(:@support_level, :full)
+      scaffold.increase_support!
+      expect(scaffold.support_level).to eq(:full)
+    end
+  end
+
+  describe '#to_h' do
+    it 'contains expected keys' do
+      h = scaffold.to_h
+      expect(h).to have_key(:id)
+      expect(h).to have_key(:skill_name)
+      expect(h).to have_key(:domain)
+      expect(h).to have_key(:competence)
+      expect(h).to have_key(:support_level)
+      expect(h).to have_key(:current_zone)
+      expect(h).to have_key(:practice_count)
+      expect(h).to have_key(:mastered)
+      expect(h).to have_key(:in_zpd)
+    end
+  end
+
+  describe 'task history cap' do
+    it 'does not exceed MAX_HISTORY' do
+      (constants::MAX_HISTORY + 5).times { scaffold.attempt_task(difficulty: 0.5, success: true) }
+      expect(scaffold.task_history.size).to eq(constants::MAX_HISTORY)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/scaffolding/helpers/scaffolding_engine_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::ScaffoldingEngine do
+  let(:engine) { described_class.new }
+  let(:constants) { Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Constants }
+
+  def make_scaffold(skill: 'reading', domain: :language, competence: nil)
+    engine.create_scaffold(skill_name: skill, domain: domain, competence: competence)
+  end
+
+  describe '#create_scaffold' do
+    it 'returns a Scaffold' do
+      scaffold = make_scaffold
+      expect(scaffold).to be_a(Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Scaffold)
+    end
+
+    it 'stores the scaffold' do
+      scaffold = make_scaffold
+      expect(engine.scaffolds[scaffold.id]).to eq(scaffold)
+    end
+
+    it 'uses DEFAULT_COMPETENCE when not provided' do
+      scaffold = make_scaffold
+      expect(scaffold.competence).to eq(constants::DEFAULT_COMPETENCE)
+    end
+
+    it 'accepts custom competence' do
+      scaffold = make_scaffold(competence: 0.7)
+      expect(scaffold.competence).to eq(0.7)
+    end
+  end
+
+  describe '#attempt_scaffolded_task' do
+    it 'returns the scaffold after attempt' do
+      scaffold = make_scaffold
+      result = engine.attempt_scaffolded_task(scaffold_id: scaffold.id, difficulty: 0.5, success: true)
+      expect(result).to be_a(Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Scaffold)
+    end
+
+    it 'returns nil for unknown scaffold_id' do
+      result = engine.attempt_scaffolded_task(scaffold_id: 'nonexistent', difficulty: 0.5, success: true)
+      expect(result).to be_nil
+    end
+
+    it 'updates competence on attempt' do
+      scaffold = make_scaffold
+      before = scaffold.competence
+      engine.attempt_scaffolded_task(scaffold_id: scaffold.id, difficulty: 0.5, success: true)
+      expect(scaffold.competence).not_to eq(before)
+    end
+  end
+
+  describe '#recommend_task' do
+    it 'returns difficulty, support_level, and zone' do
+      scaffold = make_scaffold
+      rec = engine.recommend_task(scaffold_id: scaffold.id)
+      expect(rec).to include(:difficulty, :support_level, :zone)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.recommend_task(scaffold_id: 'unknown')).to be_nil
+    end
+  end
+
+  describe '#mastered_skills' do
+    it 'returns empty when nothing mastered' do
+      make_scaffold
+      expect(engine.mastered_skills).to be_empty
+    end
+
+    it 'returns mastered scaffolds' do
+      make_scaffold(competence: constants::MASTERY_THRESHOLD)
+      expect(engine.mastered_skills.size).to eq(1)
+    end
+  end
+
+  describe '#zpd_skills' do
+    it 'returns scaffolds in ZPD' do
+      make_scaffold
+      expect(engine.zpd_skills.size).to eq(1)
+    end
+
+    it 'does not include mastered scaffolds' do
+      make_scaffold(competence: constants::MASTERY_THRESHOLD)
+      expect(engine.zpd_skills).to be_empty
+    end
+  end
+
+  describe '#by_domain' do
+    it 'filters by domain' do
+      make_scaffold(domain: :math)
+      make_scaffold(domain: :language)
+      expect(engine.by_domain(domain: :math).size).to eq(1)
+    end
+  end
+
+  describe '#adjust_support' do
+    it 'increases support level' do
+      scaffold = make_scaffold
+      scaffold.instance_variable_set(:@support_level, :independent)
+      engine.adjust_support(scaffold_id: scaffold.id, direction: :increase)
+      expect(scaffold.support_level).to eq(:prompted)
+    end
+
+    it 'decreases (fades) support level' do
+      scaffold = make_scaffold
+      scaffold.instance_variable_set(:@support_level, :full)
+      engine.adjust_support(scaffold_id: scaffold.id, direction: :decrease)
+      expect(scaffold.support_level).to eq(:guided)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.adjust_support(scaffold_id: 'x', direction: :increase)).to be_nil
+    end
+  end
+
+  describe '#overall_competence' do
+    it 'returns DEFAULT_COMPETENCE with no scaffolds' do
+      expect(engine.overall_competence).to eq(constants::DEFAULT_COMPETENCE)
+    end
+
+    it 'averages competences' do
+      engine.create_scaffold(skill_name: 'a', domain: :test, competence: 0.4)
+      engine.create_scaffold(skill_name: 'b', domain: :test, competence: 0.6)
+      expect(engine.overall_competence).to be_within(0.001).of(0.5)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns the scaffold count' do
+      2.times { |i| make_scaffold(skill: "s#{i}") }
+      expect(engine.decay_all).to eq(2)
+    end
+
+    it 'reduces competence on non-mastered scaffolds' do
+      scaffold = make_scaffold
+      before = scaffold.competence
+      engine.decay_all
+      expect(scaffold.competence).to be < before
+    end
+
+    it 'does not decay mastered scaffolds' do
+      scaffold = make_scaffold(competence: constants::MASTERY_THRESHOLD)
+      before = scaffold.competence
+      engine.decay_all
+      expect(scaffold.competence).to eq(before)
+    end
+  end
+
+  describe '#to_h' do
+    it 'contains expected stat keys' do
+      h = engine.to_h
+      expect(h).to have_key(:total_scaffolds)
+      expect(h).to have_key(:mastered_count)
+      expect(h).to have_key(:zpd_count)
+      expect(h).to have_key(:overall_competence)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/scaffolding/runners/cognitive_scaffolding_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/scaffolding/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Scaffolding::Runners::CognitiveScaffolding do
+  let(:client) { Legion::Extensions::Agentic::Learning::Scaffolding::Client.new }
+  let(:constants) { Legion::Extensions::Agentic::Learning::Scaffolding::Helpers::Constants }
+
+  def create_scaffold(skill: 'algebra', domain: :math, competence: nil)
+    result = if competence
+               client.create_scaffold(skill_name: skill, domain: domain, competence: competence)
+             else
+               client.create_scaffold(skill_name: skill, domain: domain)
+             end
+    result[:scaffold][:id]
+  end
+
+  describe '#create_scaffold' do
+    it 'returns success with scaffold data' do
+      result = client.create_scaffold(skill_name: 'reading', domain: :language)
+      expect(result[:success]).to be true
+      expect(result[:scaffold]).to include(:id, :skill_name, :domain, :competence)
+    end
+
+    it 'uses DEFAULT_COMPETENCE by default' do
+      result = client.create_scaffold(skill_name: 'reading', domain: :language)
+      expect(result[:scaffold][:competence]).to eq(constants::DEFAULT_COMPETENCE)
+    end
+
+    it 'accepts custom competence' do
+      result = client.create_scaffold(skill_name: 'x', domain: :test, competence: 0.6)
+      expect(result[:scaffold][:competence]).to eq(0.6)
+    end
+  end
+
+  describe '#attempt_scaffolded_task' do
+    it 'returns success for valid scaffold' do
+      sid = create_scaffold
+      result = client.attempt_scaffolded_task(scaffold_id: sid, difficulty: 0.5, success: true)
+      expect(result[:success]).to be true
+      expect(result[:scaffold]).to include(:competence)
+    end
+
+    it 'returns failure for unknown scaffold_id' do
+      result = client.attempt_scaffolded_task(scaffold_id: 'nonexistent', difficulty: 0.5, success: true)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'increases competence on success' do
+      result_create = client.create_scaffold(skill_name: 'y', domain: :test)
+      sid = result_create[:scaffold][:id]
+      before = result_create[:scaffold][:competence]
+      attempt = client.attempt_scaffolded_task(scaffold_id: sid, difficulty: 0.5, success: true)
+      expect(attempt[:scaffold][:competence]).to be > before
+    end
+
+    it 'decreases competence on failure' do
+      result_create = client.create_scaffold(skill_name: 'z', domain: :test)
+      sid = result_create[:scaffold][:id]
+      before = result_create[:scaffold][:competence]
+      attempt = client.attempt_scaffolded_task(scaffold_id: sid, difficulty: 0.5, success: false)
+      expect(attempt[:scaffold][:competence]).to be < before
+    end
+  end
+
+  describe '#recommend_scaffolded_task' do
+    it 'returns recommendation for valid scaffold' do
+      sid = create_scaffold
+      result = client.recommend_scaffolded_task(scaffold_id: sid)
+      expect(result[:success]).to be true
+      expect(result[:recommendation]).to include(:difficulty, :support_level, :zone)
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.recommend_scaffolded_task(scaffold_id: 'bad')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#mastered_scaffolded_skills' do
+    it 'returns empty when none mastered' do
+      create_scaffold
+      result = client.mastered_scaffolded_skills
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns mastered scaffolds' do
+      create_scaffold(competence: constants::MASTERY_THRESHOLD)
+      result = client.mastered_scaffolded_skills
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#zpd_skills' do
+    it 'returns scaffolds in ZPD' do
+      create_scaffold
+      result = client.zpd_skills
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#domain_scaffolds' do
+    it 'filters scaffolds by domain' do
+      create_scaffold(domain: :math)
+      create_scaffold(domain: :language)
+      result = client.domain_scaffolds(domain: :math)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:domain]).to eq(:math)
+    end
+  end
+
+  describe '#adjust_scaffold_support' do
+    it 'adjusts support direction increase' do
+      sid = create_scaffold
+      result = client.adjust_scaffold_support(scaffold_id: sid, direction: :increase)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.adjust_scaffold_support(scaffold_id: 'bad', direction: :increase)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#overall_scaffolded_competence' do
+    it 'returns success with a float' do
+      result = client.overall_scaffolded_competence
+      expect(result[:success]).to be true
+      expect(result[:overall_competence]).to be_a(Float)
+    end
+
+    it 'reflects created scaffolds' do
+      client.create_scaffold(skill_name: 'a', domain: :test, competence: 0.8)
+      result = client.overall_scaffolded_competence
+      expect(result[:overall_competence]).to be > constants::DEFAULT_COMPETENCE
+    end
+  end
+
+  describe '#update_cognitive_scaffolding' do
+    it 'runs decay and returns stats' do
+      create_scaffold
+      result = client.update_cognitive_scaffolding
+      expect(result[:success]).to be true
+      expect(result[:action]).to eq(:decay)
+      expect(result[:scaffold_count]).to eq(1)
+    end
+  end
+
+  describe '#cognitive_scaffolding_stats' do
+    it 'returns stats hash' do
+      create_scaffold
+      result = client.cognitive_scaffolding_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:total_scaffolds, :mastered_count, :zpd_count, :overall_competence)
+    end
+  end
+end