lex-transfer-learning 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f75d8ed4ba9863fb0509ade3cc4f3c1ab7e4cdfdc61c63a39377c01929ca2bc1
+  data.tar.gz: 6a6fb03022582a040beebbffa0d28411788a9498091628366330ac7b538c90e0
+SHA512:
+  metadata.gz: 117eb74b067523792cef8196ebec35d595b0762301c156ceb025ccf773cda5a99a3eec98df59e607dbbee7a98e6ec182f6876e4c6d39a4374fee01ddefb1d5a1
+  data.tar.gz: fb49e00c94a694769812012d05877f786377fee2c9db7c9951365e6b9cfd81a886cf26391bd17e483afc4766e54b462d8d4504700577213cfbf579765906f69b

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/lex-transfer-learning.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/transfer_learning/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-transfer-learning'
+  spec.version       = Legion::Extensions::TransferLearning::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Transfer Learning'
+  spec.description   = 'Domain knowledge transfer modeling for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-transfer-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-transfer-learning'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-transfer-learning'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-transfer-learning'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-transfer-learning/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-transfer-learning.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/transfer_learning/helpers/constants'
+require 'legion/extensions/transfer_learning/helpers/domain_knowledge'
+require 'legion/extensions/transfer_learning/helpers/transfer_engine'
+require 'legion/extensions/transfer_learning/runners/transfer_learning'
+
+module Legion
+  module Extensions
+    module TransferLearning
+      class Client
+        include Runners::TransferLearning
+
+        def initialize(**)
+          @transfer_engine = Helpers::TransferEngine.new
+        end
+
+        private
+
+        attr_reader :transfer_engine
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module TransferLearning
+      module Helpers
+        module Constants
+          MAX_DOMAINS                  = 200
+          POSITIVE_TRANSFER_THRESHOLD  = 0.6
+          NEGATIVE_TRANSFER_THRESHOLD  = 0.3
+          TRANSFER_BOOST               = 0.15
+          INTERFERENCE_PENALTY         = 0.1
+
+          TRANSFER_LABELS = {
+            positive:     'positive',
+            neutral:      'neutral',
+            negative:     'negative',
+            interference: 'interference'
+          }.freeze
+
+          DISTANCE_LABELS = {
+            near:     'near',
+            moderate: 'moderate',
+            far:      'far'
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/transfer_learning/helpers/domain_knowledge.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module TransferLearning
+      module Helpers
+        class DomainKnowledge
+          attr_reader :id, :domain, :proficiency, :learn_count, :transfer_count
+
+          PROFICIENCY_LABELS = [
+            [0.0, 0.2,  'novice'],
+            [0.2, 0.4,  'beginner'],
+            [0.4, 0.6,  'intermediate'],
+            [0.6, 0.8,  'advanced'],
+            [0.8, 1.01, 'expert']
+          ].freeze
+
+          def initialize(domain:)
+            @id             = SecureRandom.uuid
+            @domain         = domain
+            @proficiency    = 0.0
+            @learn_count    = 0
+            @transfer_count = 0
+          end
+
+          def learn!(amount:)
+            @proficiency = (@proficiency + amount).clamp(0.0, 1.0).round(10)
+            @learn_count += 1
+            self
+          end
+
+          def record_transfer!
+            @transfer_count += 1
+            self
+          end
+
+          def apply_boost!(amount)
+            @proficiency = (@proficiency + amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def apply_penalty!(amount)
+            @proficiency = (@proficiency - amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def proficiency_label
+            PROFICIENCY_LABELS.each do |low, high, label|
+              return label if @proficiency >= low && @proficiency < high
+            end
+            'novice'
+          end
+
+          def to_h
+            {
+              id:                @id,
+              domain:            @domain,
+              proficiency:       @proficiency.round(10),
+              proficiency_label: proficiency_label,
+              learn_count:       @learn_count,
+              transfer_count:    @transfer_count
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/transfer_learning/helpers/transfer_engine.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module TransferLearning
+      module Helpers
+        class TransferEngine
+          include Constants
+
+          attr_reader :domains, :similarities, :transfer_history
+
+          def initialize
+            @domains          = {}
+            @similarities     = {}
+            @transfer_history = []
+          end
+
+          def set_similarity(domain_a:, domain_b:, similarity:)
+            sim = similarity.clamp(0.0, 1.0).round(10)
+            @similarities[similarity_key(domain_a, domain_b)] = sim
+            sim
+          end
+
+          def learn_domain(domain:, amount:)
+            check_domain_limit!
+            entry = get_or_create_domain(domain)
+            entry.learn!(amount: amount.clamp(0.0, 1.0))
+            entry.to_h
+          end
+
+          def attempt_transfer(from_domain:, to_domain:)
+            source = @domains[from_domain]
+            return { status: :source_not_found, from_domain: from_domain } unless source
+
+            check_domain_limit!
+            target   = get_or_create_domain(to_domain)
+            sim      = similarity_between(from_domain, to_domain)
+            type     = transfer_type(sim)
+            distance = transfer_distance(sim)
+            effect   = apply_transfer_effect!(target, source, type)
+            source.record_transfer!
+            record_history!(from_domain, to_domain, sim, type, distance, effect)
+            build_transfer_result(from_domain, to_domain, sim, type, distance, effect, target)
+          end
+
+          def transfer_effectiveness(from_domain:, to_domain:)
+            sim = similarity_between(from_domain, to_domain)
+            build_effectiveness(from_domain, to_domain, sim, transfer_type(sim),
+                                @domains[from_domain], @domains[to_domain])
+          end
+
+          def most_transferable(target_domain:, limit: 5)
+            candidates = candidate_rows(target_domain)
+            candidates.select { |r| r[:type] == :positive }
+                      .sort_by { |r| -r[:similarity] }
+                      .first(limit)
+          end
+
+          def interference_risks(target_domain:)
+            candidate_rows(target_domain)
+              .select { |r| r[:type] == :interference }
+              .sort_by { |r| -r[:similarity] }
+          end
+
+          def transfer_report
+            {
+              total_transfers:     @transfer_history.size,
+              positive_transfers:  @transfer_history.count { |h| h[:type] == :positive },
+              negative_transfers:  @transfer_history.count { |h| h[:type] == :negative },
+              neutral_transfers:   @transfer_history.count { |h| h[:type] == :neutral },
+              interference_events: @transfer_history.count { |h| h[:type] == :interference },
+              domain_count:        @domains.size,
+              similarity_pairs:    @similarities.size
+            }
+          end
+
+          def to_h
+            {
+              domains:          @domains.transform_values(&:to_h),
+              similarities:     @similarities.dup,
+              transfer_history: @transfer_history.dup,
+              report:           transfer_report
+            }
+          end
+
+          private
+
+          def get_or_create_domain(name)
+            @domains[name] ||= DomainKnowledge.new(domain: name)
+          end
+
+          def similarity_key(domain_a, domain_b)
+            [domain_a, domain_b].sort.join(':')
+          end
+
+          def similarity_between(domain_a, domain_b)
+            @similarities[similarity_key(domain_a, domain_b)] || 0.0
+          end
+
+          def transfer_type(similarity)
+            if similarity >= POSITIVE_TRANSFER_THRESHOLD then :positive
+            elsif similarity >= NEGATIVE_TRANSFER_THRESHOLD then :interference
+            elsif similarity > 0.0 then :negative
+            else :neutral
+            end
+          end
+
+          def transfer_distance(similarity)
+            if similarity >= POSITIVE_TRANSFER_THRESHOLD then :near
+            elsif similarity >= NEGATIVE_TRANSFER_THRESHOLD then :moderate
+            else :far
+            end
+          end
+
+          def apply_transfer_effect!(target, source, type)
+            case type
+            when :positive
+              scaled = (source.proficiency * TRANSFER_BOOST).round(10)
+              target.apply_boost!(scaled)
+              scaled
+            when :interference
+              penalty = (source.proficiency * INTERFERENCE_PENALTY).round(10)
+              target.apply_penalty!(penalty)
+              -penalty
+            else
+              0.0
+            end
+          end
+
+          def record_history!(from_domain, to_domain, sim, type, distance, effect)
+            @transfer_history << {
+              from_domain: from_domain,
+              to_domain:   to_domain,
+              similarity:  sim.round(10),
+              type:        type,
+              distance:    distance,
+              effect:      effect,
+              at:          Time.now.utc
+            }
+          end
+
+          def check_domain_limit!
+            raise "domain limit of #{MAX_DOMAINS} reached" if @domains.size >= MAX_DOMAINS
+          end
+
+          def candidate_rows(target_domain)
+            @domains.reject { |name, _| name == target_domain }.map do |name, entry|
+              sim  = similarity_between(name, target_domain)
+              type = transfer_type(sim)
+              { domain: name, proficiency: entry.proficiency.round(10), similarity: sim.round(10), type: type }
+            end
+          end
+
+          def build_transfer_result(from_domain, to_domain, sim, type, distance, effect, target)
+            {
+              status:      :ok,
+              from_domain: from_domain,
+              to_domain:   to_domain,
+              similarity:  sim.round(10),
+              type:        type,
+              distance:    distance,
+              effect:      effect,
+              proficiency: target.proficiency.round(10)
+            }
+          end
+
+          def build_effectiveness(from_domain, to_domain, sim, type, source, target)
+            {
+              from_domain:        from_domain,
+              to_domain:          to_domain,
+              similarity:         sim.round(10),
+              type:               type,
+              type_label:         TRANSFER_LABELS[type],
+              distance:           transfer_distance(sim),
+              distance_label:     DISTANCE_LABELS[transfer_distance(sim)],
+              source_proficiency: source&.proficiency&.round(10) || 0.0,
+              target_proficiency: target&.proficiency&.round(10) || 0.0
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module TransferLearning
+      module Runners
+        module TransferLearning
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def learn_domain(domain:, amount:, **)
+            result = transfer_engine.learn_domain(domain: domain, amount: amount)
+            Legion::Logging.info "[transfer_learning] learn: domain=#{domain} amount=#{amount} proficiency=#{result[:proficiency]}"
+            result
+          end
+
+          def attempt_transfer(from_domain:, to_domain:, **)
+            result = transfer_engine.attempt_transfer(from_domain: from_domain, to_domain: to_domain)
+            Legion::Logging.info "[transfer_learning] transfer: from=#{from_domain} to=#{to_domain} type=#{result[:type]} effect=#{result[:effect]}"
+            result
+          end
+
+          def set_similarity(domain_a:, domain_b:, similarity:, **)
+            sim = transfer_engine.set_similarity(domain_a: domain_a, domain_b: domain_b, similarity: similarity)
+            Legion::Logging.debug "[transfer_learning] similarity set: #{domain_a}<->#{domain_b} similarity=#{sim}"
+            { domain_a: domain_a, domain_b: domain_b, similarity: sim }
+          end
+
+          def transfer_effectiveness(from_domain:, to_domain:, **)
+            result = transfer_engine.transfer_effectiveness(from_domain: from_domain, to_domain: to_domain)
+            Legion::Logging.debug "[transfer_learning] effectiveness: from=#{from_domain} to=#{to_domain} type=#{result[:type]}"
+            result
+          end
+
+          def most_transferable(target_domain:, limit: 5, **)
+            candidates = transfer_engine.most_transferable(target_domain: target_domain, limit: limit)
+            Legion::Logging.debug "[transfer_learning] most_transferable: target=#{target_domain} found=#{candidates.size}"
+            { target_domain: target_domain, candidates: candidates, count: candidates.size }
+          end
+
+          def interference_risks(target_domain:, **)
+            risks = transfer_engine.interference_risks(target_domain: target_domain)
+            Legion::Logging.debug "[transfer_learning] interference_risks: target=#{target_domain} risks=#{risks.size}"
+            { target_domain: target_domain, risks: risks, count: risks.size }
+          end
+
+          def transfer_report(**)
+            report = transfer_engine.transfer_report
+            Legion::Logging.debug "[transfer_learning] report: domains=#{report[:domain_count]} transfers=#{report[:total_transfers]}"
+            report
+          end
+
+          def get_domain(domain:, **)
+            entry = transfer_engine.domains[domain]
+            if entry
+              Legion::Logging.debug "[transfer_learning] get_domain: domain=#{domain} proficiency=#{entry.proficiency}"
+              { found: true, domain: entry.to_h }
+            else
+              Legion::Logging.debug "[transfer_learning] get_domain: domain=#{domain} not found"
+              { found: false, domain: domain }
+            end
+          end
+
+          private
+
+          def transfer_engine
+            @transfer_engine ||= Helpers::TransferEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/transfer_learning.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/transfer_learning/version'
+require 'legion/extensions/transfer_learning/helpers/constants'
+require 'legion/extensions/transfer_learning/helpers/domain_knowledge'
+require 'legion/extensions/transfer_learning/helpers/transfer_engine'
+require 'legion/extensions/transfer_learning/runners/transfer_learning'
+
+module Legion
+  module Extensions
+    module TransferLearning
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/transfer_learning/client'
+
+RSpec.describe Legion::Extensions::TransferLearning::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:learn_domain)
+    expect(client).to respond_to(:attempt_transfer)
+    expect(client).to respond_to(:set_similarity)
+    expect(client).to respond_to(:transfer_effectiveness)
+    expect(client).to respond_to(:most_transferable)
+    expect(client).to respond_to(:interference_risks)
+    expect(client).to respond_to(:transfer_report)
+    expect(client).to respond_to(:get_domain)
+  end
+end

data/spec/legion/extensions/transfer_learning/helpers/constants_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::TransferLearning::Helpers::Constants do
+  subject(:mod) { described_class }
+
+  it 'defines MAX_DOMAINS as 200' do
+    expect(mod::MAX_DOMAINS).to eq(200)
+  end
+
+  it 'defines POSITIVE_TRANSFER_THRESHOLD as 0.6' do
+    expect(mod::POSITIVE_TRANSFER_THRESHOLD).to eq(0.6)
+  end
+
+  it 'defines NEGATIVE_TRANSFER_THRESHOLD as 0.3' do
+    expect(mod::NEGATIVE_TRANSFER_THRESHOLD).to eq(0.3)
+  end
+
+  it 'defines TRANSFER_BOOST as 0.15' do
+    expect(mod::TRANSFER_BOOST).to eq(0.15)
+  end
+
+  it 'defines INTERFERENCE_PENALTY as 0.1' do
+    expect(mod::INTERFERENCE_PENALTY).to eq(0.1)
+  end
+
+  it 'defines all four TRANSFER_LABELS' do
+    expect(mod::TRANSFER_LABELS.keys).to contain_exactly(:positive, :neutral, :negative, :interference)
+  end
+
+  it 'defines all three DISTANCE_LABELS' do
+    expect(mod::DISTANCE_LABELS.keys).to contain_exactly(:near, :moderate, :far)
+  end
+
+  it 'freezes TRANSFER_LABELS' do
+    expect(mod::TRANSFER_LABELS).to be_frozen
+  end
+
+  it 'freezes DISTANCE_LABELS' do
+    expect(mod::DISTANCE_LABELS).to be_frozen
+  end
+end

data/spec/legion/extensions/transfer_learning/helpers/domain_knowledge_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::TransferLearning::Helpers::DomainKnowledge do
+  subject(:dk) { described_class.new(domain: :ruby) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(dk.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets domain' do
+      expect(dk.domain).to eq(:ruby)
+    end
+
+    it 'starts proficiency at 0.0' do
+      expect(dk.proficiency).to eq(0.0)
+    end
+
+    it 'starts learn_count at 0' do
+      expect(dk.learn_count).to eq(0)
+    end
+
+    it 'starts transfer_count at 0' do
+      expect(dk.transfer_count).to eq(0)
+    end
+  end
+
+  describe '#learn!' do
+    it 'increases proficiency by amount' do
+      dk.learn!(amount: 0.3)
+      expect(dk.proficiency).to eq(0.3)
+    end
+
+    it 'increments learn_count' do
+      dk.learn!(amount: 0.1)
+      expect(dk.learn_count).to eq(1)
+    end
+
+    it 'clamps proficiency at 1.0' do
+      dk.learn!(amount: 1.5)
+      expect(dk.proficiency).to eq(1.0)
+    end
+
+    it 'clamps proficiency at 0.0 for negative amount' do
+      dk.learn!(amount: -0.5)
+      expect(dk.proficiency).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(dk.learn!(amount: 0.1)).to be(dk)
+    end
+  end
+
+  describe '#record_transfer!' do
+    it 'increments transfer_count' do
+      dk.record_transfer!
+      expect(dk.transfer_count).to eq(1)
+    end
+
+    it 'returns self' do
+      expect(dk.record_transfer!).to be(dk)
+    end
+  end
+
+  describe '#apply_boost!' do
+    it 'increases proficiency' do
+      dk.learn!(amount: 0.5)
+      dk.apply_boost!(0.2)
+      expect(dk.proficiency).to be_within(0.0001).of(0.7)
+    end
+
+    it 'clamps at 1.0' do
+      dk.learn!(amount: 0.9)
+      dk.apply_boost!(0.5)
+      expect(dk.proficiency).to eq(1.0)
+    end
+  end
+
+  describe '#apply_penalty!' do
+    it 'decreases proficiency' do
+      dk.learn!(amount: 0.5)
+      dk.apply_penalty!(0.2)
+      expect(dk.proficiency).to be_within(0.0001).of(0.3)
+    end
+
+    it 'clamps at 0.0' do
+      dk.apply_penalty!(0.5)
+      expect(dk.proficiency).to eq(0.0)
+    end
+  end
+
+  describe '#proficiency_label' do
+    it 'returns novice for 0.0' do
+      expect(dk.proficiency_label).to eq('novice')
+    end
+
+    it 'returns beginner for 0.3' do
+      dk.learn!(amount: 0.3)
+      expect(dk.proficiency_label).to eq('beginner')
+    end
+
+    it 'returns intermediate for 0.5' do
+      dk.learn!(amount: 0.5)
+      expect(dk.proficiency_label).to eq('intermediate')
+    end
+
+    it 'returns advanced for 0.7' do
+      dk.learn!(amount: 0.7)
+      expect(dk.proficiency_label).to eq('advanced')
+    end
+
+    it 'returns expert for 0.9' do
+      dk.learn!(amount: 0.9)
+      expect(dk.proficiency_label).to eq('expert')
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      hash = dk.to_h
+      expect(hash.keys).to contain_exactly(:id, :domain, :proficiency, :proficiency_label, :learn_count, :transfer_count)
+    end
+
+    it 'reflects current proficiency' do
+      dk.learn!(amount: 0.4)
+      expect(dk.to_h[:proficiency]).to eq(0.4)
+    end
+
+    it 'includes proficiency_label' do
+      dk.learn!(amount: 0.4)
+      expect(dk.to_h[:proficiency_label]).to eq('intermediate')
+    end
+  end
+end

data/spec/legion/extensions/transfer_learning/helpers/transfer_engine_spec.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::TransferLearning::Helpers::TransferEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty domains' do
+      expect(engine.domains).to be_empty
+    end
+
+    it 'starts with empty similarities' do
+      expect(engine.similarities).to be_empty
+    end
+
+    it 'starts with empty transfer_history' do
+      expect(engine.transfer_history).to be_empty
+    end
+  end
+
+  describe '#set_similarity' do
+    it 'stores similarity between two domains' do
+      engine.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.7)
+      expect(engine.similarities['python:ruby']).to eq(0.7)
+    end
+
+    it 'is commutative (same key regardless of order)' do
+      engine.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.7)
+      engine.set_similarity(domain_a: :python, domain_b: :ruby, similarity: 0.8)
+      key = 'python:ruby'
+      expect(engine.similarities[key]).to eq(0.8)
+    end
+
+    it 'clamps similarity to 0.0..1.0' do
+      engine.set_similarity(domain_a: :a, domain_b: :b, similarity: 1.5)
+      expect(engine.similarities['a:b']).to eq(1.0)
+    end
+
+    it 'clamps negative similarity to 0.0' do
+      engine.set_similarity(domain_a: :a, domain_b: :b, similarity: -0.3)
+      expect(engine.similarities['a:b']).to eq(0.0)
+    end
+
+    it 'returns the clamped similarity' do
+      result = engine.set_similarity(domain_a: :a, domain_b: :b, similarity: 0.5)
+      expect(result).to eq(0.5)
+    end
+  end
+
+  describe '#learn_domain' do
+    it 'creates and returns domain knowledge' do
+      result = engine.learn_domain(domain: :ruby, amount: 0.4)
+      expect(result[:domain]).to eq(:ruby)
+      expect(result[:proficiency]).to eq(0.4)
+    end
+
+    it 'accumulates proficiency on repeated calls' do
+      engine.learn_domain(domain: :ruby, amount: 0.3)
+      result = engine.learn_domain(domain: :ruby, amount: 0.3)
+      expect(result[:proficiency]).to be_within(0.0001).of(0.6)
+    end
+
+    it 'increments learn_count' do
+      engine.learn_domain(domain: :ruby, amount: 0.1)
+      result = engine.learn_domain(domain: :ruby, amount: 0.1)
+      expect(result[:learn_count]).to eq(2)
+    end
+
+    it 'clamps amount before applying' do
+      result = engine.learn_domain(domain: :ruby, amount: 5.0)
+      expect(result[:proficiency]).to eq(1.0)
+    end
+  end
+
+  describe '#attempt_transfer' do
+    before do
+      engine.learn_domain(domain: :ruby, amount: 0.8)
+    end
+
+    it 'returns source_not_found when source domain does not exist' do
+      result = engine.attempt_transfer(from_domain: :unknown, to_domain: :python)
+      expect(result[:status]).to eq(:source_not_found)
+    end
+
+    context 'with positive similarity' do
+      before { engine.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.8) }
+
+      it 'returns status :ok' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(result[:status]).to eq(:ok)
+      end
+
+      it 'classifies as positive transfer' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(result[:type]).to eq(:positive)
+      end
+
+      it 'classifies distance as near' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(result[:distance]).to eq(:near)
+      end
+
+      it 'boosts target proficiency' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(result[:effect]).to be > 0
+        expect(result[:proficiency]).to be > 0
+      end
+
+      it 'increments source transfer_count' do
+        engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(engine.domains[:ruby].transfer_count).to eq(1)
+      end
+
+      it 'records transfer in history' do
+        engine.attempt_transfer(from_domain: :ruby, to_domain: :python)
+        expect(engine.transfer_history.size).to eq(1)
+        expect(engine.transfer_history.first[:type]).to eq(:positive)
+      end
+    end
+
+    context 'with interference similarity (0.3..0.6)' do
+      before { engine.set_similarity(domain_a: :ruby, domain_b: :cobol, similarity: 0.4) }
+
+      it 'classifies as interference' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :cobol)
+        expect(result[:type]).to eq(:interference)
+      end
+
+      it 'applies penalty to target' do
+        engine.learn_domain(domain: :cobol, amount: 0.5)
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :cobol)
+        expect(result[:effect]).to be < 0
+      end
+
+      it 'classifies distance as moderate' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :cobol)
+        expect(result[:distance]).to eq(:moderate)
+      end
+    end
+
+    context 'with low similarity (0.0..0.3)' do
+      before { engine.set_similarity(domain_a: :ruby, domain_b: :sql, similarity: 0.1) }
+
+      it 'classifies as negative transfer' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :sql)
+        expect(result[:type]).to eq(:negative)
+      end
+
+      it 'applies zero effect (negative = no net change)' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :sql)
+        expect(result[:effect]).to eq(0.0)
+      end
+
+      it 'classifies distance as far' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :sql)
+        expect(result[:distance]).to eq(:far)
+      end
+    end
+
+    context 'with zero similarity (unknown domains)' do
+      it 'classifies as neutral transfer' do
+        result = engine.attempt_transfer(from_domain: :ruby, to_domain: :haskell)
+        expect(result[:type]).to eq(:neutral)
+      end
+    end
+  end
+
+  describe '#transfer_effectiveness' do
+    before do
+      engine.learn_domain(domain: :ruby, amount: 0.7)
+      engine.learn_domain(domain: :python, amount: 0.3)
+      engine.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.75)
+    end
+
+    it 'returns effectiveness hash' do
+      result = engine.transfer_effectiveness(from_domain: :ruby, to_domain: :python)
+      expect(result[:type]).to eq(:positive)
+      expect(result[:type_label]).to eq('positive')
+      expect(result[:distance]).to eq(:near)
+      expect(result[:similarity]).to eq(0.75)
+    end
+
+    it 'returns source and target proficiency' do
+      result = engine.transfer_effectiveness(from_domain: :ruby, to_domain: :python)
+      expect(result[:source_proficiency]).to eq(0.7)
+      expect(result[:target_proficiency]).to eq(0.3)
+    end
+
+    it 'handles unknown domains gracefully' do
+      result = engine.transfer_effectiveness(from_domain: :unknown_a, to_domain: :unknown_b)
+      expect(result[:source_proficiency]).to eq(0.0)
+      expect(result[:target_proficiency]).to eq(0.0)
+    end
+  end
+
+  describe '#most_transferable' do
+    before do
+      engine.learn_domain(domain: :target, amount: 0.2)
+      engine.learn_domain(domain: :high_sim, amount: 0.8)
+      engine.learn_domain(domain: :low_sim, amount: 0.8)
+      engine.learn_domain(domain: :no_sim, amount: 0.8)
+      engine.set_similarity(domain_a: :high_sim, domain_b: :target, similarity: 0.9)
+      engine.set_similarity(domain_a: :low_sim, domain_b: :target, similarity: 0.1)
+    end
+
+    it 'returns only positively transferable domains' do
+      result = engine.most_transferable(target_domain: :target)
+      expect(result.map { |r| r[:domain] }).to include(:high_sim)
+      expect(result.map { |r| r[:domain] }).not_to include(:low_sim)
+      expect(result.map { |r| r[:domain] }).not_to include(:no_sim)
+    end
+
+    it 'sorts by similarity descending' do
+      engine.learn_domain(domain: :mid_sim, amount: 0.8)
+      engine.set_similarity(domain_a: :mid_sim, domain_b: :target, similarity: 0.7)
+      result = engine.most_transferable(target_domain: :target)
+      sims = result.map { |r| r[:similarity] }
+      expect(sims).to eq(sims.sort.reverse)
+    end
+
+    it 'respects the limit parameter' do
+      5.times do |i|
+        name = :"domain_#{i}"
+        engine.learn_domain(domain: name, amount: 0.5)
+        engine.set_similarity(domain_a: name, domain_b: :target, similarity: 0.7 + (i * 0.01))
+      end
+      result = engine.most_transferable(target_domain: :target, limit: 3)
+      expect(result.size).to be <= 3
+    end
+  end
+
+  describe '#interference_risks' do
+    before do
+      engine.learn_domain(domain: :target, amount: 0.3)
+      engine.learn_domain(domain: :risky, amount: 0.8)
+      engine.learn_domain(domain: :safe, amount: 0.8)
+      engine.set_similarity(domain_a: :risky, domain_b: :target, similarity: 0.45)
+      engine.set_similarity(domain_a: :safe, domain_b: :target, similarity: 0.8)
+    end
+
+    it 'returns only interference-type domains' do
+      result = engine.interference_risks(target_domain: :target)
+      domains = result.map { |r| r[:domain] }
+      expect(domains).to include(:risky)
+      expect(domains).not_to include(:safe)
+    end
+
+    it 'sorts by similarity descending' do
+      engine.learn_domain(domain: :also_risky, amount: 0.5)
+      engine.set_similarity(domain_a: :also_risky, domain_b: :target, similarity: 0.35)
+      result = engine.interference_risks(target_domain: :target)
+      sims = result.map { |r| r[:similarity] }
+      expect(sims).to eq(sims.sort.reverse)
+    end
+
+    it 'returns empty array when no interference risks' do
+      engine2 = described_class.new
+      engine2.learn_domain(domain: :t, amount: 0.3)
+      expect(engine2.interference_risks(target_domain: :t)).to be_empty
+    end
+  end
+
+  describe '#transfer_report' do
+    it 'returns zero counts for empty engine' do
+      report = engine.transfer_report
+      expect(report[:total_transfers]).to eq(0)
+      expect(report[:domain_count]).to eq(0)
+    end
+
+    it 'counts transfers correctly' do
+      engine.learn_domain(domain: :a, amount: 0.8)
+      engine.set_similarity(domain_a: :a, domain_b: :b, similarity: 0.7)
+      engine.attempt_transfer(from_domain: :a, to_domain: :b)
+      engine.attempt_transfer(from_domain: :a, to_domain: :b)
+      report = engine.transfer_report
+      expect(report[:total_transfers]).to eq(2)
+      expect(report[:positive_transfers]).to eq(2)
+    end
+
+    it 'counts interference events' do
+      engine.learn_domain(domain: :a, amount: 0.8)
+      engine.set_similarity(domain_a: :a, domain_b: :b, similarity: 0.4)
+      engine.attempt_transfer(from_domain: :a, to_domain: :b)
+      report = engine.transfer_report
+      expect(report[:interference_events]).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      keys = engine.to_h.keys
+      expect(keys).to contain_exactly(:domains, :similarities, :transfer_history, :report)
+    end
+
+    it 'reflects current state' do
+      engine.learn_domain(domain: :ruby, amount: 0.5)
+      expect(engine.to_h[:domains].keys).to include(:ruby)
+    end
+  end
+end

data/spec/legion/extensions/transfer_learning/runners/transfer_learning_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/transfer_learning/client'
+
+RSpec.describe Legion::Extensions::TransferLearning::Runners::TransferLearning do
+  let(:client) { Legion::Extensions::TransferLearning::Client.new }
+
+  describe '#learn_domain' do
+    it 'returns domain knowledge hash' do
+      result = client.learn_domain(domain: :ruby, amount: 0.5)
+      expect(result[:domain]).to eq(:ruby)
+      expect(result[:proficiency]).to eq(0.5)
+    end
+
+    it 'accumulates proficiency across calls' do
+      client.learn_domain(domain: :ruby, amount: 0.3)
+      result = client.learn_domain(domain: :ruby, amount: 0.3)
+      expect(result[:proficiency]).to be_within(0.0001).of(0.6)
+    end
+  end
+
+  describe '#set_similarity' do
+    it 'returns similarity hash' do
+      result = client.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.7)
+      expect(result[:domain_a]).to eq(:ruby)
+      expect(result[:domain_b]).to eq(:python)
+      expect(result[:similarity]).to eq(0.7)
+    end
+  end
+
+  describe '#attempt_transfer' do
+    before do
+      client.learn_domain(domain: :ruby, amount: 0.8)
+      client.set_similarity(domain_a: :ruby, domain_b: :python, similarity: 0.8)
+    end
+
+    it 'returns ok status for known source' do
+      result = client.attempt_transfer(from_domain: :ruby, to_domain: :python)
+      expect(result[:status]).to eq(:ok)
+    end
+
+    it 'returns positive type for high similarity' do
+      result = client.attempt_transfer(from_domain: :ruby, to_domain: :python)
+      expect(result[:type]).to eq(:positive)
+    end
+
+    it 'returns source_not_found for unknown source' do
+      result = client.attempt_transfer(from_domain: :unknown, to_domain: :python)
+      expect(result[:status]).to eq(:source_not_found)
+    end
+
+    it 'includes proficiency in response' do
+      result = client.attempt_transfer(from_domain: :ruby, to_domain: :python)
+      expect(result).to have_key(:proficiency)
+    end
+  end
+
+  describe '#transfer_effectiveness' do
+    before do
+      client.learn_domain(domain: :a, amount: 0.6)
+      client.learn_domain(domain: :b, amount: 0.4)
+      client.set_similarity(domain_a: :a, domain_b: :b, similarity: 0.7)
+    end
+
+    it 'returns effectiveness details' do
+      result = client.transfer_effectiveness(from_domain: :a, to_domain: :b)
+      expect(result[:type]).to eq(:positive)
+      expect(result[:type_label]).to eq('positive')
+      expect(result[:distance_label]).to eq('near')
+    end
+  end
+
+  describe '#most_transferable' do
+    before do
+      client.learn_domain(domain: :target, amount: 0.2)
+      client.learn_domain(domain: :good_source, amount: 0.8)
+      client.set_similarity(domain_a: :good_source, domain_b: :target, similarity: 0.9)
+    end
+
+    it 'returns candidates hash' do
+      result = client.most_transferable(target_domain: :target)
+      expect(result[:target_domain]).to eq(:target)
+      expect(result[:candidates]).to be_an(Array)
+      expect(result[:count]).to eq(result[:candidates].size)
+    end
+
+    it 'includes positive transfer candidates' do
+      result = client.most_transferable(target_domain: :target)
+      expect(result[:candidates].map { |c| c[:domain] }).to include(:good_source)
+    end
+  end
+
+  describe '#interference_risks' do
+    before do
+      client.learn_domain(domain: :target, amount: 0.3)
+      client.learn_domain(domain: :risky_source, amount: 0.8)
+      client.set_similarity(domain_a: :risky_source, domain_b: :target, similarity: 0.4)
+    end
+
+    it 'returns risks hash' do
+      result = client.interference_risks(target_domain: :target)
+      expect(result[:target_domain]).to eq(:target)
+      expect(result[:risks]).to be_an(Array)
+      expect(result[:count]).to eq(result[:risks].size)
+    end
+
+    it 'identifies interference risks' do
+      result = client.interference_risks(target_domain: :target)
+      expect(result[:risks].map { |r| r[:domain] }).to include(:risky_source)
+    end
+  end
+
+  describe '#transfer_report' do
+    it 'returns a report hash' do
+      result = client.transfer_report
+      expect(result).to have_key(:total_transfers)
+      expect(result).to have_key(:domain_count)
+    end
+
+    it 'counts transfers after attempts' do
+      client.learn_domain(domain: :a, amount: 0.8)
+      client.set_similarity(domain_a: :a, domain_b: :b, similarity: 0.7)
+      client.attempt_transfer(from_domain: :a, to_domain: :b)
+      result = client.transfer_report
+      expect(result[:total_transfers]).to eq(1)
+      expect(result[:positive_transfers]).to eq(1)
+    end
+  end
+
+  describe '#get_domain' do
+    it 'returns found: false for unknown domain' do
+      result = client.get_domain(domain: :unknown)
+      expect(result[:found]).to be false
+      expect(result[:domain]).to eq(:unknown)
+    end
+
+    it 'returns found: true for known domain' do
+      client.learn_domain(domain: :ruby, amount: 0.5)
+      result = client.get_domain(domain: :ruby)
+      expect(result[:found]).to be true
+      expect(result[:domain][:domain]).to eq(:ruby)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+end
+
+require 'legion/extensions/transfer_learning'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: lex-transfer-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: Domain knowledge transfer modeling for brain-modeled agentic AI
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lex-transfer-learning.gemspec
+- lib/legion/extensions/transfer_learning.rb
+- lib/legion/extensions/transfer_learning/client.rb
+- lib/legion/extensions/transfer_learning/helpers/constants.rb
+- lib/legion/extensions/transfer_learning/helpers/domain_knowledge.rb
+- lib/legion/extensions/transfer_learning/helpers/transfer_engine.rb
+- lib/legion/extensions/transfer_learning/runners/transfer_learning.rb
+- lib/legion/extensions/transfer_learning/version.rb
+- spec/legion/extensions/transfer_learning/client_spec.rb
+- spec/legion/extensions/transfer_learning/helpers/constants_spec.rb
+- spec/legion/extensions/transfer_learning/helpers/domain_knowledge_spec.rb
+- spec/legion/extensions/transfer_learning/helpers/transfer_engine_spec.rb
+- spec/legion/extensions/transfer_learning/runners/transfer_learning_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-transfer-learning
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-transfer-learning
+  source_code_uri: https://github.com/LegionIO/lex-transfer-learning
+  documentation_uri: https://github.com/LegionIO/lex-transfer-learning
+  changelog_uri: https://github.com/LegionIO/lex-transfer-learning
+  bug_tracker_uri: https://github.com/LegionIO/lex-transfer-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 Transfer Learning
+test_files: []