lex-agentic-self 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86842222337e93a3e159eff411592f845792f5fde64fb32691feed47fff7ef7b
-  data.tar.gz: 440179ab3ad0a8dde91657cd0e2955a2dae16a2e50fdcdd99b7aff163fcda232
+  metadata.gz: 9353f26016962ab841ebc5b4e5d717d1ba7b94d5c6ccd9da3be8ed8c7fdeb938
+  data.tar.gz: 5544eb5d69d9394c6f6071acfc4ea54e0a651f700f0d41ede5ac2f9e85be33bb
 SHA512:
-  metadata.gz: b180e99b145fc1f272cb29fafa7d09d28fa9b26aa3f5d56b11e6ab3263a31062234625f921ddd2eed47e891063aae2607298cdca21967b28f6072add6efb5184
-  data.tar.gz: 84e76ec6b1d8a781ce47f91c63218fefcc6a641068ec76bc0ec1e32aeb30f8da1869737b11c74a015a859b814f1bb69f3af3d2557483fd37970fdf3df24fd858
+  metadata.gz: 125c49e963e0ed3832a81a277a4f71fe815fa7fbfbc8b264775205ea6b06085313fdfc716383b4364afcff1bdb9b2d5367904eeac1a20a93254dbbb1232b004d
+  data.tar.gz: c5c64a7caf5080f6b0a335985ece8aefeaacdb2fccd4096408e1902ba0ab73e1c3cc0beb4658f9d3fbd72a5ccb795aa3597df0928b768f06856163edac366486

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [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.
+- Reflection health now updates trust drift and mode-pattern category scores from tick results.
+- Reflection LLM enhancer rejects arbitrary extra keyword arguments instead of forwarding them.
+
 ## [0.1.13] - 2026-04-22
 ### Added
 - Module-level snapshot methods (`personality_snapshot`, `reflection_snapshot`, `restore_personality`, `restore_reflections`) enabling memory↔self bridge for snapshot save/restore

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/identity/helpers/fingerprint.rb

@@ -18,6 +18,7 @@ module Legion
                 @model = Dimensions.new_identity_model
                 @observation_count = 0
                 @entropy_history = []
+                @local_previously_available = false
                 load_from_local
               end
 
@@ -87,7 +88,14 @@ module Legion
               end
 
               def save_to_local
-                return unless local_available?
+                unless local_available?
+                  if @local_previously_available
+                    Legion::Logging.warn 'lex-identity: local persistence unavailable after being available'
+                    return false
+                  end
+
+                  return nil
+                end
 
                 db = local_data_connection
 
@@ -161,7 +169,9 @@ module Legion
               private
 
               def local_available?
-                defined?(Legion::Data::Local) && respond_to?(:local_data_connected?) && local_data_connected?
+                available = defined?(Legion::Data::Local) && respond_to?(:local_data_connected?) && local_data_connected?
+                @local_previously_available = true if available
+                available
               end
             end
           end

data/lib/legion/extensions/agentic/self/reflection/helpers/llm_enhancer.rb

@@ -42,12 +42,12 @@ module Legion
                 false
               end
 
-              def enhance(prompt, phase: 'reflection', **)
+              def enhance(prompt, phase: 'reflection')
                 return nil unless available?
 
                 if pipeline_available?
                   response = Legion::LLM::Pipeline::GaiaCaller.chat(
-                    message: prompt, phase: phase, **
+                    message: prompt, phase: phase
                   )
                   response&.message&.dig(:content)
                 else

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

@@ -149,6 +149,8 @@ module Legion
                 update_emotion_score(tick_results)
                 update_memory_score(tick_results)
                 update_load_score(tick_results)
+                update_trust_score(tick_results)
+                update_mode_score(tick_results)
               end
 
               def update_prediction_score(tick_results)
@@ -190,6 +192,22 @@ module Legion
                 utilization = elapsed / budget
                 reflection_store.update_category_score(:cognitive_load, [1.0 - utilization, 0.0].max)
               end
+
+              def update_trust_score(tick_results)
+                social = tick_results[:social_cognition]
+                return unless social.is_a?(Hash) && social[:trust_drift].is_a?(Numeric)
+
+                reflection_store.update_category_score(:trust_drift, 1.0 - social[:trust_drift].abs)
+              end
+
+              def update_mode_score(tick_results)
+                state = tick_results[:tick_state]
+                return unless state.is_a?(Hash) && state[:mode_transitions].is_a?(Numeric)
+
+                transitions = state[:mode_transitions].to_f
+                threshold = Helpers::Constants::MODE_OSCILLATION_THRESHOLD.to_f
+                reflection_store.update_category_score(:mode_patterns, [1.0 - (transitions / threshold), 0.0].max)
+              end
             end
           end
         end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Self
-        VERSION = '0.1.13'
+        VERSION = '0.1.15'
       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/helpers/fingerprint_spec.rb

@@ -91,5 +91,13 @@ RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::Fingerprint
         expect(fp.save_to_local).to be_nil
       end
     end
+
+    it 'warns when local persistence was previously available but is no longer connected' do
+      fp.instance_variable_set(:@local_previously_available, true)
+      allow(fp).to receive(:local_data_connected?).and_return(false)
+
+      expect(Legion::Logging).to receive(:warn).with(/local persistence unavailable/)
+      expect(fp.save_to_local).to be false
+    end
   end
 end

data/spec/legion/extensions/agentic/self/reflection/helpers/llm_enhancer_spec.rb

@@ -75,6 +75,10 @@ RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Helpers::LlmEnhanc
       allow(enhancer_mod).to receive(:available?).and_return(false)
       expect(enhancer_mod.enhance('hello')).to be_nil
     end
+
+    it 'rejects arbitrary extra kwargs instead of forwarding them to LLM' do
+      expect { enhancer_mod.enhance('hello', unexpected: true) }.to raise_error(ArgumentError)
+    end
   end
 
   describe '.available?' do

data/spec/legion/extensions/agentic/self/reflection/runners/reflection_spec.rb

@@ -46,6 +46,23 @@ RSpec.describe Legion::Extensions::Agentic::Self::Reflection::Runners::Reflectio
       expect(result[:health]).to be < 1.0
       expect(result[:category_scores][:prediction_calibration]).to eq(0.2)
     end
+
+    it 'updates trust_drift from social cognition results' do
+      client.reflect(tick_results: { social_cognition: { trust_drift: 0.4 } })
+
+      result = client.cognitive_health
+
+      expect(result[:category_scores][:trust_drift]).to eq(0.6)
+      expect(result[:health]).to be < 1.0
+    end
+
+    it 'updates mode_patterns from tick mode transition counts' do
+      client.reflect(tick_results: { tick_state: { mode_transitions: 5 } })
+
+      result = client.cognitive_health
+
+      expect(result[:category_scores][:mode_patterns]).to eq(0.0)
+    end
   end
 
   describe '#recent_reflections' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-self
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 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