legion-apollo 0.5.4 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95c943936a3a2ac751b688b26c676197142ae6c2aa48aa3427a3dc0709cd86bd
-  data.tar.gz: d76f10cc2a7a4984f419489a1df52de501de6878f218f7374575e7b8893e0ad6
+  metadata.gz: 7150a2def38a098c16a2f35362210994cc77537ca6ee3e0e615823cf8e1797c2
+  data.tar.gz: 6e0bfa593f70915134195672dbe321f03c00c86e1f80fee06f5370f3c6578110
 SHA512:
-  metadata.gz: 586271450e0c15b6b493f702b23feeec27020ab37a34ed790246e13215f501b771da84c1c49b475da148aa448791f9eb247cf1722c664ba55ba4b3082c454fea
-  data.tar.gz: be2de9a03d9292ce01293363285ba83bfa0eeb45de922c36fcad298576d9a5ea0c3c6c24ed519c98c4f9707e1b645516fab0ff7ca1630fa061ee294b94747b15
+  metadata.gz: 97783044f23209d697578c0f56d570bc48b9531e5d569f23e4db98bf55cb5d0c4602d6a0fedeb8e7c04a89618d4586c25bc7ca89f1a8d922e8618c5b724cc13e
+  data.tar.gz: 8498fae869abc9f54520b216ed88e2aea006ee6e520d8421d44cf5781c76ae9c158553e3c34a7e9e1e37d44594248a5c6daae1c7b55336c9692e7b668f00fbb4

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.5.5] - 2026-05-15
+
+### Added
+- `Legion::Apollo.ingest` and `Legion::Apollo::Local.ingest`/`upsert` now auto-inject `access_scope` (default `'global'`), `identity_canonical_name`, `identity_principal_id`, and `identity_id` from `Legion::Identity::Process` — zero call-site changes required; guarded by `defined?` so nodes without Identity loaded are unaffected
+- Migration 006 adds the four identity/scope columns to `local_knowledge` with `access_scope` defaulting to `'global'` to match the Phase 1 Postgres schema
+
+### Fixed
+- `query_merged` now forwards `requesting_principal_id` to `Apollo::Local.query` so the access-scope filter is honoured in merged results
+- `Apollo::Local.query` accepts `requesting_principal_id:` and suppresses `private` entries whose `identity_principal_id` does not match the requesting principal (`nil` principal = system/background caller, all entries visible)
+
 ## [0.5.4] - 2026-05-07
 
 ### Fixed

data/lib/legion/apollo/local/migrations/006_add_identity_and_access_scope.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    alter_table(:local_knowledge) do
+      add_column :access_scope,            String, null: false, default: 'global'
+      add_column :identity_canonical_name, String, null: true
+      add_column :identity_principal_id,   Integer, null: true
+      add_column :identity_id,             Integer, null: true
+
+      add_index :access_scope,            name: :idx_local_knowledge_access_scope
+      add_index :identity_principal_id,   name: :idx_local_knowledge_identity_principal_id
+      add_index :identity_id,             name: :idx_local_knowledge_identity_id
+    end
+  end
+
+  down do
+    alter_table(:local_knowledge) do
+      drop_column :access_scope
+      drop_column :identity_canonical_name
+      drop_column :identity_principal_id
+      drop_column :identity_id
+    end
+  end
+end

data/lib/legion/apollo/local.rb

@@ -46,12 +46,13 @@ module Legion
           @started == true
         end
 
-        def ingest(content:, tags: [], **opts) # rubocop:disable Metrics/MethodLength
+        def ingest(content:, tags: [], access_scope: 'global', **opts) # rubocop:disable Metrics/MethodLength
           return not_started_error unless started?
 
           tags = normalize_tags_input(tags)
           WRITE_MUTEX.synchronize do
-            ingest_without_lock(content: content, tags: tags, **opts)
+            ingest_without_lock(content: content, tags: tags,
+                                **inject_identity_context(opts).merge(access_scope: access_scope))
           end
         rescue StandardError => e
           handle_exception(
@@ -64,18 +65,19 @@ module Legion
           { success: false, error: e.message }
         end
 
-        def upsert(content:, tags: [], **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def upsert(content:, tags: [], access_scope: 'global', **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           return not_started_error unless started?
 
           sorted_tags = normalize_tags_input(tags).sort
           tag_json = Legion::JSON.dump(sorted_tags)
+          merged_opts = inject_identity_context(opts).merge(access_scope: access_scope)
           WRITE_MUTEX.synchronize do
             existing = db[:local_knowledge].where(tags: tag_json).first
 
             if existing
-              update_upsert_entry(existing, content, tag_json, opts)
+              update_upsert_entry(existing, content, tag_json, merged_opts)
             else
-              result = ingest_without_lock(content: content, tags: sorted_tags, **opts)
+              result = ingest_without_lock(content: content, tags: sorted_tags, **merged_opts)
               result[:mode] = :inserted if result[:success] && result[:mode] != :deduplicated
               result
             end
@@ -91,7 +93,7 @@ module Legion
           { success: false, error: e.message }
         end
 
-        def query(text:, limit: nil, min_confidence: nil, tags: nil, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+        def query(text:, limit: nil, min_confidence: nil, tags: nil, requesting_principal_id: nil, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/ParameterLists
           return not_started_error unless started?
 
           text = normalize_text_input(text)
@@ -111,7 +113,8 @@ module Legion
           include_history = opts.fetch(:include_history, false)
           candidates = filter_candidates(candidates, min_confidence: min_confidence, tags: tags,
                                                      options: { include_inferences: include_inferences,
-                                                                include_history: include_history, as_of: as_of })
+                                                                include_history: include_history, as_of: as_of,
+                                                                requesting_principal_id: requesting_principal_id })
           candidates = cosine_rerank(text, candidates) if can_rerank?
           results = candidates.first(limit)
 
@@ -496,8 +499,13 @@ module Legion
         end
 
         def ingest_source_columns(opts)
-          { source_channel: opts[:source_channel], source_agent: opts[:source_agent],
-            submitted_by: opts[:submitted_by] }
+          { source_channel:          opts[:source_channel],
+            source_agent:            opts[:source_agent],
+            submitted_by:            opts[:submitted_by],
+            access_scope:            opts[:access_scope] || 'global',
+            identity_canonical_name: opts[:identity_canonical_name],
+            identity_principal_id:   opts[:identity_principal_id],
+            identity_id:             opts[:identity_id] }
         end
 
         def ingest_lineage_columns(opts)
@@ -653,6 +661,13 @@ module Legion
               tag_set.intersect?(entry_tags)
             end
           end
+          pid = options[:requesting_principal_id]
+          if pid
+            candidates = candidates.select do |c|
+              scope = c[:access_scope] || 'global'
+              scope != 'private' || c[:identity_principal_id] == pid
+            end
+          end
           candidates
         end
 
@@ -841,17 +856,21 @@ module Legion
 
           db.transaction do
             db[:local_knowledge].where(id: existing[:id]).update(
-              content:        content,
-              content_hash:   new_hash,
-              tags:           tags_json,
-              embedding:      embedding ? Legion::JSON.dump(embedding) : nil,
-              embedded_at:    embedded_at,
-              confidence:     opts.fetch(:confidence, existing[:confidence]),
-              expires_at:     expires_at,
-              source_channel: opts.fetch(:source_channel, existing[:source_channel]),
-              source_agent:   opts.fetch(:source_agent, existing[:source_agent]),
-              submitted_by:   opts.fetch(:submitted_by, existing[:submitted_by]),
-              updated_at:     now
+              content:                 content,
+              content_hash:            new_hash,
+              tags:                    tags_json,
+              embedding:               embedding ? Legion::JSON.dump(embedding) : nil,
+              embedded_at:             embedded_at,
+              confidence:              opts.fetch(:confidence, existing[:confidence]),
+              expires_at:              expires_at,
+              source_channel:          opts.fetch(:source_channel, existing[:source_channel]),
+              source_agent:            opts.fetch(:source_agent, existing[:source_agent]),
+              submitted_by:            opts.fetch(:submitted_by, existing[:submitted_by]),
+              access_scope:            opts.fetch(:access_scope, existing[:access_scope]) || 'global',
+              identity_canonical_name: opts.fetch(:identity_canonical_name, existing[:identity_canonical_name]),
+              identity_principal_id:   opts.fetch(:identity_principal_id, existing[:identity_principal_id]),
+              identity_id:             opts.fetch(:identity_id, existing[:identity_id]),
+              updated_at:              now
             )
             rebuild_fts_entry!(existing[:id], content, tags_json)
           end
@@ -880,6 +899,20 @@ module Legion
           end
         end
 
+        def inject_identity_context(opts)
+          return opts unless defined?(Legion::Identity::Process)
+
+          id = Legion::Identity::Process.identity_hash
+          {
+            identity_canonical_name: id[:canonical_name],
+            identity_principal_id:   id[:db_principal_id],
+            identity_id:             id[:db_identity_id]
+          }.compact.merge(opts)
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'apollo.local.inject_identity_context')
+          opts
+        end
+
         def not_started_error
           { success: false, error: :not_started }
         end

data/lib/legion/apollo/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Apollo
-    VERSION = '0.5.4'
+    VERSION = '0.5.6'
   end
 end

data/lib/legion/apollo.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'digest'
+require 'legion/json'
 require 'legion/logging'
+require 'legion/settings'
 require_relative 'apollo/version'
 require_relative 'apollo/settings'
 require_relative 'apollo/helpers/tag_normalizer'
@@ -72,6 +74,7 @@ module Legion
         normalized_tags = normalize_tags_input(tags)
         limit          ||= apollo_setting(:default_limit, 5)
         min_confidence ||= apollo_setting(:min_confidence, 0.3)
+        opts = inject_requesting_principal_id(opts)
         log.info { "Apollo query requested scope=#{scope} text_length=#{text.to_s.length} limit=#{limit}" }
         log.debug do
           "Apollo query scope=#{scope} limit=#{limit} min_confidence=#{min_confidence} tags=#{normalized_tags.size}"
@@ -93,13 +96,14 @@ module Legion
         end
       end
 
-      def ingest(content:, tags: [], scope: :global, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      def ingest(content:, tags: [], scope: :global, access_scope: 'global', **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         return not_started_error unless started?
 
         normalized_tags = normalize_tags_input(tags)
         normalized_content = normalize_text_input(content)
         normalized_raw_content = normalize_raw_content_input(opts[:raw_content], fallback: normalized_content)
-        payload = { **opts, content: normalized_content, raw_content: normalized_raw_content, tags: normalized_tags }
+        payload = { **inject_identity_context(opts), content: normalized_content,
+                    raw_content: normalized_raw_content, tags: normalized_tags, access_scope: access_scope }
         log.info do
           "Apollo ingest requested scope=#{scope} content_length=#{payload[:content].to_s.length} " \
             "tags=#{payload[:tags].size} source_channel=#{payload[:source_channel]}"
@@ -290,7 +294,8 @@ module Legion
         end
         result = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags,
                                                              :tier, :include_inferences, :include_history,
-                                                             :as_of))
+                                                             :as_of),
+                                            requesting_principal_id: payload[:requesting_principal_id])
         return result unless result[:success]
 
         entries = normalize_local_entries(Array(result[:results]))
@@ -326,7 +331,8 @@ module Legion
           attempted = true
           local = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags,
                                                               :tier, :include_inferences, :include_history,
-                                                              :as_of))
+                                                              :as_of),
+                                             requesting_principal_id: payload[:requesting_principal_id])
           if local[:success]
             any_success = true
             entries.concat(normalize_local_entries(Array(local[:results]))) if local[:results]
@@ -558,6 +564,33 @@ module Legion
         end
       end
 
+      def inject_identity_context(opts)
+        return opts unless defined?(Legion::Identity::Process)
+
+        id = Legion::Identity::Process.identity_hash
+        {
+          identity_canonical_name: id[:canonical_name],
+          identity_principal_id:   id[:db_principal_id],
+          identity_id:             id[:db_identity_id]
+        }.compact.merge(opts)
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'apollo.inject_identity_context')
+        opts
+      end
+
+      def inject_requesting_principal_id(opts)
+        return opts if opts.key?(:requesting_principal_id)
+        return opts unless defined?(Legion::Identity::Process)
+
+        principal_id = Legion::Identity::Process.db_principal_id
+        return opts if principal_id.nil?
+
+        opts.merge(requesting_principal_id: principal_id)
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'apollo.inject_requesting_principal_id')
+        opts
+      end
+
       def not_started_error
         { success: false, error: :not_started }
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-apollo
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.6
 platform: ruby
 authors:
 - Esity
@@ -88,6 +88,7 @@ files:
 - lib/legion/apollo/local/migrations/003_harden_graph_relationships.rb
 - lib/legion/apollo/local/migrations/004_add_versioning_tiers_inference.rb
 - lib/legion/apollo/local/migrations/005_add_raw_content_temporal_windows.rb
+- lib/legion/apollo/local/migrations/006_add_identity_and_access_scope.rb
 - lib/legion/apollo/messages/access_boost.rb
 - lib/legion/apollo/messages/ingest.rb
 - lib/legion/apollo/messages/query.rb