lex-agentic-self 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53c28592aa4721c2cc7901452451b9836cad8d3ded37f83c2a8dc04aac3ba1f8
-  data.tar.gz: 29a423e61504f68cf11fd8c234f29b0d4ff654e33ea5651fd2d7739656cfb9ab
+  metadata.gz: 9353f26016962ab841ebc5b4e5d717d1ba7b94d5c6ccd9da3be8ed8c7fdeb938
+  data.tar.gz: 5544eb5d69d9394c6f6071acfc4ea54e0a651f700f0d41ede5ac2f9e85be33bb
 SHA512:
-  metadata.gz: 38e5b0225a70847a4fb4a8d2f323f1bf1174004f16643deca0fca3567970f16fb5ee722e5e974051b42aff17c7dbb4ccdf7d1c403651c9d4228f3dec4433f7ca
-  data.tar.gz: 3bc0d255fb156a9ce05ac926ecd6c5ca15c57a0729c57de9b679ebb684748143e004bbb209433056b628b4de78f7fa0437393d428d810069b69cd3f0fa787ff0
+  metadata.gz: 125c49e963e0ed3832a81a277a4f71fe815fa7fbfbc8b264775205ea6b06085313fdfc716383b4364afcff1bdb9b2d5367904eeac1a20a93254dbbb1232b004d
+  data.tar.gz: c5c64a7caf5080f6b0a335985ece8aefeaacdb2fccd4096408e1902ba0ab73e1c3cc0beb4658f9d3fbd72a5ccb795aa3597df0928b768f06856163edac366486

data/CHANGELOG.md

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

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/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Self
-        VERSION = '0.1.14'
+        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

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.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