lex-agentic-learning 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98b0f0afb82cb17c9db706827d06ce2f27e9a69c590170b720bfa986bcb5529d
-  data.tar.gz: d985458466141a279fe4c0b79aaeccf168b15246f6863e2ff7181bf90d88bb31
+  metadata.gz: 0b9c9e5ffb94a852f69565d33096e38bc7314620ce3eb227c38f062b8ea79a13
+  data.tar.gz: a305ff18874b4ebac3878db8f18304f24c5a2f9575a5711d9bd73015b2dd6ee3
 SHA512:
-  metadata.gz: 3bf9d04bee2e5d19aba000ec08d043caa79fd704eea2414adcb89277a88e655784933bc5a358415a3d5a7319b3cc044bee04cc3fd6d2ab6fb74b4f932c3eac1b
-  data.tar.gz: 92193dbf3ffb4efeb3ec9c52751888a3798764652f75bee7b610e8b91e743fc27f286cbbef65eff134fe1adce4c478c6022fe6c650118cfa331f1160b736e122
+  metadata.gz: 78c10230805690d2207721eb815a8bce9bcbbc2c1d4c571d5c417dbd5d1480de5ce059fae848a6415d2a04c0c5bfbf9427ea2942f3d7f70c4a1f54e86277d987
+  data.tar.gz: 7fa6dce7d74b53af81283e29dc590697fd746321f031abe48d4b34f9d5c9c58c0f07eab6725e5b84dcec0abb94cbb15bcea7e529bc28ad960619f8490867709a

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # 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.

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/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.11'
+        VERSION = '0.1.12'
       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/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.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Esity