legion-apollo 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7468f022e582731ace40da083285569d57c98e38ef375e5745f43d93e9c9d171
-  data.tar.gz: 3d2bb59a17a6060e690c7321fc914d2dc2e2bdd7bb1ec108917bf86fc7f26c72
+  metadata.gz: 37c9cddf7269f0a38272eeedb3fe3f3abb50440271b4ec9686820307233fe12f
+  data.tar.gz: 28962732f0a157e4e6f5abbf2ad494cd4d9fdb56f9d3723de3d074710143118e
 SHA512:
-  metadata.gz: a47cb6e18c47432ec0f3a15872f52dc193d7253fda94833da1c63d6046ad39bba8894f10dacc1c3472d7ef538157aad39cf1cf9894061623a9f1a162f69a5c16
-  data.tar.gz: 3ca7dc35c483089a4b2c6bb0af57b524afe3a3cce571b893a14a4aa01f74fbb01b51b5eb09040389db09a6b5f2516d0bd6d97fc499bf8c912aadc6c3b622a587
+  metadata.gz: f1a1999ff0d3731d67af120efc58c215faeccc6a278ba02c11bfbc84f45dfb50520556e7966bdc6ee9a29a7744cdd61ac3cbc31f99b5112a0c7c3a82e2011141
+  data.tar.gz: f4421e4ace8b3e735ae78012e8579a052ee054f2f1a72160cf401f47fcf74fef3ab96925d567378804fadcd84f290c774cdaf73ecc24d94f8fdf23427b9b76bf

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.5.0] - 2026-04-18
+
+### Added
+- Migration 004: versioning, tiers, inference, expiry metadata, and source linkage columns on `local_knowledge`; `local_source_links` table (#6-#11)
+- Inference tagging: `is_inference` flag on ingest, `include_inferences:` filter on query, `INITIAL_INFERENCE_CONFIDENCE` (0.35) for LLM-derived entries (#9)
+- Temporal expiry metadata: `forget_reason` and custom `expires_at` on ingest (#8)
+- Versioned knowledge: `parent_knowledge_id`/`is_latest`/`supersession_type` on ingest, automatic parent supersession, `version_chain` traversal, `include_history:` query filter (#7)
+- L0/L1/L2 tiered retrieval: `tier:` parameter on query with summary projection and truncation fallback (#6)
+- Source-to-fact linkage: `source_uri`/`source_hash`/`relevance_score`/`extraction_method` on ingest, `source_links_for` query method, `local_source_links` table (#10)
+- `SUPERSEDES` relation type in `Local::Graph` (#11)
+- Versioning and expiry settings defaults
+
+### Fixed
+- FTS5 search crashes on punctuation (`.`, `:`, `-`, `+`, etc.) by tokenizing input into quoted alphanumeric terms with implicit AND semantics; ILIKE fallback now escapes `%` and `_` wildcards (#22)
+- Apollo query returns HTTP 500 on non-Postgres backends: `direct_query` exceptions normalized to `:backend_query_failed` symbol, `apollo_status_code` maps known unavailability symbols to 503 (#23)
+
 ## [0.4.0] - 2026-04-02
 
 ### Changed

data/lib/legion/apollo/helpers/confidence.rb

@@ -17,6 +17,7 @@ module Legion
         WRITE_GATE_THRESHOLD   = 0.3
         HIGH_CONFIDENCE        = 0.8
         ARCHIVE_THRESHOLD      = 0.1
+        INITIAL_INFERENCE_CONFIDENCE = 0.35
 
         STATUSES = %i[pending confirmed disputed deprecated archived].freeze
 

data/lib/legion/apollo/local/graph.rb

@@ -11,7 +11,7 @@ module Legion
       # Relationships are directional typed edges between two entities.
       # Graph traversal expands one frontier batch per depth to avoid per-node queries.
       module Graph # rubocop:disable Metrics/ModuleLength
-        VALID_RELATION_TYPES = %w[AFFECTS OWNED_BY DEPENDS_ON RELATED_TO].freeze
+        VALID_RELATION_TYPES = %w[AFFECTS OWNED_BY DEPENDS_ON RELATED_TO SUPERSEDES].freeze
 
         class << self # rubocop:disable Metrics/ClassLength
           include Legion::Logging::Helper

data/lib/legion/apollo/local/migrations/004_add_versioning_tiers_inference.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+Sequel.migration do # rubocop:disable Metrics/BlockLength
+  up do # rubocop:disable Metrics/BlockLength
+    alter_table(:local_knowledge) do
+      add_column :is_inference, :boolean, default: false, null: false
+      add_column :parent_knowledge_id, Integer, null: true
+      add_column :is_latest, :boolean, default: true, null: false
+      add_column :supersession_type, String, size: 32, null: true
+      add_column :forget_reason, String, size: 128, null: true
+      add_column :summary_l0, String, size: 500, null: true
+      add_column :summary_l1, :text, null: true
+      add_column :knowledge_tier, String, size: 4, null: false, default: 'L2'
+      add_column :l0_generated_at, String, null: true
+      add_column :l1_generated_at, String, null: true
+
+      add_index :is_latest, name: :idx_local_knowledge_is_latest
+      add_index :is_inference, name: :idx_local_knowledge_is_inference
+      add_index :knowledge_tier, name: :idx_local_knowledge_tier
+      add_index :parent_knowledge_id, name: :idx_local_knowledge_parent
+    end
+
+    create_table(:local_source_links) do
+      primary_key :id
+      Integer :entry_id, null: false
+      String  :source_uri, text: true
+      String  :source_hash, size: 64
+      Float   :relevance_score, default: 1.0
+      String  :extraction_method, size: 64
+      String  :created_at, null: false
+
+      index :entry_id, name: :idx_source_links_entry
+      index :source_hash, name: :idx_source_links_hash
+    end
+  end
+
+  down do
+    drop_table(:local_source_links) if table_exists?(:local_source_links)
+
+    alter_table(:local_knowledge) do
+      drop_column :is_inference
+      drop_column :parent_knowledge_id
+      drop_column :is_latest
+      drop_column :supersession_type
+      drop_column :forget_reason
+      drop_column :summary_l0
+      drop_column :summary_l1
+      drop_column :knowledge_tier
+      drop_column :l0_generated_at
+      drop_column :l1_generated_at
+    end
+  end
+end

data/lib/legion/apollo/local.rb

@@ -5,6 +5,7 @@ require 'legion/logging'
 require 'socket'
 require 'time'
 require_relative 'local/graph'
+require_relative 'helpers/confidence'
 require_relative 'helpers/similarity'
 require_relative 'helpers/tag_normalizer'
 
@@ -90,7 +91,7 @@ module Legion
           { success: false, error: e.message }
         end
 
-        def query(text:, limit: nil, min_confidence: nil, tags: nil, **) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def query(text:, limit: nil, min_confidence: nil, tags: nil, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
           return not_started_error unless started?
 
           text = normalize_text_input(text)
@@ -105,12 +106,19 @@ module Legion
           log.debug { "Apollo::Local query limit=#{limit} min_confidence=#{min_confidence} tags=#{Array(tags).size}" }
 
           candidates = fts_search(text, limit: limit * multiplier)
-          candidates = filter_candidates(candidates, min_confidence: min_confidence, tags: tags)
+          include_inferences = opts.fetch(:include_inferences, true)
+          include_history = opts.fetch(:include_history, false)
+          candidates = filter_candidates(candidates, min_confidence: min_confidence, tags: tags,
+                                                     include_inferences: include_inferences,
+                                                     include_history: include_history)
           candidates = cosine_rerank(text, candidates) if can_rerank?
           results = candidates.first(limit)
 
+          tier = opts[:tier]
+          results = results.map { |r| project_tier(r, tier) } if tier
+
           log.info { "Apollo::Local query completed count=#{results.size}" }
-          { success: true, results: results, count: results.size, mode: :local }
+          { success: true, results: results, count: results.size, mode: :local, tier: tier }
         rescue StandardError => e
           handle_exception(
             e,
@@ -223,6 +231,41 @@ module Legion
           { success: false, error: e.message }
         end
 
+        def version_chain(entry_id:, max_depth: 50) # rubocop:disable Metrics/MethodLength
+          return not_started_error unless started?
+
+          chain = []
+          current_id = entry_id
+          seen = Set.new
+
+          max_depth.times do
+            break unless current_id
+            break if seen.include?(current_id)
+
+            seen.add(current_id)
+            row = db[:local_knowledge].where(id: current_id).first
+            break unless row
+
+            chain << row
+            current_id = row[:parent_knowledge_id]
+          end
+
+          { success: true, chain: chain, count: chain.size }
+        rescue StandardError => e
+          handle_exception(e, level: :error, operation: 'apollo.local.version_chain', entry_id: entry_id)
+          { success: false, error: e.message }
+        end
+
+        def source_links_for(entry_id:)
+          return not_started_error unless started?
+
+          links = db[:local_source_links].where(entry_id: entry_id).all
+          { success: true, links: links, count: links.size }
+        rescue StandardError => e
+          handle_exception(e, level: :error, operation: 'apollo.local.source_links_for', entry_id: entry_id)
+          { success: false, error: e.message }
+        end
+
         private
 
         def self_knowledge_files
@@ -375,7 +418,8 @@ module Legion
           log.debug { "Apollo::Local ingest hash=#{hash} tags=#{Array(tags).size} source_channel=#{opts[:source_channel]}" }
 
           row = build_ingest_row(content: content, hash: hash, tags: tags, **opts)
-          id = persist_ingest_row(row)
+          id = persist_ingest_row(row, opts)
+          mark_parent_superseded(opts[:parent_knowledge_id]) if opts[:parent_knowledge_id]
 
           log.info { "Apollo::Local ingest stored id=#{id} hash=#{hash}" }
           { success: true, mode: :local, id: id }
@@ -385,31 +429,60 @@ module Legion
           deduplicated_ingest(hash)
         end
 
-        def build_ingest_row(content:, hash:, tags:, **opts)
+        def build_ingest_row(content:, hash:, tags:, **opts) # rubocop:disable Metrics/MethodLength
+          is_inference = opts[:is_inference] == true
+          default_confidence = is_inference ? Legion::Apollo::Helpers::Confidence::INITIAL_INFERENCE_CONFIDENCE : 1.0
           {
-            content:        content,
-            content_hash:   hash,
-            tags:           serialized_tags(tags),
-            source_channel: opts[:source_channel],
-            source_agent:   opts[:source_agent],
-            submitted_by:   opts[:submitted_by],
-            confidence:     opts[:confidence] || 1.0
-          }.merge(embedding_columns(content)).merge(timestamp_columns)
-        end
-
-        def persist_ingest_row(row)
+            content:             content,
+            content_hash:        hash,
+            tags:                serialized_tags(tags),
+            source_channel:      opts[:source_channel],
+            source_agent:        opts[:source_agent],
+            submitted_by:        opts[:submitted_by],
+            confidence:          opts[:confidence] || default_confidence,
+            is_inference:        is_inference,
+            forget_reason:       opts[:forget_reason],
+            parent_knowledge_id: opts[:parent_knowledge_id],
+            supersession_type:   opts[:supersession_type]
+          }.merge(embedding_columns(content, opts)).merge(timestamp_columns)
+        end
+
+        def persist_ingest_row(row, opts = {})
           db.transaction do
             id = db[:local_knowledge].insert(row)
             sync_fts!(id, row[:content], row[:tags])
+            create_source_link(id, opts) if opts[:source_uri]
             id
           end
         end
 
+        def create_source_link(entry_id, opts)
+          db[:local_source_links].insert(
+            entry_id:          entry_id,
+            source_uri:        opts[:source_uri],
+            source_hash:       opts[:source_hash],
+            relevance_score:   opts[:relevance_score] || 1.0,
+            extraction_method: opts[:extraction_method],
+            created_at:        Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+          )
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'apollo.local.create_source_link', entry_id: entry_id)
+        end
+
         def deduplicated_ingest(hash)
           log.info { "Apollo::Local ingest deduplicated hash=#{hash}" }
           { success: true, mode: :deduplicated }
         end
 
+        def mark_parent_superseded(parent_id)
+          return unless parent_id
+
+          db[:local_knowledge].where(id: parent_id).update(is_latest: false)
+          log.info { "Apollo::Local marked entry id=#{parent_id} as superseded" }
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'apollo.local.mark_parent_superseded', parent_id: parent_id)
+        end
+
         def generate_embedding(content) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:can_embed?) && Legion::LLM.can_embed?
             log.debug 'Apollo::Local embedding skipped because embeddings are unavailable'
@@ -447,13 +520,13 @@ module Legion
           log.debug { "Apollo::Local FTS synced id=#{id}" }
         end
 
-        def embedding_columns(content)
+        def embedding_columns(content, opts = {})
           embedding, embedded_at = generate_embedding(content)
 
           {
             embedding:   embedding ? Legion::JSON.dump(embedding) : nil,
             embedded_at: embedded_at,
-            expires_at:  compute_expires_at
+            expires_at:  opts[:expires_at] || compute_expires_at
           }
         end
 
@@ -467,15 +540,18 @@ module Legion
         end
 
         def fts_search(text, limit:) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
           if text.to_s.strip.empty?
             return db[:local_knowledge]
-                   .where(Sequel.lit('expires_at > ?', Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')))
+                   .where(Sequel.lit('expires_at > ?', now))
                    .limit(limit)
                    .all
           end
 
-          escaped = text.to_s.gsub('"', '""')
-          now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+          tokens = text.to_s.scan(/[\p{L}\p{N}_]+/)
+          return ilike_search(text, now: now, limit: limit) if tokens.empty?
+
+          escaped = tokens.map { |t| %("#{t}") }.join(' ')
           db.fetch(
             'SELECT lk.* FROM local_knowledge lk ' \
             'INNER JOIN local_knowledge_fts fts ON lk.id = fts.rowid ' \
@@ -484,15 +560,24 @@ module Legion
           ).all
         rescue StandardError => e
           handle_exception(e, level: :debug, operation: 'apollo.local.fts_search', limit: limit, fallback: :ilike)
+          ilike_search(text, now: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ'), limit: limit)
+        end
+
+        def ilike_search(text, now:, limit:)
+          safe_text = text.to_s.gsub('\\', '\\\\\\\\').gsub('%', '\%').gsub('_', '\_')
           db[:local_knowledge]
-            .where(Sequel.lit('expires_at > ?', Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')))
-            .where(Sequel.ilike(:content, "%#{text}%"))
+            .where(Sequel.lit('expires_at > ?', now))
+            .where(Sequel.lit("content LIKE ? ESCAPE '\\' COLLATE NOCASE", "%#{safe_text}%"))
             .limit(limit)
             .all
         end
 
-        def filter_candidates(candidates, min_confidence:, tags:)
+        def filter_candidates(candidates, min_confidence:, tags:, include_inferences: true, include_history: false) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/AbcSize
           candidates = candidates.select { |c| (c[:confidence] || 0) >= min_confidence }
+          candidates = candidates.reject { |c| [1, true].include?(c[:is_inference]) } unless include_inferences
+          unless include_history
+            candidates = candidates.select { |c| c[:is_latest].nil? || c[:is_latest] == 1 || c[:is_latest] == true }
+          end
           if tags && !tags.empty?
             tag_set = Array(tags).map(&:to_s)
             candidates = candidates.select do |c|
@@ -658,6 +743,21 @@ module Legion
           log.debug { "Apollo::Local FTS rebuilt id=#{id}" }
         end
 
+        def project_tier(entry, tier) # rubocop:disable Metrics/MethodLength
+          case tier
+          when :l0
+            entry.slice(:id, :content_hash, :confidence, :tags, :source_channel, :is_inference, :is_latest).merge(
+              summary: entry[:summary_l0] || entry[:content]&.slice(0, 200)
+            )
+          when :l1
+            entry.slice(:id, :content_hash, :confidence, :tags, :source_channel, :is_inference, :is_latest).merge(
+              summary: entry[:summary_l1] || entry[:content]&.slice(0, 1000)
+            )
+          else
+            entry
+          end
+        end
+
         def not_started_error
           { success: false, error: :not_started }
         end

data/lib/legion/apollo/routes.rb

@@ -50,7 +50,7 @@ module Legion
         end
       end
 
-      def self.register_query_route(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+      def self.register_query_route(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         app.post '/api/apollo/query' do
           unless apollo_api_available?
             halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503)
@@ -59,21 +59,24 @@ module Legion
           body = parse_request_body
           default_limit = defined?(Legion::Settings) ? (Legion::Settings[:apollo]&.dig(:default_limit) || 5) : 5
           result = Legion::Apollo.query(
-            text:           body[:query],
-            limit:          body[:limit] || default_limit,
-            min_confidence: body[:min_confidence],
-            status:         body[:status] || [:confirmed],
-            tags:           body[:tags],
-            domain:         body[:domain],
-            agent_id:       body[:agent_id] || 'api',
-            scope:          normalize_scope(body[:scope])
+            text:               body[:query],
+            limit:              body[:limit] || default_limit,
+            min_confidence:     body[:min_confidence],
+            status:             body[:status] || [:confirmed],
+            tags:               body[:tags],
+            domain:             body[:domain],
+            agent_id:           body[:agent_id] || 'api',
+            scope:              normalize_scope(body[:scope]),
+            tier:               body[:tier]&.to_sym,
+            include_inferences: body.fetch(:include_inferences, true),
+            include_history:    body.fetch(:include_history, false)
           )
           json_response(result, status_code: apollo_status_code(result))
         end
       end
 
       def self.register_ingest_route(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        app.post '/api/apollo/ingest' do
+        app.post '/api/apollo/ingest' do # rubocop:disable Metrics/BlockLength
           unless apollo_api_available?
             halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503)
           end
@@ -84,15 +87,24 @@ module Legion
           effective_max_tags = [max_tags, Legion::Apollo::Helpers::TagNormalizer::MAX_TAGS].min
           tags = Legion::Apollo::Helpers::TagNormalizer.normalize(Array(body[:tags])).first(effective_max_tags)
           result = Legion::Apollo.ingest(
-            content:          body[:content],
-            content_type:     body[:content_type] || :observation,
-            tags:             tags,
-            source_agent:     body[:source_agent] || 'api',
-            source_provider:  body[:source_provider],
-            source_channel:   body[:source_channel] || 'rest_api',
-            knowledge_domain: body[:knowledge_domain],
-            context:          body[:context] || {},
-            scope:            normalize_scope(body[:scope])
+            content:             body[:content],
+            content_type:        body[:content_type] || :observation,
+            tags:                tags,
+            source_agent:        body[:source_agent] || 'api',
+            source_provider:     body[:source_provider],
+            source_channel:      body[:source_channel] || 'rest_api',
+            knowledge_domain:    body[:knowledge_domain],
+            context:             body[:context] || {},
+            scope:               normalize_scope(body[:scope]),
+            is_inference:        body[:is_inference] == true,
+            forget_reason:       body[:forget_reason],
+            expires_at:          body[:expires_at],
+            parent_knowledge_id: body[:parent_knowledge_id],
+            supersession_type:   body[:supersession_type],
+            source_uri:          body[:source_uri],
+            source_hash:         body[:source_hash],
+            relevance_score:     body[:relevance_score],
+            extraction_method:   body[:extraction_method]
           )
           json_response(result, status_code: apollo_status_code(result, success_status: 201))
         end
@@ -197,13 +209,16 @@ module Legion
           :global
         end
 
-        def apollo_status_code(result, success_status: 200)
+        def apollo_status_code(result, success_status: 200) # rubocop:disable Metrics/MethodLength
           return 202 if result[:success] && result[:mode] == :async
           return success_status if result[:success]
 
           case result[:error]
-          when :no_path_available, :not_started then 503
-          else 500
+          when :no_path_available, :not_started, :local_not_started,
+               :upstream_query_failed, :backend_query_failed
+            503
+          else
+            500
           end
         rescue StandardError => e
           handle_exception(e, level: :debug, operation: :apollo_status_code)

data/lib/legion/apollo/settings.rb

@@ -10,7 +10,9 @@ module Legion
           max_tags:       20,
           default_limit:  5,
           min_confidence: 0.3,
-          local:          local_defaults
+          local:          local_defaults,
+          versioning:     versioning_defaults,
+          expiry:         expiry_defaults
         }
       end
 
@@ -24,6 +26,22 @@ module Legion
           default_limit:            5
         }
       end
+
+      def self.versioning_defaults
+        {
+          enabled:                true,
+          supersession_threshold: 0.85,
+          max_chain_depth:        50
+        }
+      end
+
+      def self.expiry_defaults
+        {
+          enabled:            true,
+          sweep_interval:     3600,
+          warn_before_expiry: 86_400
+        }
+      end
     end
   end
 end

data/lib/legion/apollo/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Apollo
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/lib/legion/apollo.rb

@@ -247,7 +247,7 @@ module Legion
         Legion::Extensions::Apollo::Runners::Knowledge.handle_query(**normalize_query_payload(payload))
       rescue StandardError => e
         handle_exception(e, level: :error, operation: 'apollo.direct_query', payload_keys: payload.keys)
-        { success: false, error: e.message }
+        { success: false, error: :backend_query_failed, detail: e.message }
       end
 
       def direct_ingest(payload)
@@ -288,7 +288,8 @@ module Legion
           "Apollo query using local store text_length=#{payload[:text].to_s.length} " \
             "limit=#{payload[:limit]}"
         end
-        result = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags))
+        result = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags,
+                                                             :tier, :include_inferences, :include_history))
         return result unless result[:success]
 
         entries = normalize_local_entries(Array(result[:results]))
@@ -322,7 +323,8 @@ module Legion
 
         if Legion::Apollo::Local.started?
           attempted = true
-          local = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags))
+          local = Legion::Apollo::Local.query(**payload.slice(:text, :limit, :min_confidence, :tags,
+                                                              :tier, :include_inferences, :include_history))
           if local[:success]
             any_success = true
             entries.concat(normalize_local_entries(Array(local[:results]))) if local[:results]
@@ -341,6 +343,9 @@ module Legion
         return { success: false, error: :no_path_available } unless attempted
 
         unless any_success
+          symbol_errors = errors.compact.grep(Symbol).uniq
+          return { success: false, error: symbol_errors.first } if symbol_errors.size == 1
+
           combined_error = errors.compact.map(&:to_s).reject(&:empty?).join('; ')
           combined_error = :upstream_query_failed if combined_error.empty?
           return { success: false, error: combined_error }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Esity
@@ -86,6 +86,7 @@ files:
 - lib/legion/apollo/local/migrations/001_create_local_knowledge.rb
 - lib/legion/apollo/local/migrations/002_create_graph_tables.rb
 - lib/legion/apollo/local/migrations/003_harden_graph_relationships.rb
+- lib/legion/apollo/local/migrations/004_add_versioning_tiers_inference.rb
 - lib/legion/apollo/messages/access_boost.rb
 - lib/legion/apollo/messages/ingest.rb
 - lib/legion/apollo/messages/query.rb