lex-agentic-learning 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c50a23830ef7370f63b760995907264a4df20b9dfe31355fb536d6a25d0b53a8
-  data.tar.gz: a1d7dce23a94d8e5eefabd9fc4265195c0c8e1b42f50f6f4c724e2060f2b9d83
+  metadata.gz: 31725ad79b661a818e233bd94df4a06db34375f1d863e981ea41f5851fce4040
+  data.tar.gz: b63c48208160bbbbc292fd8a7563d51a53cc5a8bbed4d3cc9aac316bf19a6556
 SHA512:
-  metadata.gz: 5b7893d82240aa11f85aad8544d883b1d24551c46b3ea2c19c9f8bf0c839968b90a3adb4a0d86f22ad63a807071d96ac6d24461729da6e8ed3b34b126ae807aa
-  data.tar.gz: eaa5f171f8f87ed92f01748fb19c820f9fed1ae04048e920cd7f5b95dd4b443cca2c8e9092a2d1a5c83f0b66fec417367a4741b334a91a53358cec35ebdcd76c
+  metadata.gz: 93f6862f753e160b1fa73d2fe10627e765a5a4b85e8e504a3835addee1d4d1544e1081fff84db2ebd179bfce9ef085b1709f3c1bb1b804c65d17db8c30160019
+  data.tar.gz: af4930204eeaaf926ea5a20f01d97a7525412925fdfc90b4535f72b64cea433a687c2c878e55feb186bf177f6750571676860b4461d618c0635e3f1617f637cf

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.1.5] - 2026-03-31
+
+### Added
+- OutcomeListener sub-module: subscription actor wiring task completion events to cognitive model updates (#4)
+- DomainExtractor helper: extracts learning domain from runner class names
+- LessonBuilder helper: generates structured situation-lesson pairs for Apollo persistence
+- MetaLearning, LearningRate, and Scaffolding models updated on each task outcome
+- Per-agent scoped lessons written to Apollo knowledge store
+- Settings toggles: outcome_listener, write_to_apollo, min_lesson_severity
+
+## [0.1.4] - 2026-03-30
+
+### Changed
+- update to rubocop-legion 0.1.7, resolve all offenses
+
 ## [0.1.3] - 2026-03-26
 
 ### Changed

data/Gemfile

@@ -3,3 +3,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'rubocop-legion'

data/lex-agentic-learning.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-transport', '>= 1.3.9'
 
   spec.add_development_dependency 'rspec', '~> 3.13'
-  spec.add_development_dependency 'rubocop', '~> 1.60'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.26'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-legion'
+  spec.add_development_dependency 'rubocop-rspec'
 end

data/lib/legion/extensions/agentic/learning/anchoring/runners/anchoring.rb

@@ -7,8 +7,8 @@ module Legion
         module Anchoring
           module Runners
             module Anchoring
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def record_anchor(value:, domain: :general, **)
                 anchor = anchor_store.add(value: value, domain: domain)

data/lib/legion/extensions/agentic/learning/catalyst/runners/cognitive_catalyst.rb

@@ -7,8 +7,8 @@ module Legion
         module Catalyst
           module Runners
             module CognitiveCatalyst
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_catalyst(catalyst_type:, domain:, potency: nil, specificity: nil, engine: nil, **)
                 e = engine || default_engine

data/lib/legion/extensions/agentic/learning/chrysalis/runners/cognitive_chrysalis.rb

@@ -11,7 +11,7 @@ module Legion
 
               begin
                 include Legion::Extensions::Helpers::Lex # rubocop:disable Layout/EmptyLinesAfterModuleInclusion
-              rescue StandardError
+              rescue StandardError => _e
                 nil
               end
 

data/lib/legion/extensions/agentic/learning/curiosity/runners/curiosity.rb

@@ -8,8 +8,8 @@ module Legion
           module Runners
             # Runner methods for the curiosity engine: gap detection, wonder lifecycle, agenda formation.
             module Curiosity
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def detect_gaps(prior_results: {}, **)
                 gaps = Helpers::GapDetector.detect(prior_results)

data/lib/legion/extensions/agentic/learning/epistemic_curiosity/runners/epistemic_curiosity.rb

@@ -7,8 +7,8 @@ module Legion
         module EpistemicCuriosity
           module Runners
             module EpistemicCuriosity
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_gap(question:, domain:, gap_type: :factual, urgency: Helpers::Constants::DEFAULT_URGENCY, **)
                 result = engine.create_gap(question: question, domain: domain, gap_type: gap_type, urgency: urgency)

data/lib/legion/extensions/agentic/learning/habit/runners/habit.rb

@@ -7,8 +7,8 @@ module Legion
         module Habit
           module Runners
             module Habit
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def observe_action(action:, context: {}, **)
                 log.debug "[habit] observe_action: action=#{action} context=#{context}"

data/lib/legion/extensions/agentic/learning/hebbian/runners/hebbian_assembly.rb

@@ -7,8 +7,8 @@ module Legion
         module Hebbian
           module Runners
             module HebbianAssembly
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def activate_unit(id:, level: 1.0, domain: :general, **)
                 log.debug "[hebbian] activate: id=#{id} level=#{level}"

data/lib/legion/extensions/agentic/learning/learning_rate/runners/learning_rate.rb

@@ -7,8 +7,8 @@ module Legion
         module LearningRate
           module Runners
             module LearningRate
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def record_prediction(correct:, domain: :general, **)
                 rate_model.record_prediction(domain: domain, correct: correct)

data/lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb

@@ -7,8 +7,8 @@ module Legion
         module MetaLearning
           module Runners
             module MetaLearning
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_learning_domain(name:, learning_rate: Helpers::Constants::DEFAULT_LEARNING_RATE,
                                          related_domains: [], **)

data/lib/legion/extensions/agentic/learning/outcome_listener/actors/outcome_listener.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+return unless defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          module Actor
+            class OutcomeListener < Legion::Extensions::Actors::Subscription
+              def runner_class
+                Legion::Extensions::Agentic::Learning::OutcomeListener::Runners::OutcomeListener
+              end
+
+              def runner_function
+                'process_outcome'
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
+                outcome_listener_setting? &&
+                  defined?(Legion::Extensions::Agentic::Learning::OutcomeListener::Runners::OutcomeListener) &&
+                  transport_connected?
+              rescue StandardError => e
+                log.warn "[outcome_listener] enabled? check failed: #{e.message}"
+                false
+              end
+
+              private
+
+              def outcome_listener_setting?
+                return true unless defined?(Legion::Settings)
+
+                Legion::Settings.dig(:agentic, :learning, :outcome_listener) != false
+              rescue StandardError => e
+                log.warn "[outcome_listener] settings check failed: #{e.message}"
+                true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener/client.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/constants'
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor'
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder'
+require 'legion/extensions/agentic/learning/outcome_listener/runners/outcome_listener'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          class Client
+            include Runners::OutcomeListener
+
+            # rubocop:disable ThreadSafety/ClassInstanceVariable
+            class << self
+              def meta_client
+                @meta_client ||= MetaLearning::Client.new
+              end
+
+              def scaffolding_client
+                @scaffolding_client ||= Scaffolding::Client.new
+              end
+
+              def learning_rate_client
+                @learning_rate_client ||= LearningRate::Client.new
+              end
+
+              def domain_map
+                @domain_map ||= {}
+              end
+
+              def reset!
+                @meta_client = nil
+                @scaffolding_client = nil
+                @learning_rate_client = nil
+                @domain_map = nil
+              end
+            end
+            # rubocop:enable ThreadSafety/ClassInstanceVariable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener/helpers/constants.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          module Helpers
+            module Constants
+              DEFAULT_MIN_LESSON_SEVERITY = 0.3
+              COMPLETED_STATUS = 'task.completed'
+              FAILED_STATUS = 'task.failed'
+              DEFAULT_DIFFICULTY = 0.5
+              DEFAULT_CONFIDENCE_SUCCESS = 0.7
+              DEFAULT_CONFIDENCE_FAILURE = 0.5
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          module Helpers
+            module DomainExtractor
+              RUNNER_PATTERN = /Legion::Extensions::(?:Agentic::)?(\w+)/
+
+              module_function
+
+              def extract(runner_class_name)
+                return 'unknown' if runner_class_name.nil? || runner_class_name.empty?
+
+                match = runner_class_name.match(RUNNER_PATTERN)
+                return snake_case(match[1]) if match
+
+                segments = runner_class_name.split('::')
+                return snake_case(segments[-2]) if segments.size >= 2
+
+                snake_case(segments.last)
+              end
+
+              def snake_case(str)
+                str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .downcase
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          module Helpers
+            module LessonBuilder
+              include Constants
+
+              module_function
+
+              def build(runner_class:, domain:, success:, status: nil, function: nil, source_agent: nil) # rubocop:disable Lint/UnusedMethodArgument
+                {
+                  situation:    build_situation(runner_class, function),
+                  outcome:      success ? :success : :failure,
+                  lesson:       build_lesson(domain, success),
+                  domain:       domain,
+                  confidence:   success ? DEFAULT_CONFIDENCE_SUCCESS : DEFAULT_CONFIDENCE_FAILURE,
+                  source_agent: source_agent,
+                  recorded_at:  Time.now.utc
+                }
+              end
+
+              def build_situation(runner_class, function)
+                parts = [runner_class.to_s]
+                parts << "##{function}" if function
+                parts.join
+              end
+
+              def build_lesson(domain, success)
+                if success
+                  "Task in domain '#{domain}' completed successfully"
+                else
+                  "Task in domain '#{domain}' failed — review for corrective action"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener/runners/outcome_listener.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module OutcomeListener
+          module Runners
+            module OutcomeListener
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+
+              def process_outcome(payload = {}, **)
+                runner_class_name = payload[:runner_class].to_s
+                status = payload[:status].to_s
+                domain = Helpers::DomainExtractor.extract(runner_class_name)
+                success = status == Helpers::Constants::COMPLETED_STATUS
+                source_agent = payload[:source_agent] || payload[:agent_id]
+
+                updates = {}
+                updates[:meta_learning] = update_meta_learning_model(domain, success)
+                updates[:learning_rate] = update_learning_rate_model(domain, success)
+                updates[:scaffolding] = update_scaffolding_model(domain, success, payload)
+
+                if write_to_apollo?
+                  lesson = Helpers::LessonBuilder.build(
+                    runner_class: runner_class_name,
+                    function:     payload[:function],
+                    status:       status,
+                    domain:       domain,
+                    success:      success,
+                    source_agent: source_agent
+                  )
+                  write_apollo_lesson(lesson, source_agent) if lesson[:confidence] >= min_lesson_severity
+                  updates[:lesson] = lesson
+                end
+
+                log.debug "[outcome_listener] domain=#{domain} success=#{success} updates=#{updates.keys}"
+                { success: true, domain: domain, outcome: success, updates: updates }
+              end
+
+              private
+
+              def update_meta_learning_model(domain, success)
+                meta = self.class.meta_client
+                domain_id = resolve_domain_id(meta, domain)
+                meta.record_learning_episode(domain_id: domain_id, success: success)
+              rescue StandardError => e
+                log.warn "[outcome_listener] meta_learning update failed: #{e.message}"
+                { error: e.message }
+              end
+
+              def update_learning_rate_model(domain, success)
+                lr = self.class.learning_rate_client
+                lr.record_prediction(correct: success, domain: domain.to_sym)
+              rescue StandardError => e
+                log.warn "[outcome_listener] learning_rate update failed: #{e.message}"
+                { error: e.message }
+              end
+
+              def update_scaffolding_model(domain, success, payload)
+                sc = self.class.scaffolding_client
+                scaffolds = sc.engine.by_domain(domain: domain)
+                return { skipped: true, reason: :no_scaffold } if scaffolds.empty?
+
+                scaffold = scaffolds.first
+                difficulty = payload[:complexity]&.to_f || Helpers::Constants::DEFAULT_DIFFICULTY
+                sc.attempt_scaffolded_task(scaffold_id: scaffold.id, difficulty: difficulty, success: success)
+              rescue StandardError => e
+                log.warn "[outcome_listener] scaffolding update failed: #{e.message}"
+                { error: e.message }
+              end
+
+              def resolve_domain_id(meta, domain)
+                map = self.class.domain_map
+                return map[domain] if map.key?(domain)
+
+                result = meta.create_learning_domain(name: domain)
+                map[domain] = result[:id]
+                result[:id]
+              end
+
+              def write_apollo_lesson(lesson, source_agent)
+                return unless defined?(Legion::Apollo)
+
+                ingest_knowledge(content:          json_generate(lesson),
+                                 content_type:     'task_outcome_lesson',
+                                 tags:             ['task_outcome', lesson[:domain]],
+                                 source_agent:     source_agent,
+                                 knowledge_domain: 'learning')
+              rescue StandardError => e
+                log.warn "[outcome_listener] apollo write failed: #{e.message}"
+              end
+
+              def write_to_apollo?
+                return false unless defined?(Legion::Settings)
+
+                Legion::Settings.dig(:agentic, :learning, :write_to_apollo) != false
+              rescue StandardError => e
+                log.warn "[outcome_listener] write_to_apollo? check failed: #{e.message}"
+                true
+              end
+
+              def min_lesson_severity
+                return Helpers::Constants::DEFAULT_MIN_LESSON_SEVERITY unless defined?(Legion::Settings)
+
+                Legion::Settings.dig(:agentic, :learning, :min_lesson_severity) ||
+                  Helpers::Constants::DEFAULT_MIN_LESSON_SEVERITY
+              rescue StandardError => e
+                log.warn "[outcome_listener] min_lesson_severity check failed: #{e.message}"
+                Helpers::Constants::DEFAULT_MIN_LESSON_SEVERITY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/outcome_listener.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'outcome_listener/client'

data/lib/legion/extensions/agentic/learning/preference_learning/runners/preference_learning.rb

@@ -7,8 +7,8 @@ module Legion
         module PreferenceLearning
           module Runners
             module PreferenceLearning
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def register_preference_option(label:, domain: :general, **)
                 result = preference_engine.register_option(label: label, domain: domain)

data/lib/legion/extensions/agentic/learning/procedural/runners/procedural_learning.rb

@@ -7,8 +7,8 @@ module Legion
         module Procedural
           module Runners
             module ProceduralLearning
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_skill(name:, domain:, **)
                 skill = engine.create_skill(name: name, domain: domain)

data/lib/legion/extensions/agentic/learning/scaffolding/runners/cognitive_scaffolding.rb

@@ -7,8 +7,8 @@ module Legion
         module Scaffolding
           module Runners
             module CognitiveScaffolding
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_scaffold(skill_name:, domain:, competence: nil, **)
                 comp = competence || Helpers::Constants::DEFAULT_COMPETENCE

data/lib/legion/extensions/agentic/learning/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Learning
-        VERSION = '0.1.3'
+        VERSION = '0.1.5'
       end
     end
   end

data/lib/legion/extensions/agentic/learning.rb

@@ -15,12 +15,13 @@ require_relative 'learning/meta_learning'
 require_relative 'learning/preference_learning'
 require_relative 'learning/procedural'
 require_relative 'learning/anchoring'
+require_relative 'learning/outcome_listener'
 
 module Legion
   module Extensions
     module Agentic
       module Learning
-        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
 
         def self.remote_invocable?
           false

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/outcome_listener/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Client do
+  before { described_class.reset! }
+
+  it 'responds to process_outcome' do
+    client = described_class.new
+    expect(client).to respond_to(:process_outcome)
+  end
+
+  describe '.meta_client' do
+    it 'returns a MetaLearning::Client' do
+      expect(described_class.meta_client).to be_a(
+        Legion::Extensions::Agentic::Learning::MetaLearning::Client
+      )
+    end
+
+    it 'returns the same instance on repeated calls' do
+      expect(described_class.meta_client).to equal(described_class.meta_client)
+    end
+  end
+
+  describe '.scaffolding_client' do
+    it 'returns a Scaffolding::Client' do
+      expect(described_class.scaffolding_client).to be_a(
+        Legion::Extensions::Agentic::Learning::Scaffolding::Client
+      )
+    end
+
+    it 'returns the same instance on repeated calls' do
+      expect(described_class.scaffolding_client).to equal(described_class.scaffolding_client)
+    end
+  end
+
+  describe '.learning_rate_client' do
+    it 'returns a LearningRate::Client' do
+      expect(described_class.learning_rate_client).to be_a(
+        Legion::Extensions::Agentic::Learning::LearningRate::Client
+      )
+    end
+
+    it 'returns the same instance on repeated calls' do
+      expect(described_class.learning_rate_client).to equal(described_class.learning_rate_client)
+    end
+  end
+
+  describe '.domain_map' do
+    it 'returns an empty hash initially' do
+      expect(described_class.domain_map).to eq({})
+    end
+
+    it 'persists entries across calls' do
+      described_class.domain_map['test'] = 'id-123'
+      expect(described_class.domain_map['test']).to eq('id-123')
+    end
+  end
+
+  describe '.reset!' do
+    it 'clears all shared state' do
+      described_class.meta_client
+      described_class.scaffolding_client
+      described_class.learning_rate_client
+      described_class.domain_map['test'] = 'id'
+
+      described_class.reset!
+
+      expect(described_class.domain_map).to eq({})
+      expect(described_class.instance_variable_get(:@meta_client)).to be_nil
+      expect(described_class.instance_variable_get(:@scaffolding_client)).to be_nil
+      expect(described_class.instance_variable_get(:@learning_rate_client)).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/constants'
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Helpers::DomainExtractor do
+  describe '.extract' do
+    it 'extracts domain from standard runner class' do
+      expect(described_class.extract('Legion::Extensions::Http::Runners::Get')).to eq('http')
+    end
+
+    it 'extracts domain from agentic runner class' do
+      expect(described_class.extract('Legion::Extensions::Agentic::Learning::MetaLearning::Runners::MetaLearning'))
+        .to eq('learning')
+    end
+
+    it 'handles consul extension' do
+      expect(described_class.extract('Legion::Extensions::Consul::Runners::Kv')).to eq('consul')
+    end
+
+    it 'handles camel case domains' do
+      expect(described_class.extract('Legion::Extensions::SwarmGithub::Runners::Issue')).to eq('swarm_github')
+    end
+
+    it 'returns unknown for nil input' do
+      expect(described_class.extract(nil)).to eq('unknown')
+    end
+
+    it 'returns unknown for empty string' do
+      expect(described_class.extract('')).to eq('unknown')
+    end
+
+    it 'falls back to second-to-last segment for non-standard format' do
+      expect(described_class.extract('Custom::Runner::DoWork')).to eq('runner')
+    end
+
+    it 'handles single segment' do
+      expect(described_class.extract('Worker')).to eq('worker')
+    end
+  end
+
+  describe '.snake_case' do
+    it 'converts CamelCase to snake_case' do
+      expect(described_class.snake_case('SwarmGithub')).to eq('swarm_github')
+    end
+
+    it 'converts simple word' do
+      expect(described_class.snake_case('Http')).to eq('http')
+    end
+
+    it 'handles consecutive capitals' do
+      expect(described_class.snake_case('LLMGateway')).to eq('llm_gateway')
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/constants'
+require 'legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Helpers::LessonBuilder do
+  describe '.build' do
+    let(:success_lesson) do
+      described_class.build(
+        runner_class: 'Legion::Extensions::Http::Runners::Get',
+        function:     'fetch',
+        status:       'task.completed',
+        domain:       'http',
+        success:      true,
+        source_agent: 'agent-1'
+      )
+    end
+
+    let(:failure_lesson) do
+      described_class.build(
+        runner_class: 'Legion::Extensions::Consul::Runners::Kv',
+        function:     'put',
+        status:       'task.failed',
+        domain:       'consul',
+        success:      false,
+        source_agent: 'agent-2'
+      )
+    end
+
+    it 'builds a success lesson with correct outcome' do
+      expect(success_lesson[:outcome]).to eq(:success)
+    end
+
+    it 'builds a failure lesson with correct outcome' do
+      expect(failure_lesson[:outcome]).to eq(:failure)
+    end
+
+    it 'includes situation with runner class and function' do
+      expect(success_lesson[:situation]).to eq('Legion::Extensions::Http::Runners::Get#fetch')
+    end
+
+    it 'includes domain' do
+      expect(success_lesson[:domain]).to eq('http')
+    end
+
+    it 'assigns higher confidence to successes' do
+      expect(success_lesson[:confidence]).to be > failure_lesson[:confidence]
+    end
+
+    it 'includes source_agent' do
+      expect(success_lesson[:source_agent]).to eq('agent-1')
+    end
+
+    it 'includes recorded_at timestamp' do
+      expect(success_lesson[:recorded_at]).to be_a(Time)
+    end
+
+    it 'builds lesson text for success' do
+      expect(success_lesson[:lesson]).to include('completed successfully')
+    end
+
+    it 'builds lesson text for failure' do
+      expect(failure_lesson[:lesson]).to include('failed')
+    end
+  end
+
+  describe '.build_situation' do
+    it 'combines runner_class and function' do
+      result = described_class.build_situation('MyRunner', 'do_work')
+      expect(result).to eq('MyRunner#do_work')
+    end
+
+    it 'omits function when nil' do
+      result = described_class.build_situation('MyRunner', nil)
+      expect(result).to eq('MyRunner')
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/outcome_listener/runners/outcome_listener_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/outcome_listener/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Runners::OutcomeListener do
+  let(:client) { Legion::Extensions::Agentic::Learning::OutcomeListener::Client.new }
+
+  before { Legion::Extensions::Agentic::Learning::OutcomeListener::Client.reset! }
+
+  let(:completed_payload) do
+    {
+      runner_class: 'Legion::Extensions::Http::Runners::Get',
+      function:     'fetch',
+      status:       'task.completed',
+      source_agent: 'agent-1'
+    }
+  end
+
+  let(:failed_payload) do
+    {
+      runner_class: 'Legion::Extensions::Consul::Runners::Kv',
+      function:     'put',
+      status:       'task.failed',
+      source_agent: 'agent-2'
+    }
+  end
+
+  describe '#process_outcome' do
+    it 'returns success hash for completed task' do
+      result = client.process_outcome(completed_payload)
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq('http')
+      expect(result[:outcome]).to be true
+    end
+
+    it 'returns success hash for failed task' do
+      result = client.process_outcome(failed_payload)
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq('consul')
+      expect(result[:outcome]).to be false
+    end
+
+    it 'updates meta_learning model on completion' do
+      result = client.process_outcome(completed_payload)
+      episode = result[:updates][:meta_learning]
+      expect(episode[:success]).to be true
+      expect(episode[:domain_name]).to eq('http')
+    end
+
+    it 'updates meta_learning model on failure' do
+      result = client.process_outcome(failed_payload)
+      episode = result[:updates][:meta_learning]
+      expect(episode[:success]).to be false
+    end
+
+    it 'updates learning_rate model' do
+      result = client.process_outcome(completed_payload)
+      lr = result[:updates][:learning_rate]
+      expect(lr[:success]).to be true
+      expect(lr[:domain]).to eq(:http)
+    end
+
+    it 'skips scaffolding when no scaffold exists for domain' do
+      result = client.process_outcome(completed_payload)
+      scaffolding = result[:updates][:scaffolding]
+      expect(scaffolding[:skipped]).to be true
+      expect(scaffolding[:reason]).to eq(:no_scaffold)
+    end
+
+    it 'updates scaffolding when scaffold exists for domain' do
+      sc = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.scaffolding_client
+      sc.create_scaffold(skill_name: 'http_requests', domain: 'http')
+      result = client.process_outcome(completed_payload)
+      scaffolding = result[:updates][:scaffolding]
+      expect(scaffolding[:success]).to be true
+    end
+
+    it 'uses payload complexity for scaffolding difficulty' do
+      sc = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.scaffolding_client
+      scaffold_result = sc.create_scaffold(skill_name: 'consul_kv', domain: 'consul')
+      original_competence = scaffold_result[:scaffold][:competence]
+
+      client.process_outcome(failed_payload.merge(complexity: 0.9))
+      scaffolding_client = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.scaffolding_client
+      scaffold = scaffolding_client.engine.by_domain(domain: 'consul').first
+      expect(scaffold.competence).to be < original_competence
+    end
+
+    it 'creates domain in meta_learning on first encounter' do
+      client.process_outcome(completed_payload)
+      meta = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client
+      stats = meta.meta_learning_stats
+      expect(stats[:domain_count]).to eq(1)
+    end
+
+    it 'reuses existing domain on subsequent outcomes' do
+      client.process_outcome(completed_payload)
+      client.process_outcome(completed_payload)
+      meta = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client
+      stats = meta.meta_learning_stats
+      expect(stats[:domain_count]).to eq(1)
+    end
+
+    it 'accumulates proficiency across multiple successes' do
+      3.times { client.process_outcome(completed_payload) }
+      meta = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client
+      domain_id = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.domain_map['http']
+      episodes = meta.send(:engine).domains[domain_id]
+      expect(episodes.proficiency).to be > 0.0
+    end
+
+    it 'handles empty payload gracefully' do
+      result = client.process_outcome({})
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq('unknown')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-learning
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Esity
@@ -125,30 +125,44 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.60'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.60'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-legion
+  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'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '0'
 description: 'LEX agentic learning domain: adaptation, memory consolidation, skill
   acquisition'
 email:
@@ -239,6 +253,13 @@ files:
 - lib/legion/extensions/agentic/learning/meta_learning/helpers/strategy.rb
 - lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb
 - lib/legion/extensions/agentic/learning/meta_learning/version.rb
+- lib/legion/extensions/agentic/learning/outcome_listener.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/actors/outcome_listener.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/client.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/helpers/constants.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder.rb
+- lib/legion/extensions/agentic/learning/outcome_listener/runners/outcome_listener.rb
 - lib/legion/extensions/agentic/learning/plasticity.rb
 - lib/legion/extensions/agentic/learning/plasticity/client.rb
 - lib/legion/extensions/agentic/learning/plasticity/helpers/constants.rb
@@ -327,6 +348,10 @@ files:
 - spec/legion/extensions/agentic/learning/meta_learning/helpers/meta_learning_engine_spec.rb
 - spec/legion/extensions/agentic/learning/meta_learning/helpers/strategy_spec.rb
 - spec/legion/extensions/agentic/learning/meta_learning/runners/meta_learning_spec.rb
+- spec/legion/extensions/agentic/learning/outcome_listener/client_spec.rb
+- spec/legion/extensions/agentic/learning/outcome_listener/helpers/domain_extractor_spec.rb
+- spec/legion/extensions/agentic/learning/outcome_listener/helpers/lesson_builder_spec.rb
+- spec/legion/extensions/agentic/learning/outcome_listener/runners/outcome_listener_spec.rb
 - spec/legion/extensions/agentic/learning/plasticity/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/learning/plasticity/helpers/neural_pathway_spec.rb
 - spec/legion/extensions/agentic/learning/plasticity/helpers/plasticity_engine_spec.rb