lex-agentic-self 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53c28592aa4721c2cc7901452451b9836cad8d3ded37f83c2a8dc04aac3ba1f8
-  data.tar.gz: 29a423e61504f68cf11fd8c234f29b0d4ff654e33ea5651fd2d7739656cfb9ab
+  metadata.gz: 78fabc193208b0e2059a6f95600bd6c358abe763ee62d26da104e624d8e665ab
+  data.tar.gz: a606062b0f999c578120934bc4cd6486d5b4f6f80456f2b119557cf7afbd7ea0
 SHA512:
-  metadata.gz: 38e5b0225a70847a4fb4a8d2f323f1bf1174004f16643deca0fca3567970f16fb5ee722e5e974051b42aff17c7dbb4ccdf7d1c403651c9d4228f3dec4433f7ca
-  data.tar.gz: 3bc0d255fb156a9ce05ac926ecd6c5ca15c57a0729c57de9b679ebb684748143e004bbb209433056b628b4de78f7fa0437393d428d810069b69cd3f0fa787ff0
+  metadata.gz: 2ada4ab413f48e62b67e0ed9913db7d88b4756af102d7bc121b6b9d26905158c2d1d3dcfacfe12e914d560583e2832076ac8c178d0977344bc0b9a245a8894ae
+  data.tar.gz: 9695b4662b313bbce2dc7d73ca9f1b6dd12e96a18525cf1cd4dc87dada063a5fbd87e8c93fc07202f35bfe7c178b2f4501b6a98309e626ce1abf25b4183da187

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.16] - 2026-10-29
+### Fixed
+- Refresh metacognitive snapshots immediately when new tick or subsystem observations arrive instead of hiding them behind the cache TTL.
+- Refresh expired architecture overviews through normal introspection so newly loaded extensions appear in architecture change history.
+
+## [0.1.15] - 2026-07-16
+### Added
+- Per-partner identity fingerprint models: `CognitiveFingerprint` runner now accepts `partner_identity:` on all methods, routing each partner to an isolated `FingerprintEngine` instance via an in-memory registry.
+- `erase_partner!(identity:)` removes the fingerprint model for a given partner identity; returns `{erased: true/false, identity:}`.
+- `tracked_partners` returns the list of partner identities currently held in the registry.
+
 ## [0.1.14] - 2026-05-07
 ### Fixed
 - Identity fingerprint save now warns and returns false if local persistence disconnects after previously being available.

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for self-model, identity, metacognition, and self-aware
 ## Overview
 
 **Gem**: `lex-agentic-self`
-**Version**: 0.1.13
+**Version**: 0.1.16
 **Namespace**: `Legion::Extensions::Agentic::Self`
 
 ## Sub-Modules

data/lib/legion/extensions/agentic/self/architecture/helpers/subsystem.rb

@@ -23,7 +23,7 @@ module Legion
                 @load             = 0.0
                 @activation_count = 0
                 @last_activated_at = nil
-                @created_at       = Time.now.utc
+                @created_at = Time.now.utc
               end
 
               def activate!

data/lib/legion/extensions/agentic/self/fingerprint/client.rb

@@ -12,14 +12,6 @@ module Legion
         module Fingerprint
           class Client
             include Runners::CognitiveFingerprint
-
-            def initialize(**)
-              @fingerprint_engine = Helpers::FingerprintEngine.new
-            end
-
-            private
-
-            attr_reader :fingerprint_engine
           end
         end
       end

data/lib/legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint.rb

@@ -10,26 +10,26 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def record_observation(category:, value:, **)
+              def record_observation(category:, value:, partner_identity: nil, **)
                 category = category.to_sym
-                result   = fingerprint_engine.record_observation(category: category, value: value.to_f)
+                result   = engine_for(partner_identity).record_observation(category: category, value: value.to_f)
                 log.debug "[cognitive_fingerprint] record category=#{category} " \
                           "baseline=#{result[:baseline]&.round(4)} samples=#{result[:samples]}"
                 result
               end
 
-              def verify_identity(observations:, **)
+              def verify_identity(observations:, partner_identity: nil, **)
                 parsed = Array(observations).map do |obs|
                   { category: obs[:category].to_sym, value: obs[:value].to_f }
                 end
-                result = fingerprint_engine.verify_identity(observations: parsed)
+                result = engine_for(partner_identity).verify_identity(observations: parsed)
                 log.info "[cognitive_fingerprint] verify score=#{result[:match_score]&.round(4)} " \
                          "verdict=#{result[:verdict]}"
                 result
               end
 
-              def anomaly_check(category:, value:, **)
-                result = fingerprint_engine.anomaly_check(category: category.to_sym, value: value.to_f)
+              def anomaly_check(category:, value:, partner_identity: nil, **)
+                result = engine_for(partner_identity).anomaly_check(category: category.to_sym, value: value.to_f)
                 if result[:anomaly]
                   log.warn "[cognitive_fingerprint] anomaly category=#{category} " \
                            "deviation=#{result[:deviation]&.round(4)}"
@@ -37,45 +37,64 @@ module Legion
                 result
               end
 
-              def trait_profile(**)
-                { profile: fingerprint_engine.trait_profile }
+              def trait_profile(partner_identity: nil, **)
+                { profile: engine_for(partner_identity).trait_profile }
               end
 
-              def strongest_traits(top_n: 3, **)
-                { traits: fingerprint_engine.strongest_traits(top_n.to_i) }
+              def strongest_traits(top_n: 3, partner_identity: nil, **)
+                { traits: engine_for(partner_identity).strongest_traits(top_n.to_i) }
               end
 
-              def weakest_traits(top_n: 3, **)
-                { traits: fingerprint_engine.weakest_traits(top_n.to_i) }
+              def weakest_traits(top_n: 3, partner_identity: nil, **)
+                { traits: engine_for(partner_identity).weakest_traits(top_n.to_i) }
               end
 
-              def identity_confidence(**)
-                confidence = fingerprint_engine.identity_confidence
-                label      = fingerprint_engine.identity_label
+              def identity_confidence(partner_identity: nil, **)
+                engine = engine_for(partner_identity)
+                confidence = engine.identity_confidence
+                label      = engine.identity_label
                 log.debug "[cognitive_fingerprint] confidence=#{confidence.round(4)} label=#{label}"
                 { confidence: confidence, label: label }
               end
 
-              def fingerprint_hash(**)
-                { fingerprint_hash: fingerprint_engine.fingerprint_hash }
+              def fingerprint_hash(partner_identity: nil, **)
+                { fingerprint_hash: engine_for(partner_identity).fingerprint_hash }
               end
 
-              def fingerprint_report(**)
-                fingerprint_engine.fingerprint_report
+              def fingerprint_report(partner_identity: nil, **)
+                engine_for(partner_identity).fingerprint_report
               end
 
-              def fingerprint_status(**)
+              def fingerprint_status(partner_identity: nil, **)
+                engine = engine_for(partner_identity)
                 {
-                  trait_count:  fingerprint_engine.trait_count,
-                  sample_count: fingerprint_engine.sample_count,
-                  label:        fingerprint_engine.identity_label
+                  trait_count:  engine.trait_count,
+                  sample_count: engine.sample_count,
+                  label:        engine.identity_label
                 }
               end
 
+              def erase_partner!(identity:, **)
+                registry = fingerprint_registry
+                return { erased: false, identity: identity } unless registry.key?(identity)
+
+                registry.delete(identity)
+                log.info "[cognitive_fingerprint] erased partner identity=#{identity}"
+                { erased: true, identity: identity }
+              end
+
+              def tracked_partners
+                fingerprint_registry.keys.compact
+              end
+
               private
 
-              def fingerprint_engine
-                @fingerprint_engine ||= Helpers::FingerprintEngine.new
+              def engine_for(partner_identity)
+                fingerprint_registry[partner_identity] ||= Helpers::FingerprintEngine.new
+              end
+
+              def fingerprint_registry
+                @fingerprint_registry ||= {}
               end
             end
           end

data/lib/legion/extensions/agentic/self/metacognition/runners/metacognition.rb

@@ -11,7 +11,9 @@ module Legion
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def introspect(tick_results: {}, subsystem_states: {}, **)
-                model = if snapshot_store.stale?
+                observed = (tick_results.is_a?(Hash) && !tick_results.empty?) ||
+                           (subsystem_states.is_a?(Hash) && !subsystem_states.empty?)
+                model = if snapshot_store.stale? || observed
                           fresh = Helpers::SelfModel.build(
                             subsystem_states: subsystem_states,
                             tick_results:     tick_results
@@ -59,8 +61,7 @@ module Legion
               end
 
               def architecture_overview(**)
-                model = snapshot_store.latest || Helpers::SelfModel.build
-                snapshot_store.store(model) if snapshot_store.stale?
+                model = introspect
 
                 {
                   identity:     model[:identity],

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Self
-        VERSION = '0.1.14'
+        VERSION = '0.1.16'
       end
     end
   end

data/spec/legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint_partner_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/fingerprint/client'
+
+RSpec.describe 'CognitiveFingerprint per-partner identity scoping' do
+  let(:client) { Legion::Extensions::Agentic::Self::Fingerprint::Client.new }
+
+  def seed(partner, category, value, count = 10)
+    count.times { client.record_observation(category: category, value: value, partner_identity: partner) }
+  end
+
+  describe 'isolation between partners' do
+    it 'observations for partner X are not visible to partner Y' do
+      seed('alice', :accuracy, 0.9)
+      result = client.fingerprint_status(partner_identity: 'bob')
+      expect(result[:trait_count]).to eq(0)
+    end
+
+    it 'partner X traits are visible when queried for X' do
+      seed('alice', :accuracy, 0.9)
+      result = client.fingerprint_status(partner_identity: 'alice')
+      expect(result[:trait_count]).to eq(1)
+    end
+
+    it 'two partners maintain independent baselines' do
+      seed('alice', :accuracy, 0.9)
+      seed('bob', :accuracy, 0.1)
+      alice_profile = client.trait_profile(partner_identity: 'alice')[:profile]
+      bob_profile   = client.trait_profile(partner_identity: 'bob')[:profile]
+      expect(alice_profile[:accuracy]).to be > 0.5
+      expect(bob_profile[:accuracy]).to be < 0.5
+    end
+
+    it 'verify_identity for X never sees Y data' do
+      seed('alice', :accuracy, 0.9, 20)
+      result = client.verify_identity(observations:     [{ category: :accuracy, value: 0.9 }],
+                                      partner_identity: 'bob')
+      expect(result[:verdict]).to eq(:insufficient_data)
+    end
+
+    it 'anomaly_check for X never uses Y baseline' do
+      seed('alice', :accuracy, 0.9, 10)
+      result = client.anomaly_check(category: :accuracy, value: 0.9, partner_identity: 'bob')
+      expect(result[:reason]).to eq(:no_baseline)
+    end
+  end
+
+  describe '#erase_partner!' do
+    before { seed('alice', :accuracy, 0.9) }
+
+    it 'removes all data for the named partner' do
+      client.erase_partner!(identity: 'alice')
+      result = client.fingerprint_status(partner_identity: 'alice')
+      expect(result[:trait_count]).to eq(0)
+    end
+
+    it 'leaves other partners untouched' do
+      seed('bob', :accuracy, 0.5)
+      client.erase_partner!(identity: 'alice')
+      result = client.fingerprint_status(partner_identity: 'bob')
+      expect(result[:trait_count]).to eq(1)
+    end
+
+    it 'returns a success hash' do
+      result = client.erase_partner!(identity: 'alice')
+      expect(result[:erased]).to eq(true)
+      expect(result[:identity]).to eq('alice')
+    end
+
+    it 'is a no-op for unknown partner and returns erased: false' do
+      result = client.erase_partner!(identity: 'nobody')
+      expect(result[:erased]).to eq(false)
+    end
+  end
+
+  describe 'registry introspection' do
+    it 'returns list of tracked partner identities' do
+      seed('alice', :accuracy, 0.9)
+      seed('bob', :creativity, 0.5)
+      partners = client.tracked_partners
+      expect(partners).to include('alice')
+      expect(partners).to include('bob')
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/identity/local_persistence_spec.rb

@@ -39,8 +39,8 @@ RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::Fingerprint
 
   def stub_local(db)
     local_mod = Module.new do
-      define_singleton_method(:connection)  { db }
-      define_singleton_method(:connected?)  { true }
+      define_singleton_method(:connection) { db }
+      define_singleton_method(:connected?) { true }
     end
     stub_const('Legion::Data', Module.new)
     stub_const('Legion::Data::Local', local_mod)

data/spec/legion/extensions/agentic/self/identity/runners/entra_spec.rb

@@ -9,8 +9,8 @@ unless defined?(Legion::Logging)
       module_function
 
       def debug(*); end
-      def info(*);  end
-      def warn(*);  end
+      def info(*); end
+      def warn(*); end
     end
   end
 end
@@ -245,7 +245,7 @@ RSpec.describe Legion::Extensions::Agentic::Self::Identity::Runners::Entra do
   describe '#refresh_access_token' do
     let(:vault_secrets_mod) do
       Module.new do
-        def self.read_client_secret(worker_id:) # rubocop:disable Lint/UnusedMethodArgument
+        def self.read_client_secret(**)
           { client_id: 'app-id', client_secret: 'secret-val' }
         end
       end

data/spec/legion/extensions/agentic/self/metacognition/runners/metacognition_spec.rb

@@ -41,6 +41,24 @@ RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Runners::Metaco
       expect(model.dig(:cognitive, :health)).to eq(0.95)
       expect(store.size).to eq(2)
     end
+
+    it 'uses newly observed health and subsystem state before the cache expires' do
+      client.introspect(tick_results: tick_results, subsystem_states: { memory: { status: :healthy } })
+      changed = tick_results.merge(post_tick_reflection: { cognitive_health: 0.35 })
+
+      model = client.introspect(tick_results: changed, subsystem_states: { memory: { status: :degraded } })
+
+      expect(model.dig(:cognitive, :health)).to eq(0.35)
+      expect(client.explain_subsystem(subsystem: :memory)[:state]).to eq(status: :degraded)
+      expect(client.health_trend[:trend].map { |entry| entry[:health] }).to eq([0.88, 0.35])
+    end
+
+    it 'accepts new subsystem observations without requiring a new tick' do
+      client.introspect(subsystem_states: { memory: { status: :healthy } })
+      client.introspect(subsystem_states: { memory: { status: :degraded } })
+
+      expect(client.explain_subsystem(subsystem: :memory)[:state]).to eq(status: :degraded)
+    end
   end
 
   describe '#self_narrative' do
@@ -74,6 +92,19 @@ RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Runners::Metaco
       expect(result[:identity][:framework]).to eq('LegionIO')
       expect(result).to have_key(:capabilities)
     end
+
+    it 'rediscovers loaded extensions after the cached architecture expires' do
+      hide_const('Legion::Extensions::Curiosity') if Legion::Extensions.const_defined?(:Curiosity, false)
+      old = client.introspect
+      old[:assembled_at] = Time.now.utc - 60
+      stub_const('Legion::Extensions::Curiosity', Module.new)
+
+      overview = client.architecture_overview
+
+      expect(overview[:architecture][:loaded]).to include(:Curiosity)
+      expect(overview[:assembled_at]).to be > old[:assembled_at]
+      expect(client.architecture_changes[:changes].last[:added]).to include(:Curiosity)
+    end
   end
 
   describe '#health_trend' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-self
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.16
 platform: ruby
 authors:
 - Esity
@@ -367,6 +367,7 @@ files:
 - spec/legion/extensions/agentic/self/fingerprint/helpers/cognitive_trait_spec.rb
 - spec/legion/extensions/agentic/self/fingerprint/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/self/fingerprint/helpers/fingerprint_engine_spec.rb
+- spec/legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint_partner_spec.rb
 - spec/legion/extensions/agentic/self/fingerprint/runners/cognitive_fingerprint_spec.rb
 - spec/legion/extensions/agentic/self/identity/actors/orphan_check_spec.rb
 - spec/legion/extensions/agentic/self/identity/client_spec.rb