lex-agentic-learning 0.1.11 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98b0f0afb82cb17c9db706827d06ce2f27e9a69c590170b720bfa986bcb5529d
-  data.tar.gz: d985458466141a279fe4c0b79aaeccf168b15246f6863e2ff7181bf90d88bb31
+  metadata.gz: cecc51a27c68a22d11bae4df4784f6b5eeba66d6621911809596a3f8bba5c03b
+  data.tar.gz: 4190bc8f28519fad9f5acb205c944c88a99f40459dfd1a23ff62a77c3ec39643
 SHA512:
-  metadata.gz: 3bf9d04bee2e5d19aba000ec08d043caa79fd704eea2414adcb89277a88e655784933bc5a358415a3d5a7319b3cc044bee04cc3fd6d2ab6fb74b4f932c3eac1b
-  data.tar.gz: 92193dbf3ffb4efeb3ec9c52751888a3798764652f75bee7b610e8b91e743fc27f286cbbef65eff134fe1adce4c478c6022fe6c650118cfa331f1160b736e122
+  metadata.gz: c79885b2f17dc71be2c0e10f1eb31994e08e9d5b2a0b093fd3576f859a75c8d6c8c4970c2a066eddffac3617b2a0e04a9b9977e6c31a7ddb843a50f232de0c77
+  data.tar.gz: ef96ad14cd80eda16d36821f5a327bdd393fb8cf49ab307307edfd2c0e531ba3b481091998407b1e06c8abf9b5868e48d014b95defa8636f5bc35c95a5a86b73

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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`.
+- OutcomeListener `write_apollo_lesson` now calls `Legion::Apollo.ingest` directly (replacing `ingest_knowledge(content: ...)` which was a dormant `ArgumentError` in Ruby 3.x due to missing positional arg); adds `access_scope: 'private'` and `identity_principal_id: nil`.
+
 ## [0.1.11] - 2026-05-07
 ### Fixed
 - Curiosity self-inquiry now uses native `Legion::LLM.chat` response hashes directly and avoids obsolete legacy LLM fallback calls after native chat succeeds.

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/curiosity/runners/curiosity.rb

@@ -177,15 +177,16 @@ module Legion
               end
 
               def store_insight_in_apollo(question, insight, domain)
-                return unless defined?(Legion::Extensions::Apollo)
+                return unless defined?(Legion::Apollo)
 
-                Legion::Extensions::Apollo.store(
-                  content:      "Self-inquiry insight [#{domain}]: #{question}\n\n#{insight}",
-                  content_type: :observation,
-                  tags:         ['gaia-self-inquiry', "domain-#{domain}", 'autonomous-thought']
+                Legion::Apollo.ingest( # rubocop:disable Legion/HelperMigration/DirectKnowledge
+                  content:               "Self-inquiry insight [#{domain}]: #{question}\n\n#{insight}",
+                  tags:                  ['gaia-self-inquiry', "domain-#{domain}", 'autonomous-thought'],
+                  access_scope:          'private',
+                  identity_principal_id: nil
                 )
               rescue StandardError => e
-                log.warn "[curiosity:self_inquiry] Apollo store failed: #{e.class}: #{e.message}"
+                log.warn "[curiosity:self_inquiry] Apollo ingest failed: #{e.class}: #{e.message}"
               end
 
               def create_wonders_from_gaps(gaps)

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)
@@ -83,11 +114,15 @@ module Legion
               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')
+                Legion::Apollo.ingest( # rubocop:disable Legion/HelperMigration/DirectKnowledge
+                  content:               json_generate(lesson),
+                  tags:                  ['task_outcome', lesson[:domain]].compact,
+                  source_agent:          source_agent,
+                  access_scope:          'private',
+                  content_type:          'task_outcome_lesson',
+                  knowledge_domain:      'learning',
+                  identity_principal_id: nil
+                )
               rescue StandardError => e
                 log.warn "[outcome_listener] apollo write failed: #{e.message}"
               end
@@ -98,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.11'
+        VERSION = '0.1.13'
       end
     end
   end

data/spec/legion/extensions/agentic/learning/curiosity/runners/curiosity_spec.rb

@@ -199,4 +199,58 @@ RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Runners::Curios
       expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to be_nil
     end
   end
+
+  describe '#store_insight_in_apollo' do
+    before do
+      mock_apollo = Module.new do
+        def self.started?
+          true
+        end
+
+        def self.ingest(**)
+          { success: true }
+        end
+      end
+      stub_const('Legion::Apollo', mock_apollo)
+    end
+
+    it 'passes access_scope: private to Legion::Apollo.ingest' do
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:store_insight_in_apollo, 'How does Consul ACL work?', 'found it', 'consul')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(access_scope: 'private')
+      )
+    end
+
+    it 'includes the domain and question in the ingested content' do
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:store_insight_in_apollo, 'What is raft?', 'distributed consensus', 'distributed_systems')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(
+          content: a_string_including('distributed_systems'),
+          tags:    array_including('gaia-self-inquiry', 'domain-distributed_systems')
+        )
+      )
+    end
+
+    it 'is a no-op when Legion::Apollo is not defined' do
+      hide_const('Legion::Apollo')
+      expect { client.send(:store_insight_in_apollo, 'q?', 'insight', 'test') }.not_to raise_error
+    end
+
+    it 'does not inject process identity as the owner' do
+      stub_const('Legion::Identity::Process', Module.new do
+        extend self
+
+        define_method(:identity_hash) do
+          { canonical_name: 'daemon', db_principal_id: 999, db_identity_id: 888 }
+        end
+      end)
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:store_insight_in_apollo, 'q?', 'insight', 'test')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(identity_principal_id: nil)
+      )
+    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,171 @@ 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
+
+  describe '#write_apollo_lesson' do
+    let(:lesson) do
+      { runner_class: 'Http::Get', function: 'fetch', status: 'task.completed',
+        domain: 'http', success: true, confidence: 0.8 }
+    end
+
+    before do
+      mock_apollo = Module.new do
+        def self.ingest(**)
+          { success: true }
+        end
+      end
+      stub_const('Legion::Apollo', mock_apollo)
+    end
+
+    it 'passes access_scope: private to Legion::Apollo.ingest' do
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:write_apollo_lesson, lesson, 'agent-1')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(access_scope: 'private')
+      )
+    end
+
+    it 'includes source_agent in the ingest call' do
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:write_apollo_lesson, lesson, 'agent-99')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(source_agent: 'agent-99')
+      )
+    end
+
+    it 'tags the entry with task_outcome and domain' do
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:write_apollo_lesson, lesson, 'agent-1')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(tags: array_including('task_outcome', 'http'))
+      )
+    end
+
+    it 'is a no-op when Legion::Apollo is not defined' do
+      hide_const('Legion::Apollo')
+      expect { client.send(:write_apollo_lesson, lesson, 'agent-1') }.not_to raise_error
+    end
+
+    it 'does not inject process identity as the owner' do
+      stub_const('Legion::Identity::Process', Module.new do
+        extend self
+
+        define_method(:identity_hash) do
+          { canonical_name: 'daemon', db_principal_id: 999, db_identity_id: 888 }
+        end
+      end)
+      allow(Legion::Apollo).to receive(:ingest).and_return({ success: true })
+      client.send(:write_apollo_lesson, lesson, 'agent-1')
+      expect(Legion::Apollo).to have_received(:ingest).with(
+        hash_including(identity_principal_id: nil)
+      )
     end
   end
 end

metadata

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