lex-agentic-learning 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4da6d50340dafa221b40f6c63e1af34678d45c2729be6d3b2e67701ea6ee19a
-  data.tar.gz: f485edff0dacee93438320daf14fb9171b5685a51afeba146e4c70f1fe10e0cb
+  metadata.gz: 0b9c9e5ffb94a852f69565d33096e38bc7314620ce3eb227c38f062b8ea79a13
+  data.tar.gz: a305ff18874b4ebac3878db8f18304f24c5a2f9575a5711d9bd73015b2dd6ee3
 SHA512:
-  metadata.gz: c5cc7fb0ac840ea9b1f3f0914f26c395a36ca2a6f8cbc3e03dbc33ab13c0140bd5b5dba73e22fb7879e7fe7f5b6f82c4d2202c594cbcd781c1a6a292ea1f0fe1
-  data.tar.gz: fb6446f01f7d2b0659b98e51971248c2f2d913df1c952cc0e4aa083973e3302aa205e0e5132e1ac47f6cc7723db6db76b55720f2a6e1a0e0d6bea36cc3075e74
+  metadata.gz: 78c10230805690d2207721eb815a8bce9bcbbc2c1d4c571d5c417dbd5d1480de5ce059fae848a6415d2a04c0c5bfbf9427ea2942f3d7f70c4a1f54e86277d987
+  data.tar.gz: 7fa6dce7d74b53af81283e29dc590697fd746321f031abe48d4b34f9d5c9c58c0f07eab6725e5b84dcec0abb94cbb15bcea7e529bc28ad960619f8490867709a

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [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.
+
 ## [0.1.10] - 2026-04-28
 ### Fixed
 - Curiosity self-inquiry now prefers the current `Legion::LLM.ask` router before legacy helper fallbacks, preventing old `lex(:llm, :complete)` failures from hiding native LLM availability.

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

@@ -136,20 +136,15 @@ module Legion
               def query_llm_for_wonder(question, domain)
                 prompt = build_self_inquiry_prompt(question, domain)
 
-                # Prefer the current legion-llm router; legacy helper paths are fallbacks only.
-                if defined?(Legion::LLM) && Legion::LLM.respond_to?(:ask)
-                  result = Legion::LLM.ask(message: prompt) # rubocop:disable Legion/HelperMigration/DirectLlm
-                  text = extract_llm_text(result)
-                  return text if text && !text.empty?
-                end
-
-                if respond_to?(:lex, true)
-                  text = query_legacy_lex_llm(prompt)
-                  return text if text && !text.empty?
-                end
-
-                if defined?(Legion::LLM) && Legion::LLM.respond_to?(:complete)
-                  result = Legion::LLM.complete(prompt: prompt, max_tokens: 300)
+                if defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat)
+                  result = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+                    message: prompt,
+                    caller:  {
+                      extension: 'lex-agentic-learning',
+                      operation: 'curiosity',
+                      phase:     'self_inquiry'
+                    }
+                  )
                   text = extract_llm_text(result)
                   return text if text && !text.empty?
                 end
@@ -160,19 +155,13 @@ module Legion
                 nil
               end
 
-              def query_legacy_lex_llm(prompt)
-                result = lex(:llm, :complete, prompt: prompt, max_tokens: 300)
-                extract_llm_text(result)
-              rescue StandardError => e
-                log.warn "[curiosity:self_inquiry] legacy lex LLM query failed: #{e.class}: #{e.message}"
-                nil
-              end
-
               def extract_llm_text(result)
                 return result.strip if result.is_a?(String)
+                return result.content.to_s.strip if result.respond_to?(:content)
                 return nil unless result.is_a?(Hash)
 
-                text = result[:response] || result[:content] || result[:text] || result[:completion]
+                text = result[:response] || result[:content] || result[:text] || result[:completion] ||
+                       result.dig(:message, :content) || result.dig('message', 'content')
                 text&.to_s&.strip
               end
 
@@ -188,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/runners/outcome_listener.rb

@@ -83,11 +83,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

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

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

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

@@ -163,12 +163,12 @@ RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Runners::Curios
       allow(client).to receive(:respond_to?).with(:lex, true).and_return(false)
     end
 
-    it 'uses Legion::LLM.ask response hashes for current legion-llm' do
+    it 'uses Legion::LLM.chat response hashes for current legion-llm' do
       llm = Module.new do
-        def self.ask(message:)
+        def self.chat(message:, **)
           raise 'missing prompt' if message.to_s.empty?
 
-          { response: '  useful insight  ' }
+          { content: '  useful insight  ' }
         end
       end
       stub_const('Legion::LLM', llm)
@@ -176,33 +176,81 @@ RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Runners::Curios
       expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to eq('useful insight')
     end
 
-    it 'does not let legacy lex complete failures hide current Legion::LLM.ask' do
+    it 'does not call legacy LLM paths when native chat succeeds' do
       allow(client).to receive(:respond_to?).with(:lex, true).and_return(true)
-      allow(client).to receive(:lex).and_raise(StandardError, 'legacy unavailable')
+      expect(client).not_to receive(:lex)
 
       llm = Module.new do
-        def self.ask(message:)
+        def self.chat(message:, **)
           raise 'missing prompt' if message.to_s.empty?
 
-          { response: 'ask survived' }
+          { content: 'chat survived' }
         end
       end
       stub_const('Legion::LLM', llm)
 
-      expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to eq('ask survived')
+      expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to eq('chat survived')
     end
 
-    it 'keeps legacy Legion::LLM.complete fallback for older installs' do
-      llm = Module.new do
-        def self.complete(prompt:, max_tokens:)
-          raise 'missing prompt' if prompt.to_s.empty? || max_tokens != 300
+    it 'returns nil when native chat is unavailable' do
+      llm = Module.new
+      stub_const('Legion::LLM', llm)
+
+      expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to be_nil
+    end
+  end
 
-          { content: 'legacy insight' }
+  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::LLM', llm)
+      stub_const('Legion::Apollo', mock_apollo)
+    end
 
-      expect(client.send(:query_llm_for_wonder, 'why?', :curiosity)).to eq('legacy insight')
+    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/runners/outcome_listener_spec.rb

@@ -115,4 +115,64 @@ RSpec.describe Legion::Extensions::Agentic::Learning::OutcomeListener::Runners::
       expect(result[:domain]).to eq('unknown')
     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.10
+  version: 0.1.12
 platform: ruby
 authors:
 - Esity