lex-procedural-learning 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: beadefed7bdfbf63394e91a805c43d2fde712ba5f95ec1781f48999e1fb2a0f2
+  data.tar.gz: a5627d0dce87ba20527e1251d2564de55008d2f12b7a378da49f338bcf86ccf3
+SHA512:
+  metadata.gz: de643f276210c3abaedf90f75df2a1b12fff7aaf9a49dbcf89e6a8456ff6c31fd87b4aba8321b8df2e6e4dcb3555e121074eecf367bbbed1c26f5672872e2333
+  data.tar.gz: 062b9255719b45a29a57ba1c0b78a49aa3714f882a89e9908b0a70b32ad8a465c658a22dc71c9fcae7a920a68ce076c72cf88278aa0f8c32eb879055037e7d90

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec'
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/lex-procedural-learning.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/procedural_learning/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-procedural-learning'
+  spec.version       = Legion::Extensions::ProceduralLearning::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Procedural Learning'
+  spec.description   = "Anderson's ACT-R production rules — skill acquisition from declarative " \
+                       'to autonomous for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-procedural-learning'
+  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-procedural-learning'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-procedural-learning'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-procedural-learning'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-procedural-learning/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-procedural-learning.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      class Client
+        include Runners::ProceduralLearning
+
+        def initialize(engine: nil)
+          @engine = engine || Helpers::LearningEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      module Helpers
+        module Constants
+          MAX_SKILLS = 200
+          MAX_PRODUCTIONS = 500
+          MAX_HISTORY = 300
+
+          DEFAULT_PROFICIENCY = 0.1
+          PROFICIENCY_FLOOR = 0.0
+          PROFICIENCY_CEILING = 1.0
+
+          PRACTICE_GAIN = 0.08
+          COMPILATION_THRESHOLD = 0.6
+          AUTOMATION_THRESHOLD = 0.85
+          DECAY_RATE = 0.01
+          STALE_THRESHOLD = 300
+
+          SKILL_STAGES = %i[declarative associative autonomous].freeze
+
+          STAGE_LABELS = {
+            (0.0...0.3)  => :declarative,
+            (0.3...0.6)  => :associative,
+            (0.6...0.85) => :compiled,
+            (0.85..1.0)  => :autonomous
+          }.freeze
+
+          PROFICIENCY_LABELS = {
+            (0.8..)     => :expert,
+            (0.6...0.8) => :proficient,
+            (0.4...0.6) => :intermediate,
+            (0.2...0.4) => :beginner,
+            (..0.2)     => :novice
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/procedural_learning/helpers/learning_engine.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      module Helpers
+        class LearningEngine
+          include Constants
+
+          attr_reader :history
+
+          def initialize
+            @skills      = {}
+            @productions = {}
+            @history     = []
+          end
+
+          def create_skill(name:, domain:)
+            evict_oldest_skill if @skills.size >= MAX_SKILLS
+
+            skill = Skill.new(name: name, domain: domain)
+            @skills[skill.id] = skill
+            record_history(:skill_created, skill.id)
+            skill
+          end
+
+          def add_production(skill_id:, condition:, action:, domain:)
+            skill = @skills[skill_id]
+            return { success: false, reason: :skill_not_found } unless skill
+            return { success: false, reason: :max_productions } if @productions.size >= MAX_PRODUCTIONS
+
+            production = Production.new(
+              condition: condition, action: action,
+              domain: domain, skill_id: skill_id
+            )
+            @productions[production.id] = production
+            skill.add_production(production.id)
+            record_history(:production_added, production.id)
+            production
+          end
+
+          def practice_skill(skill_id:, success:)
+            skill = @skills[skill_id]
+            return { success: false, reason: :not_found } unless skill
+
+            skill.practice!(success: success)
+            record_history(:practiced, skill_id)
+            build_practice_result(skill)
+          end
+
+          def execute_production(production_id:, success:)
+            production = @productions[production_id]
+            return { success: false, reason: :not_found } unless production
+
+            production.execute!(success: success)
+            record_history(:production_executed, production_id)
+            { success: true, production_id: production_id, success_rate: production.success_rate }
+          end
+
+          def skill_assessment(skill_id:)
+            skill = @skills[skill_id]
+            return { success: false, reason: :not_found } unless skill
+
+            productions = skill.productions.filter_map { |pid| @productions[pid] }
+            build_assessment(skill, productions)
+          end
+
+          def compiled_skills
+            @skills.values.select(&:compiled?)
+          end
+
+          def autonomous_skills
+            @skills.values.select(&:autonomous?)
+          end
+
+          def by_domain(domain:)
+            @skills.values.select { |s| s.domain == domain }
+          end
+
+          def most_practiced(limit: 5)
+            @skills.values.sort_by { |s| -s.practice_count }.first(limit)
+          end
+
+          def decay_all
+            @skills.each_value(&:decay!)
+          end
+
+          def prune_stale
+            stale_ids = @skills.select { |_id, s| s.proficiency <= 0.02 }.keys
+            stale_ids.each do |sid|
+              remove_skill_productions(sid)
+              @skills.delete(sid)
+            end
+            stale_ids.size
+          end
+
+          def to_h
+            {
+              total_skills:      @skills.size,
+              total_productions: @productions.size,
+              compiled_count:    compiled_skills.size,
+              autonomous_count:  autonomous_skills.size,
+              history_count:     @history.size,
+              stage_counts:      stage_counts
+            }
+          end
+
+          private
+
+          def build_practice_result(skill)
+            {
+              success:     true,
+              skill_id:    skill.id,
+              proficiency: skill.proficiency,
+              stage:       skill.stage,
+              stage_label: skill.stage_label
+            }
+          end
+
+          def build_assessment(skill, productions)
+            {
+              success:          true,
+              skill:            skill.to_h,
+              productions:      productions.map(&:to_h),
+              reliable_count:   productions.count(&:reliable?),
+              total_executions: productions.sum(&:execution_count)
+            }
+          end
+
+          def remove_skill_productions(skill_id)
+            @productions.delete_if { |_id, prod| prod.skill_id == skill_id }
+          end
+
+          def evict_oldest_skill
+            oldest_id = @skills.min_by { |_id, s| s.last_practiced_at }&.first
+            return unless oldest_id
+
+            remove_skill_productions(oldest_id)
+            @skills.delete(oldest_id)
+          end
+
+          def record_history(event, subject_id)
+            @history << { event: event, subject_id: subject_id, at: Time.now.utc }
+            @history.shift while @history.size > MAX_HISTORY
+          end
+
+          def stage_counts
+            @skills.values.each_with_object(Hash.new(0)) do |skill, counts|
+              counts[skill.stage] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/procedural_learning/helpers/production.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      module Helpers
+        class Production
+          include Constants
+
+          attr_reader :id, :condition, :action, :domain, :skill_id,
+                      :execution_count, :success_count, :created_at, :last_executed_at
+
+          def initialize(condition:, action:, domain:, skill_id:)
+            @id               = SecureRandom.uuid
+            @condition        = condition
+            @action           = action
+            @domain           = domain
+            @skill_id         = skill_id
+            @execution_count  = 0
+            @success_count    = 0
+            @created_at       = Time.now.utc
+            @last_executed_at = @created_at
+          end
+
+          def execute!(success:)
+            @execution_count  += 1
+            @success_count    += 1 if success
+            @last_executed_at  = Time.now.utc
+          end
+
+          def success_rate
+            return 0.0 if @execution_count.zero?
+
+            @success_count.to_f / @execution_count
+          end
+
+          def reliable?
+            success_rate >= 0.7 && @execution_count >= 3
+          end
+
+          def to_h
+            {
+              id:               @id,
+              condition:        @condition,
+              action:           @action,
+              domain:           @domain,
+              skill_id:         @skill_id,
+              execution_count:  @execution_count,
+              success_count:    @success_count,
+              success_rate:     success_rate,
+              reliable:         reliable?,
+              created_at:       @created_at,
+              last_executed_at: @last_executed_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/procedural_learning/helpers/skill.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      module Helpers
+        class Skill
+          include Constants
+
+          attr_reader :id, :name, :domain, :proficiency, :practice_count,
+                      :stage, :productions, :created_at, :last_practiced_at
+
+          def initialize(name:, domain:)
+            @id               = SecureRandom.uuid
+            @name             = name
+            @domain           = domain
+            @proficiency      = DEFAULT_PROFICIENCY
+            @practice_count   = 0
+            @stage            = :declarative
+            @productions      = []
+            @created_at       = Time.now.utc
+            @last_practiced_at = @created_at
+          end
+
+          def practice!(success:)
+            @practice_count    += 1
+            @last_practiced_at  = Time.now.utc
+            gain = success ? PRACTICE_GAIN : PRACTICE_GAIN * 0.3
+            @proficiency = (@proficiency + gain).clamp(PROFICIENCY_FLOOR, PROFICIENCY_CEILING)
+            update_stage
+          end
+
+          def add_production(production_id)
+            @productions << production_id unless @productions.include?(production_id)
+          end
+
+          def compiled?
+            @proficiency >= COMPILATION_THRESHOLD
+          end
+
+          def autonomous?
+            @proficiency >= AUTOMATION_THRESHOLD
+          end
+
+          def stage_label
+            STAGE_LABELS.find { |range, _| range.cover?(@proficiency) }&.last || :declarative
+          end
+
+          def proficiency_label
+            PROFICIENCY_LABELS.find { |range, _| range.cover?(@proficiency) }&.last || :novice
+          end
+
+          def decay!
+            @proficiency = (@proficiency - DECAY_RATE).clamp(PROFICIENCY_FLOOR, PROFICIENCY_CEILING)
+            update_stage
+          end
+
+          def stale?
+            (Time.now.utc - @last_practiced_at) > STALE_THRESHOLD
+          end
+
+          def to_h
+            {
+              id:                @id,
+              name:              @name,
+              domain:            @domain,
+              proficiency:       @proficiency,
+              proficiency_label: proficiency_label,
+              stage:             @stage,
+              stage_label:       stage_label,
+              practice_count:    @practice_count,
+              production_count:  @productions.size,
+              compiled:          compiled?,
+              autonomous:        autonomous?,
+              created_at:        @created_at,
+              last_practiced_at: @last_practiced_at
+            }
+          end
+
+          private
+
+          def update_stage
+            @stage = if autonomous?
+                       :autonomous
+                     elsif compiled?
+                       :associative
+                     else
+                       :declarative
+                     end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      module Runners
+        module ProceduralLearning
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def create_skill(name:, domain:, **)
+            skill = engine.create_skill(name: name, domain: domain)
+            Legion::Logging.debug "[procedural_learning] created skill=#{name} " \
+                                  "domain=#{domain} id=#{skill.id[0..7]}"
+            { success: true, skill_id: skill.id, name: name, domain: domain,
+              proficiency: skill.proficiency, stage: skill.stage }
+          end
+
+          def add_skill_production(skill_id:, condition:, action:, domain:, **)
+            result = engine.add_production(
+              skill_id: skill_id, condition: condition,
+              action: action, domain: domain
+            )
+
+            return result unless result.is_a?(Helpers::Production)
+
+            Legion::Logging.debug '[procedural_learning] production added ' \
+                                  "skill=#{skill_id[0..7]} condition=#{condition}"
+            { success: true, production_id: result.id, skill_id: skill_id }
+          end
+
+          def practice_skill(skill_id:, success:, **)
+            result = engine.practice_skill(skill_id: skill_id, success: success)
+            Legion::Logging.debug "[procedural_learning] practice skill=#{skill_id[0..7]} " \
+                                  "success=#{success} proficiency=#{result[:proficiency]&.round(3)}"
+            result
+          end
+
+          def execute_production(production_id:, success:, **)
+            result = engine.execute_production(production_id: production_id, success: success)
+            Legion::Logging.debug "[procedural_learning] execute production=#{production_id[0..7]} " \
+                                  "success=#{success}"
+            result
+          end
+
+          def skill_assessment(skill_id:, **)
+            result = engine.skill_assessment(skill_id: skill_id)
+            Legion::Logging.debug "[procedural_learning] assessment skill=#{skill_id[0..7]}"
+            result
+          end
+
+          def compiled_skills(**)
+            skills = engine.compiled_skills
+            Legion::Logging.debug "[procedural_learning] compiled count=#{skills.size}"
+            { success: true, skills: skills.map(&:to_h), count: skills.size }
+          end
+
+          def autonomous_skills(**)
+            skills = engine.autonomous_skills
+            Legion::Logging.debug "[procedural_learning] autonomous count=#{skills.size}"
+            { success: true, skills: skills.map(&:to_h), count: skills.size }
+          end
+
+          def most_practiced_skills(limit: 5, **)
+            skills = engine.most_practiced(limit: limit)
+            Legion::Logging.debug "[procedural_learning] most_practiced limit=#{limit}"
+            { success: true, skills: skills.map(&:to_h), count: skills.size }
+          end
+
+          def update_procedural_learning(**)
+            engine.decay_all
+            pruned = engine.prune_stale
+            Legion::Logging.debug "[procedural_learning] decay+prune pruned=#{pruned}"
+            { success: true, pruned: pruned }
+          end
+
+          def procedural_learning_stats(**)
+            stats = engine.to_h
+            Legion::Logging.debug "[procedural_learning] stats total=#{stats[:total_skills]}"
+            { success: true }.merge(stats)
+          end
+
+          private
+
+          def engine
+            @engine ||= Helpers::LearningEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/procedural_learning.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/procedural_learning/version'
+require 'legion/extensions/procedural_learning/helpers/constants'
+require 'legion/extensions/procedural_learning/helpers/production'
+require 'legion/extensions/procedural_learning/helpers/skill'
+require 'legion/extensions/procedural_learning/helpers/learning_engine'
+require 'legion/extensions/procedural_learning/runners/procedural_learning'
+require 'legion/extensions/procedural_learning/client'
+
+module Legion
+  module Extensions
+    module ProceduralLearning
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::ProceduralLearning::Client do
+  subject(:client) { described_class.new }
+
+  it 'creates a skill' do
+    result = client.create_skill(name: 'test', domain: :test)
+    expect(result[:success]).to be true
+  end
+
+  it 'practices and compiles a skill' do
+    created = client.create_skill(name: 'test', domain: :test)
+    8.times { client.practice_skill(skill_id: created[:skill_id], success: true) }
+    compiled = client.compiled_skills
+    expect(compiled[:count]).to eq(1)
+  end
+
+  it 'returns stats' do
+    result = client.procedural_learning_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/procedural_learning/helpers/learning_engine_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::ProceduralLearning::Helpers::LearningEngine do
+  subject(:engine) { described_class.new }
+
+  let(:skill) { engine.create_skill(name: 'api_retry', domain: :http) }
+
+  describe '#create_skill' do
+    it 'creates and returns a skill' do
+      result = skill
+      expect(result).to be_a(Legion::Extensions::ProceduralLearning::Helpers::Skill)
+      expect(result.name).to eq('api_retry')
+    end
+
+    it 'records history' do
+      skill
+      expect(engine.history.size).to eq(1)
+    end
+  end
+
+  describe '#add_production' do
+    it 'creates a production for a skill' do
+      result = engine.add_production(
+        skill_id: skill.id, condition: 'if_error',
+        action: 'retry', domain: :http
+      )
+      expect(result).to be_a(Legion::Extensions::ProceduralLearning::Helpers::Production)
+    end
+
+    it 'returns error for unknown skill' do
+      result = engine.add_production(
+        skill_id: 'bad', condition: 'test',
+        action: 'test', domain: :test
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#practice_skill' do
+    it 'increases proficiency' do
+      result = engine.practice_skill(skill_id: skill.id, success: true)
+      expect(result[:success]).to be true
+      expect(result[:proficiency]).to be > 0.1
+    end
+
+    it 'returns error for unknown skill' do
+      result = engine.practice_skill(skill_id: 'bad', success: true)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#execute_production' do
+    it 'executes and records outcome' do
+      prod = engine.add_production(
+        skill_id: skill.id, condition: 'test',
+        action: 'act', domain: :test
+      )
+      result = engine.execute_production(production_id: prod.id, success: true)
+      expect(result[:success]).to be true
+      expect(result[:success_rate]).to eq(1.0)
+    end
+  end
+
+  describe '#skill_assessment' do
+    it 'returns assessment with productions' do
+      prod = engine.add_production(
+        skill_id: skill.id, condition: 'test',
+        action: 'act', domain: :test
+      )
+      engine.execute_production(production_id: prod.id, success: true)
+      result = engine.skill_assessment(skill_id: skill.id)
+      expect(result[:success]).to be true
+      expect(result[:productions].size).to eq(1)
+    end
+  end
+
+  describe '#compiled_skills' do
+    it 'returns skills above compilation threshold' do
+      8.times { engine.practice_skill(skill_id: skill.id, success: true) }
+      expect(engine.compiled_skills.size).to eq(1)
+    end
+  end
+
+  describe '#autonomous_skills' do
+    it 'returns skills above automation threshold' do
+      12.times { engine.practice_skill(skill_id: skill.id, success: true) }
+      expect(engine.autonomous_skills.size).to eq(1)
+    end
+  end
+
+  describe '#by_domain' do
+    it 'filters by domain' do
+      skill
+      engine.create_skill(name: 'other', domain: :dns)
+      expect(engine.by_domain(domain: :http).size).to eq(1)
+    end
+  end
+
+  describe '#most_practiced' do
+    it 'returns skills sorted by practice count' do
+      3.times { engine.practice_skill(skill_id: skill.id, success: true) }
+      other = engine.create_skill(name: 'other', domain: :dns)
+      engine.practice_skill(skill_id: other.id, success: true)
+      results = engine.most_practiced(limit: 2)
+      expect(results.first.practice_count).to be >= results.last.practice_count
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces proficiency of all skills' do
+      5.times { engine.practice_skill(skill_id: skill.id, success: true) }
+      original = skill.proficiency
+      engine.decay_all
+      expect(skill.proficiency).to be < original
+    end
+  end
+
+  describe '#prune_stale' do
+    it 'removes skills with near-zero proficiency' do
+      skill
+      50.times { skill.decay! }
+      pruned = engine.prune_stale
+      expect(pruned).to be >= 0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats' do
+      skill
+      stats = engine.to_h
+      expect(stats[:total_skills]).to eq(1)
+      expect(stats).to include(:compiled_count, :autonomous_count, :stage_counts)
+    end
+  end
+end

data/spec/legion/extensions/procedural_learning/helpers/production_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::ProceduralLearning::Helpers::Production do
+  subject(:production) do
+    described_class.new(condition: 'if_error', action: 'retry_request', domain: :http, skill_id: 'skill-123')
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(production.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores condition and action' do
+      expect(production.condition).to eq('if_error')
+      expect(production.action).to eq('retry_request')
+    end
+
+    it 'starts with zero execution count' do
+      expect(production.execution_count).to eq(0)
+    end
+  end
+
+  describe '#execute!' do
+    it 'increments execution count' do
+      expect { production.execute!(success: true) }.to change(production, :execution_count).by(1)
+    end
+
+    it 'increments success count on success' do
+      expect { production.execute!(success: true) }.to change(production, :success_count).by(1)
+    end
+
+    it 'does not increment success count on failure' do
+      expect { production.execute!(success: false) }.not_to change(production, :success_count)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 when no executions' do
+      expect(production.success_rate).to eq(0.0)
+    end
+
+    it 'computes success ratio' do
+      3.times { production.execute!(success: true) }
+      production.execute!(success: false)
+      expect(production.success_rate).to eq(0.75)
+    end
+  end
+
+  describe '#reliable?' do
+    it 'returns false initially' do
+      expect(production).not_to be_reliable
+    end
+
+    it 'returns true after sufficient successful executions' do
+      5.times { production.execute!(success: true) }
+      expect(production).to be_reliable
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash representation' do
+      hash = production.to_h
+      expect(hash).to include(:id, :condition, :action, :domain, :success_rate, :reliable)
+    end
+  end
+end

data/spec/legion/extensions/procedural_learning/helpers/skill_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::ProceduralLearning::Helpers::Skill do
+  subject(:skill) { described_class.new(name: 'api_retry', domain: :http) }
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(skill.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts at declarative stage' do
+      expect(skill.stage).to eq(:declarative)
+    end
+
+    it 'starts with low proficiency' do
+      expect(skill.proficiency).to be < 0.2
+    end
+  end
+
+  describe '#practice!' do
+    it 'increases proficiency on success' do
+      original = skill.proficiency
+      skill.practice!(success: true)
+      expect(skill.proficiency).to be > original
+    end
+
+    it 'increases proficiency less on failure' do
+      success_skill = described_class.new(name: 'test', domain: :test)
+      failure_skill = described_class.new(name: 'test', domain: :test)
+      success_skill.practice!(success: true)
+      failure_skill.practice!(success: false)
+      expect(success_skill.proficiency).to be > failure_skill.proficiency
+    end
+
+    it 'transitions stage with practice' do
+      10.times { skill.practice!(success: true) }
+      expect(skill.stage).not_to eq(:declarative)
+    end
+  end
+
+  describe '#compiled?' do
+    it 'returns false initially' do
+      expect(skill).not_to be_compiled
+    end
+
+    it 'returns true after sufficient practice' do
+      8.times { skill.practice!(success: true) }
+      expect(skill).to be_compiled
+    end
+  end
+
+  describe '#autonomous?' do
+    it 'returns false initially' do
+      expect(skill).not_to be_autonomous
+    end
+
+    it 'returns true after extensive practice' do
+      12.times { skill.practice!(success: true) }
+      expect(skill).to be_autonomous
+    end
+  end
+
+  describe '#stage_label' do
+    it 'returns a label symbol' do
+      expect(skill.stage_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#proficiency_label' do
+    it 'returns a label symbol' do
+      expect(skill.proficiency_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces proficiency' do
+      5.times { skill.practice!(success: true) }
+      original = skill.proficiency
+      skill.decay!
+      expect(skill.proficiency).to be < original
+    end
+  end
+
+  describe '#add_production' do
+    it 'adds production id' do
+      skill.add_production('prod-123')
+      expect(skill.productions).to include('prod-123')
+    end
+
+    it 'does not add duplicates' do
+      2.times { skill.add_production('prod-123') }
+      expect(skill.productions.size).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash representation' do
+      hash = skill.to_h
+      expect(hash).to include(:id, :name, :domain, :proficiency, :stage, :compiled, :autonomous)
+    end
+  end
+end

data/spec/legion/extensions/procedural_learning/runners/procedural_learning_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::ProceduralLearning::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/spec_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Helpers
+      module Lex; end
+    end
+  end
+
+  module Logging
+    def self.debug(*); end
+
+    def self.info(*); end
+
+    def self.warn(*); end
+
+    def self.error(*); end
+  end
+end
+
+require 'legion/extensions/procedural_learning'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run_when_matching :focus
+  config.order = :random
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-procedural-learning
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Anderson's ACT-R production rules — skill acquisition from declarative
+  to autonomous for brain-modeled agentic AI
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lex-procedural-learning.gemspec
+- lib/legion/extensions/procedural_learning.rb
+- lib/legion/extensions/procedural_learning/client.rb
+- lib/legion/extensions/procedural_learning/helpers/constants.rb
+- lib/legion/extensions/procedural_learning/helpers/learning_engine.rb
+- lib/legion/extensions/procedural_learning/helpers/production.rb
+- lib/legion/extensions/procedural_learning/helpers/skill.rb
+- lib/legion/extensions/procedural_learning/runners/procedural_learning.rb
+- lib/legion/extensions/procedural_learning/version.rb
+- spec/legion/extensions/procedural_learning/client_spec.rb
+- spec/legion/extensions/procedural_learning/helpers/learning_engine_spec.rb
+- spec/legion/extensions/procedural_learning/helpers/production_spec.rb
+- spec/legion/extensions/procedural_learning/helpers/skill_spec.rb
+- spec/legion/extensions/procedural_learning/runners/procedural_learning_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-procedural-learning
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-procedural-learning
+  source_code_uri: https://github.com/LegionIO/lex-procedural-learning
+  documentation_uri: https://github.com/LegionIO/lex-procedural-learning
+  changelog_uri: https://github.com/LegionIO/lex-procedural-learning
+  bug_tracker_uri: https://github.com/LegionIO/lex-procedural-learning/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Procedural Learning
+test_files: []