lex-agentic-learning 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b9c9e5ffb94a852f69565d33096e38bc7314620ce3eb227c38f062b8ea79a13
-  data.tar.gz: a305ff18874b4ebac3878db8f18304f24c5a2f9575a5711d9bd73015b2dd6ee3
+  metadata.gz: cecc51a27c68a22d11bae4df4784f6b5eeba66d6621911809596a3f8bba5c03b
+  data.tar.gz: 4190bc8f28519fad9f5acb205c944c88a99f40459dfd1a23ff62a77c3ec39643
 SHA512:
-  metadata.gz: 78c10230805690d2207721eb815a8bce9bcbbc2c1d4c571d5c417dbd5d1480de5ce059fae848a6415d2a04c0c5bfbf9427ea2942f3d7f70c4a1f54e86277d987
-  data.tar.gz: 7fa6dce7d74b53af81283e29dc590697fd746321f031abe48d4b34f9d5c9c58c0f07eab6725e5b84dcec0abb94cbb15bcea7e529bc28ad960619f8490867709a
+  metadata.gz: c79885b2f17dc71be2c0e10f1eb31994e08e9d5b2a0b093fd3576f859a75c8d6c8c4970c2a066eddffac3617b2a0e04a9b9977e6c31a7ddb843a50f232de0c77
+  data.tar.gz: ef96ad14cd80eda16d36821f5a327bdd393fb8cf49ab307307edfd2c0e531ba3b481091998407b1e06c8abf9b5868e48d014b95defa8636f5bc35c95a5a86b73

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.13] - 2026-10-29
+### Fixed
+- Accept framework keyword/module outcome dispatch and reject unknown statuses or missing task attribution without updating learning models.
+- Deduplicate explicit transport message identities across concurrent listener clients using bounded process-local history and a stable, eagerly initialized lock shared with state resets; repeated task IDs remain distinct executions.
+- Report model update failures and identify task lessons as technical execution evidence, not demonstrated human acceptance.
+- Fail closed when Apollo publication settings cannot be read. Event subscription activation and durable deduplication are unchanged.
+
 ## [0.1.12] - 2026-05-15
 ### Fixed
 - Curiosity `store_insight_in_apollo` now calls `Legion::Apollo.ingest` directly (replacing `Legion::Extensions::Apollo.store` which was a non-existent method and silently failed on every call); adds `access_scope: 'private'` and `identity_principal_id: nil`.

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for learning, adaptation, and knowledge acquisition. Bu
 ## Overview
 
 **Gem**: `lex-agentic-learning`
-**Version**: 0.1.10
+**Version**: 0.1.13
 **Namespace**: `Legion::Extensions::Agentic::Learning`
 
 ## Sub-Modules

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

@@ -14,7 +14,7 @@ module Legion
               end
 
               begin
-                include Legion::Extensions::Helpers::Lex # rubocop:disable Layout/EmptyLinesAfterModuleInclusion
+                include Legion::Extensions::Helpers::Lex
               rescue StandardError => e
                 log.error "[cognitive_chrysalis] failed to include Helpers::Lex: #{e.class}: #{e.message}"
               end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'legion/extensions/agentic/learning/meta_learning/client'
+require 'legion/extensions/agentic/learning/scaffolding/client'
+require 'legion/extensions/agentic/learning/learning_rate/client'
 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'
@@ -13,32 +16,42 @@ module Legion
           class Client
             include Runners::OutcomeListener
 
-            # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @outcome_mutex = Mutex.new
+
+            # rubocop:disable-next ThreadSafety/ClassInstanceVariable
             class << self
+              attr_reader :outcome_mutex
+
               def meta_client
-                @meta_client ||= MetaLearning::Client.new
+                @meta_client ||= Legion::Extensions::Agentic::Learning::MetaLearning::Client.new
               end
 
               def scaffolding_client
-                @scaffolding_client ||= Scaffolding::Client.new
+                @scaffolding_client ||= Legion::Extensions::Agentic::Learning::Scaffolding::Client.new
               end
 
               def learning_rate_client
-                @learning_rate_client ||= LearningRate::Client.new
+                @learning_rate_client ||= Legion::Extensions::Agentic::Learning::LearningRate::Client.new
               end
 
               def domain_map
                 @domain_map ||= {}
               end
 
+              def processed_outcomes
+                @processed_outcomes ||= {}
+              end
+
               def reset!
-                @meta_client = nil
-                @scaffolding_client = nil
-                @learning_rate_client = nil
-                @domain_map = nil
+                outcome_mutex.synchronize do
+                  @meta_client = nil
+                  @scaffolding_client = nil
+                  @learning_rate_client = nil
+                  @domain_map = nil
+                  @processed_outcomes = nil
+                end
               end
             end
-            # rubocop:enable ThreadSafety/ClassInstanceVariable
           end
         end
       end

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

@@ -10,6 +10,8 @@ module Legion
               DEFAULT_MIN_LESSON_SEVERITY = 0.3
               COMPLETED_STATUS = 'task.completed'
               FAILED_STATUS = 'task.failed'
+              EXCEPTION_STATUS = 'task.exception'
+              MAX_OUTCOME_HISTORY = 1000
               DEFAULT_DIFFICULTY = 0.5
               DEFAULT_CONFIDENCE_SUCCESS = 0.7
               DEFAULT_CONFIDENCE_FAILURE = 0.5

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

@@ -11,10 +11,11 @@ module Legion
 
               module_function
 
-              def build(runner_class:, domain:, success:, status: nil, function: nil, source_agent: nil) # rubocop:disable Lint/UnusedMethodArgument
+              def build(runner_class:, domain:, success:, function: nil, source_agent: nil)
                 {
                   situation:    build_situation(runner_class, function),
                   outcome:      success ? :success : :failure,
+                  evidence:     :technical_execution,
                   lesson:       build_lesson(domain, success),
                   domain:       domain,
                   confidence:   success ? DEFAULT_CONFIDENCE_SUCCESS : DEFAULT_CONFIDENCE_FAILURE,
@@ -31,9 +32,9 @@ module Legion
 
               def build_lesson(domain, success)
                 if success
-                  "Task in domain '#{domain}' completed successfully"
+                  "Task execution in domain '#{domain}' completed without an exception"
                 else
-                  "Task in domain '#{domain}' failed — review for corrective action"
+                  "Task execution in domain '#{domain}' failed — review for corrective action"
                 end
               end
             end

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

@@ -10,7 +10,40 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def process_outcome(payload = {}, **)
+              def process_outcome(payload = {}, **options)
+                payload = payload.merge(options)
+                status = payload[:status].to_s
+                unless [Helpers::Constants::COMPLETED_STATUS, Helpers::Constants::FAILED_STATUS,
+                        Helpers::Constants::EXCEPTION_STATUS].include?(status)
+                  return { success: false, skipped: true, reason: :unrecognized_status, outcome: nil }
+                end
+                if payload[:runner_class].to_s.strip.empty? || payload[:function].to_s.strip.empty?
+                  return { success: false, skipped: true, reason: :missing_task_context, outcome: nil }
+                end
+
+                owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+                owner.outcome_mutex.synchronize do
+                  process_unique_outcome(payload, owner)
+                end
+              end
+
+              private
+
+              def process_unique_outcome(payload, owner)
+                message_id = payload[:message_id]
+                key = [payload[:source_agent] || payload[:agent_id], message_id]
+                tracked = !message_id.to_s.strip.empty?
+                return owner.processed_outcomes[key].merge(skipped: true, reason: :duplicate_outcome) if tracked && owner.processed_outcomes.key?(key)
+
+                result = process_task_outcome(payload)
+                if tracked
+                  owner.processed_outcomes[key] = result
+                  owner.processed_outcomes.shift while owner.processed_outcomes.size > Helpers::Constants::MAX_OUTCOME_HISTORY
+                end
+                result
+              end
+
+              def process_task_outcome(payload)
                 runner_class_name = payload[:runner_class].to_s
                 status = payload[:status].to_s
                 domain = Helpers::DomainExtractor.extract(runner_class_name)
@@ -26,7 +59,6 @@ module Legion
                   lesson = Helpers::LessonBuilder.build(
                     runner_class: runner_class_name,
                     function:     payload[:function],
-                    status:       status,
                     domain:       domain,
                     success:      success,
                     source_agent: source_agent
@@ -36,13 +68,12 @@ module Legion
                 end
 
                 log.debug "[outcome_listener] domain=#{domain} success=#{success} updates=#{updates.keys}"
-                { success: true, domain: domain, outcome: success, updates: updates }
+                { success: updates.values.none? { |update| update.key?(:error) },
+                  domain: domain, outcome: success, evidence: :technical_execution, updates: updates }
               end
 
-              private
-
               def update_meta_learning_model(domain, success)
-                meta = self.class.meta_client
+                meta = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client
                 domain_id = resolve_domain_id(meta, domain)
                 meta.record_learning_episode(domain_id: domain_id, success: success)
               rescue StandardError => e
@@ -51,7 +82,7 @@ module Legion
               end
 
               def update_learning_rate_model(domain, success)
-                lr = self.class.learning_rate_client
+                lr = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.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}"
@@ -59,7 +90,7 @@ module Legion
               end
 
               def update_scaffolding_model(domain, success, payload)
-                sc = self.class.scaffolding_client
+                sc = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.scaffolding_client
                 scaffolds = sc.engine.by_domain(domain: domain)
                 return { skipped: true, reason: :no_scaffold } if scaffolds.empty?
 
@@ -72,7 +103,7 @@ module Legion
               end
 
               def resolve_domain_id(meta, domain)
-                map = self.class.domain_map
+                map = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.domain_map
                 return map[domain] if map.key?(domain)
 
                 result = meta.create_learning_domain(name: domain)
@@ -102,7 +133,7 @@ module Legion
                 Legion::Settings.dig(:agentic, :learning, :write_to_apollo) != false
               rescue StandardError => e
                 log.warn "[outcome_listener] write_to_apollo? check failed: #{e.message}"
-                true
+                false
               end
 
               def min_lesson_severity

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Learning
-        VERSION = '0.1.12'
+        VERSION = '0.1.13'
       end
     end
   end

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

@@ -9,7 +9,6 @@ RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Helpers::
       described_class.build(
         runner_class: 'Legion::Extensions::Http::Runners::Get',
         function:     'fetch',
-        status:       'task.completed',
         domain:       'http',
         success:      true,
         source_agent: 'agent-1'
@@ -20,7 +19,6 @@ RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Helpers::
       described_class.build(
         runner_class: 'Legion::Extensions::Consul::Runners::Kv',
         function:     'put',
-        status:       'task.failed',
         domain:       'consul',
         success:      false,
         source_agent: 'agent-2'
@@ -54,14 +52,6 @@ RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Helpers::
     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

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

@@ -109,10 +109,111 @@ RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Runners::
       expect(episodes.proficiency).to be > 0.0
     end
 
-    it 'handles empty payload gracefully' do
+    it 'ignores missing outcomes without creating learning state' do
       result = client.process_outcome({})
+      expect(result).to include(success: false, skipped: true, outcome: nil)
+      expect(Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client.meta_learning_stats[:episode_count]).to eq(0)
+    end
+
+    it 'consumes keyword-dispatched technical failures from the current runner' do
+      result = client.process_outcome(**failed_payload, status: 'task.exception')
+      expect(result).to include(success: true, outcome: false, evidence: :technical_execution)
+      expect(result[:updates][:meta_learning]).to include(domain_name: 'consul', success: false)
+    end
+
+    it 'ignores nonterminal and unrecognized statuses without changing existing learning' do
+      client.process_outcome(completed_payload)
+      owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+      before = owner.meta_client.learning_domain_ranking
+
+      [nil, 'task.queued', 'transformer.succeeded', 'unexpected'].each do |status|
+        result = client.process_outcome(**completed_payload, status: status)
+        expect(result).to include(success: false, skipped: true, reason: :unrecognized_status, outcome: nil)
+      end
+
+      expect(owner.meta_client.learning_domain_ranking).to eq(before)
+      expect(owner.meta_client.meta_learning_stats[:episode_count]).to eq(1)
+    end
+
+    it 'does not attribute context-free transport status updates to an unknown domain' do
+      result = client.process_outcome(task_id: 42, status: 'task.completed')
+      expect(result).to include(success: false, reason: :missing_task_context)
+      expect(Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client.meta_learning_stats[:domain_count]).to eq(0)
+    end
+
+    it 'does not reinforce a redelivered identified outcome twice across clients' do
+      payload = completed_payload.merge(task_id: 42, message_id: 'delivery-1')
+      client.process_outcome(**payload)
+      other = Legion::Extensions::Agentic::Learning::OutcomeListener::Client.new
+      result = other.process_outcome(**payload)
+      expect(result).to include(skipped: true, reason: :duplicate_outcome)
+      expect(Legion::Extensions::Agentic::Learning::OutcomeListener::Client.meta_client.meta_learning_stats[:episode_count]).to eq(1)
+    end
+
+    it 'reinforces concurrent redeliveries only once per shared state lifecycle' do
+      owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+      payload = completed_payload.merge(message_id: 'concurrent-delivery')
+
+      2.times do
+        ready = Queue.new
+        start = Queue.new
+        workers = Array.new(8) do
+          Thread.new do
+            listener = owner.new
+            ready << true
+            start.pop
+            listener.process_outcome(**payload)
+          end
+        end
+        workers.size.times { ready.pop }
+        workers.size.times { start << true }
+        results = workers.map(&:value)
+
+        expect(results.count { |result| result[:reason] == :duplicate_outcome }).to eq(7)
+        expect(results).to all(include(success: true, outcome: true))
+        expect(owner.meta_client.meta_learning_stats[:episode_count]).to eq(1)
+        owner.reset!
+      end
+    end
+
+    it 'keeps different agents and a later terminal status distinct' do
+      payload = completed_payload.merge(task_id: 42, message_id: 'delivery-1')
+      client.process_outcome(**payload)
+      client.process_outcome(**payload, source_agent: 'agent-2')
+      client.process_outcome(**payload, status: 'task.exception', message_id: 'delivery-2')
+      owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+      domain = owner.meta_client.learning_domain_ranking[:ranking].first
+      expect(domain).to include(successes: 2, failures: 1)
+    end
+
+    it 'does not treat repeated task IDs as delivery identities' do
+      2.times { client.process_outcome(**completed_payload, task_id: 42) }
+      owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+      expect(owner.meta_client.meta_learning_stats[:episode_count]).to eq(2)
+    end
+
+    it 'updates the same scaffold decision when invoked as a framework runner module' do
+      owner = Legion::Extensions::Agentic::Learning::OutcomeListener::Client
+      scaffold = owner.scaffolding_client.create_scaffold(skill_name: 'http_requests', domain: 'http')
+      id = scaffold[:scaffold][:id]
+      before = owner.scaffolding_client.recommend_scaffolded_task(scaffold_id: id)
+      runner = Module.new
+      runner.extend(described_class)
+      result = runner.process_outcome(**completed_payload)
+
       expect(result[:success]).to be true
-      expect(result[:domain]).to eq('unknown')
+      after = owner.scaffolding_client.recommend_scaffolded_task(scaffold_id: id)
+      expect(after[:recommendation][:difficulty]).to be > before[:recommendation][:difficulty]
+      expect(owner.meta_client.meta_learning_stats[:episode_count]).to eq(1)
+    end
+
+    it 'fails closed when the lesson publication setting cannot be read' do
+      allow(Legion::Settings).to receive(:dig).with(:agentic, :learning, :write_to_apollo).and_raise(IOError, 'unavailable')
+      apollo = Module.new
+      stub_const('Legion::Apollo', apollo)
+      expect(apollo).not_to receive(:ingest)
+
+      expect(client.process_outcome(**completed_payload)[:success]).to be true
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-learning
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Esity