lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/identity/actors/orphan_check_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class since legionio gem is not available in test
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+# Intercept the require in the actor file so it doesn't fail
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/self/identity/actors/orphan_check'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Actor::OrphanCheck do
+  subject(:actor) { described_class.new }
+
+  describe 'ORPHAN_CHECK_INTERVAL' do
+    it 'is 14400 seconds (4 hours)' do
+      expect(described_class::ORPHAN_CHECK_INTERVAL).to eq(14_400)
+    end
+  end
+
+  describe '#runner_class' do
+    it 'returns the Entra module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Self::Identity::Runners::Entra)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns check_orphans' do
+      expect(actor.runner_function).to eq('check_orphans')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 14400 seconds using the constant' do
+      expect(actor.time).to eq(Legion::Extensions::Agentic::Self::Identity::Actor::OrphanCheck::ORPHAN_CHECK_INTERVAL)
+    end
+
+    it 'returns 14400' do
+      expect(actor.time).to eq(14_400)
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+
+  describe '#enabled?' do
+    context 'when Legion::Data is not defined' do
+      it 'returns false' do
+        hide_const('Legion::Data') if defined?(Legion::Data)
+        expect(actor.enabled?).to be_falsey
+      end
+    end
+
+    context 'when Legion::Data is defined and data is connected' do
+      it 'returns truthy' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        settings_double = { connected: true }
+        allow(Legion::Settings).to receive(:[]).with(:data).and_return(settings_double)
+        expect(actor.enabled?).to be_truthy
+      end
+    end
+
+    context 'when Legion::Data is defined but connected is false' do
+      it 'returns false' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        settings_double = { connected: false }
+        allow(Legion::Settings).to receive(:[]).with(:data).and_return(settings_double)
+        expect(actor.enabled?).to be false
+      end
+    end
+
+    context 'when Legion::Settings raises an error' do
+      it 'returns false' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        allow(Legion::Settings).to receive(:[]).with(:data).and_raise(StandardError)
+        expect(actor.enabled?).to be false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/identity/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to identity runner methods' do
+    expect(client).to respond_to(:observe_behavior)
+    expect(client).to respond_to(:observe_all)
+    expect(client).to respond_to(:check_entropy)
+    expect(client).to respond_to(:identity_status)
+    expect(client).to respond_to(:identity_maturity)
+  end
+
+  it 'round-trips identity lifecycle' do
+    # Build identity
+    50.times do
+      client.observe_all(observations: {
+                           communication_cadence: 0.5 + (rand * 0.1),
+                           vocabulary_patterns:   0.6 + (rand * 0.1),
+                           emotional_response:    0.4 + (rand * 0.1)
+                         })
+    end
+
+    expect(client.identity_maturity[:maturity]).to eq(:established)
+
+    # Check entropy with consistent behavior
+    result = client.check_entropy(observations: { communication_cadence: 0.55 })
+    expect(result[:entropy]).to be_between(0.0, 1.0)
+  end
+end

data/spec/legion/extensions/agentic/self/identity/helpers/dimensions_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::Dimensions do
+  describe '.new_identity_model' do
+    it 'creates a model with 6 dimensions' do
+      model = described_class.new_identity_model
+      expect(model.size).to eq(6)
+      described_class::IDENTITY_DIMENSIONS.each do |dim|
+        expect(model[dim][:mean]).to eq(0.5)
+      end
+    end
+  end
+
+  describe '.compute_entropy' do
+    it 'returns 0.5 for empty observations' do
+      model = described_class.new_identity_model
+      expect(described_class.compute_entropy({}, model)).to eq(0.5)
+    end
+
+    it 'returns low entropy for observations matching baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      obs = { communication_cadence: 0.5 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be < 0.3
+    end
+
+    it 'returns high entropy for observations diverging from baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      model[:communication_cadence][:variance] = 0.1
+      obs = { communication_cadence: 1.0 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be > 0.3
+    end
+  end
+
+  describe '.classify_entropy' do
+    it 'classifies high entropy' do
+      expect(described_class.classify_entropy(0.8)).to eq(:high_entropy)
+    end
+
+    it 'classifies low entropy' do
+      expect(described_class.classify_entropy(0.1)).to eq(:low_entropy)
+    end
+
+    it 'classifies normal entropy' do
+      expect(described_class.classify_entropy(0.5)).to eq(:normal)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/identity/helpers/fingerprint_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::Fingerprint do
+  let(:fp) { described_class.new }
+
+  describe '#observe' do
+    it 'records observation for valid dimension' do
+      fp.observe(:communication_cadence, 0.7)
+      expect(fp.observation_count).to eq(1)
+    end
+
+    it 'ignores invalid dimensions' do
+      fp.observe(:nonexistent, 0.5)
+      expect(fp.observation_count).to eq(0)
+    end
+
+    it 'shifts mean toward observed values' do
+      original = fp.model[:vocabulary_patterns][:mean]
+      10.times { fp.observe(:vocabulary_patterns, 0.9) }
+      expect(fp.model[:vocabulary_patterns][:mean]).to be > original
+    end
+  end
+
+  describe '#observe_all' do
+    it 'records multiple dimensions at once' do
+      fp.observe_all(communication_cadence: 0.6, vocabulary_patterns: 0.7)
+      expect(fp.observation_count).to eq(2)
+    end
+  end
+
+  describe '#current_entropy' do
+    it 'computes entropy against model' do
+      entropy = fp.current_entropy(communication_cadence: 0.5)
+      expect(entropy).to be_between(0.0, 1.0)
+    end
+
+    it 'tracks entropy history' do
+      3.times { fp.current_entropy(communication_cadence: 0.5) }
+      expect(fp.entropy_history.size).to eq(3)
+    end
+  end
+
+  describe '#entropy_trend' do
+    it 'returns stable for insufficient data' do
+      expect(fp.entropy_trend).to eq(:stable)
+    end
+
+    it 'detects rising entropy' do
+      5.times { |i| fp.current_entropy(communication_cadence: 0.5 + (i * 0.1)) }
+      # Trend depends on actual computed values
+      trend = fp.entropy_trend(window: 5)
+      expect(%i[rising stable falling]).to include(trend)
+    end
+  end
+
+  describe '#maturity' do
+    it 'starts as nascent' do
+      expect(fp.maturity).to eq(:nascent)
+    end
+
+    it 'progresses to developing' do
+      15.times { fp.observe(:communication_cadence, 0.5) }
+      expect(fp.maturity).to eq(:developing)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/identity/helpers/graph_client_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/identity/helpers/graph_client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::GraphClient do
+  describe '.connection' do
+    it 'returns a Faraday connection with bearer token' do
+      conn = described_class.connection(token: 'test-token')
+      expect(conn).to be_a(Faraday::Connection)
+      expect(conn.headers['Authorization']).to eq('Bearer test-token')
+    end
+
+    it 'uses custom base URL when provided' do
+      conn = described_class.connection(token: 'tok', base: 'https://custom.api.com')
+      expect(conn.url_prefix.to_s).to eq('https://custom.api.com/')
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/identity/helpers/graph_token_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/identity/helpers/graph_token'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::GraphToken do
+  describe '.fetch' do
+    it 'raises GraphTokenError on failure' do
+      stub_request = instance_double(Faraday::Response, success?: false,
+                                                        body:     { 'error_description' => 'invalid_client' })
+      conn = instance_double(Faraday::Connection)
+      allow(conn).to receive(:post).and_return(stub_request)
+      allow(Faraday).to receive(:new).and_return(conn)
+
+      expect do
+        described_class.fetch(tenant_id: 't1', client_id: 'c1', client_secret: 's1')
+      end.to raise_error(described_class::GraphTokenError, 'invalid_client')
+    end
+
+    it 'returns access_token on success' do
+      stub_request = instance_double(Faraday::Response, success?: true,
+                                                        body:     { 'access_token' => 'tok-123' })
+      conn = instance_double(Faraday::Connection)
+      allow(conn).to receive(:post).and_return(stub_request)
+      allow(Faraday).to receive(:new).and_return(conn)
+
+      token = described_class.fetch(tenant_id: 't1', client_id: 'c1', client_secret: 's1')
+      expect(token).to eq('tok-123')
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/identity/helpers/token_cache_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/identity/helpers/token_cache'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::TokenCache do
+  before { described_class.clear_all }
+  after { described_class.clear_all }
+
+  describe '.store and .fetch' do
+    it 'stores and retrieves a token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      entry = described_class.fetch(worker_id: 'w1')
+      expect(entry[:access_token]).to eq('abc')
+    end
+
+    it 'returns nil for unknown worker' do
+      expect(described_class.fetch(worker_id: 'unknown')).to be_nil
+    end
+
+    it 'returns nil for expired token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: -1)
+      expect(described_class.fetch(worker_id: 'w1')).to be_nil
+    end
+  end
+
+  describe '.approaching_expiry?' do
+    it 'returns true when no token exists' do
+      expect(described_class.approaching_expiry?(worker_id: 'w1')).to be true
+    end
+
+    it 'returns true when token is within buffer' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 100)
+      expect(described_class.approaching_expiry?(worker_id: 'w1', buffer: 200)).to be true
+    end
+
+    it 'returns false when token has plenty of time' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      expect(described_class.approaching_expiry?(worker_id: 'w1', buffer: 300)).to be false
+    end
+  end
+
+  describe '.clear' do
+    it 'removes a specific worker token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      described_class.clear(worker_id: 'w1')
+      expect(described_class.fetch(worker_id: 'w1')).to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+# Local persistence spec for Legion::Extensions::Agentic::Self::Identity::Helpers::Fingerprint
+#
+# Strategy: stub Legion::Data::Local with a real in-memory Sequel SQLite database
+# when sequel + sqlite3 are available, otherwise use a double that records calls.
+# Either way, the Fingerprint save/load logic is exercised end-to-end.
+
+begin
+  require 'sequel'
+  require 'sqlite3'
+  SEQUEL_AVAILABLE = true
+rescue LoadError
+  SEQUEL_AVAILABLE = false
+end
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Helpers::Fingerprint, 'local persistence' do
+  # ---------------------------------------------------------------------------
+  # Helpers for setting up the in-memory DB (shared between contexts)
+  # ---------------------------------------------------------------------------
+
+  def build_in_memory_db
+    db = Sequel.sqlite
+    db.create_table(:identity_fingerprint) do
+      primary_key :id
+      String  :dimension,     null: false, unique: true
+      Float   :mean,          default: 0.0
+      Float   :variance,      default: 0.0
+      Integer :observations,  default: 0
+      DateTime :last_observed
+    end
+    db.create_table(:identity_meta) do
+      primary_key :id
+      Integer :observation_count, default: 0
+      String  :entropy_history,   text: true
+    end
+    db
+  end
+
+  def stub_local(db)
+    local_mod = Module.new do
+      define_singleton_method(:connection)  { db }
+      define_singleton_method(:connected?)  { true }
+    end
+    stub_const('Legion::Data', Module.new)
+    stub_const('Legion::Data::Local', local_mod)
+  end
+
+  # ---------------------------------------------------------------------------
+  # When Sequel + sqlite3 are available: full round-trip integration tests
+  # ---------------------------------------------------------------------------
+
+  if SEQUEL_AVAILABLE
+    context 'with an in-memory SQLite database' do
+      let(:db) { build_in_memory_db }
+
+      before { stub_local(db) }
+
+      describe '#save_to_local' do
+        it 'returns true on first save' do
+          fp = described_class.new
+          expect(fp.save_to_local).to be true
+        end
+
+        it 'persists all 6 dimension rows to identity_fingerprint' do
+          fp = described_class.new
+          fp.observe(:communication_cadence, 0.8)
+          fp.save_to_local
+
+          rows = db[:identity_fingerprint].all
+          expect(rows.size).to eq(6)
+        end
+
+        it 'persists updated mean for observed dimension' do
+          fp = described_class.new
+          10.times { fp.observe(:vocabulary_patterns, 0.9) }
+          fp.save_to_local
+
+          row = db[:identity_fingerprint].where(dimension: 'vocabulary_patterns').first
+          expect(row[:mean]).to be > 0.5
+          expect(row[:observations]).to eq(10)
+        end
+
+        it 'persists observation_count in identity_meta' do
+          fp = described_class.new
+          3.times { fp.observe(:communication_cadence, 0.6) }
+          fp.save_to_local
+
+          meta = db[:identity_meta].first
+          expect(meta[:observation_count]).to eq(3)
+        end
+
+        it 'persists entropy_history as JSON in identity_meta' do
+          fp = described_class.new
+          fp.current_entropy(communication_cadence: 0.5)
+          fp.current_entropy(vocabulary_patterns: 0.6)
+          fp.save_to_local
+
+          meta = db[:identity_meta].first
+          parsed = JSON.parse(meta[:entropy_history])
+          expect(parsed.size).to eq(2)
+          expect(parsed.first).to have_key('entropy')
+          expect(parsed.first).to have_key('at')
+        end
+
+        it 'updates existing rows on second save (upsert)' do
+          fp = described_class.new
+          fp.observe(:emotional_response, 0.3)
+          fp.save_to_local
+
+          # mutate and save again
+          5.times { fp.observe(:emotional_response, 0.9) }
+          fp.save_to_local
+
+          rows = db[:identity_fingerprint].where(dimension: 'emotional_response').all
+          expect(rows.size).to eq(1) # still one row, not two
+          expect(rows.first[:observations]).to eq(6)
+        end
+      end
+
+      describe '#load_from_local' do
+        it 'returns true when called with an empty DB' do
+          fp = described_class.new # load_from_local called in initialize
+          expect(fp.observation_count).to eq(0)
+        end
+
+        it 'restores model dimensions from DB rows' do
+          # Pre-seed DB directly
+          db[:identity_fingerprint].insert(
+            dimension: 'communication_cadence',
+            mean: 0.75, variance: 0.05, observations: 42,
+            last_observed: Time.now.utc
+          )
+
+          fp = described_class.new # triggers load_from_local
+          expect(fp.model[:communication_cadence][:mean]).to be_within(0.001).of(0.75)
+          expect(fp.model[:communication_cadence][:observations]).to eq(42)
+        end
+
+        it 'restores observation_count from identity_meta' do
+          db[:identity_meta].insert(observation_count: 57, entropy_history: '[]')
+
+          fp = described_class.new
+          expect(fp.observation_count).to eq(57)
+        end
+
+        it 'restores entropy_history from identity_meta JSON' do
+          history = [
+            { 'entropy' => 0.3, 'at' => Time.now.utc.iso8601 },
+            { 'entropy' => 0.4, 'at' => Time.now.utc.iso8601 }
+          ]
+          db[:identity_meta].insert(observation_count: 0, entropy_history: JSON.generate(history))
+
+          fp = described_class.new
+          expect(fp.entropy_history.size).to eq(2)
+          expect(fp.entropy_history.first[:entropy]).to be_within(0.001).of(0.3)
+          expect(fp.entropy_history.first[:at]).to be_a(Time)
+        end
+
+        it 'ignores DB rows for unknown dimensions' do
+          db[:identity_fingerprint].insert(
+            dimension: 'nonexistent_dimension',
+            mean: 0.9, variance: 0.1, observations: 5,
+            last_observed: nil
+          )
+
+          fp = described_class.new # must not raise
+          expect(fp.model.keys).to match_array(
+            %i[communication_cadence vocabulary_patterns emotional_response
+               decision_patterns contextual_consistency temporal_patterns]
+          )
+        end
+      end
+
+      describe 'full round-trip' do
+        it 'survives a save-then-load cycle with identical state' do
+          # Build state in first fingerprint instance
+          fp1 = described_class.new
+          12.times { fp1.observe(:communication_cadence, 0.7) }
+          8.times  { fp1.observe(:vocabulary_patterns,   0.6) }
+          fp1.current_entropy(communication_cadence: 0.65)
+          fp1.current_entropy(vocabulary_patterns: 0.55)
+          fp1.save_to_local
+
+          # Load into a fresh instance (DB already populated)
+          fp2 = described_class.new
+
+          expect(fp2.observation_count).to eq(fp1.observation_count)
+          expect(fp2.entropy_history.size).to eq(fp1.entropy_history.size)
+
+          dims = %i[communication_cadence vocabulary_patterns]
+          dims.each do |dim|
+            expect(fp2.model[dim][:mean]).to be_within(0.0001).of(fp1.model[dim][:mean])
+            expect(fp2.model[dim][:variance]).to be_within(0.0001).of(fp1.model[dim][:variance])
+            expect(fp2.model[dim][:observations]).to eq(fp1.model[dim][:observations])
+          end
+        end
+
+        it 'preserves maturity after round-trip' do
+          fp1 = described_class.new
+          15.times { fp1.observe(:decision_patterns, 0.5) }
+          expect(fp1.maturity).to eq(:developing)
+          fp1.save_to_local
+
+          fp2 = described_class.new
+          expect(fp2.maturity).to eq(:developing)
+        end
+
+        it 'preserves entropy trend direction after round-trip' do
+          fp1 = described_class.new
+          # Ascending entropy values — second half larger than first half
+          [0.1, 0.1, 0.1, 0.1, 0.7, 0.8, 0.9, 0.95, 0.98, 1.0].each do |e|
+            fp1.instance_variable_get(:@entropy_history) << { entropy: e, at: Time.now.utc }
+          end
+          fp1.save_to_local
+
+          fp2 = described_class.new
+          expect(fp2.entropy_history.map { |h| h[:entropy] }).to eq(
+            fp1.entropy_history.map { |h| h[:entropy] }
+          )
+        end
+      end
+    end
+
+  else
+    # ---------------------------------------------------------------------------
+    # Fallback: double-based tests when Sequel is not in the bundle
+    # ---------------------------------------------------------------------------
+
+    context 'when Sequel is not available (double-based fallback)' do
+      let(:fingerprint_rows) { {} }
+      let(:meta_rows)        { [] }
+
+      let(:fp_dataset) do
+        d = double('fingerprint_dataset')
+        allow(d).to receive(:where) { |args|
+          scoped = double('scoped_fp_dataset')
+          allow(scoped).to receive(:first) { fingerprint_rows[args[:dimension]] }
+          allow(scoped).to receive(:update) { |row|
+            fingerprint_rows[row[:dimension] || args[:dimension]] = row
+          }
+          scoped
+        }
+        allow(d).to receive(:insert) { |row| fingerprint_rows[row[:dimension]] = row }
+        allow(d).to receive(:each)   { |&block| fingerprint_rows.each_value(&block) }
+        allow(d).to receive(:first)  { fingerprint_rows.values.first }
+        d
+      end
+
+      let(:meta_dataset) do
+        d = double('meta_dataset')
+        allow(d).to receive(:first)  { meta_rows.first }
+        allow(d).to receive(:insert) { |row| meta_rows << row }
+        allow(d).to receive(:where) do
+          scoped = double('scoped_meta_dataset')
+          allow(scoped).to receive(:update) { |row| meta_rows[0] = meta_rows[0]&.merge(row) }
+          scoped
+        end
+        d
+      end
+
+      let(:db) do
+        d = double('Sequel::Database')
+        allow(d).to receive(:[]).with(:identity_fingerprint).and_return(fp_dataset)
+        allow(d).to receive(:[]).with(:identity_meta).and_return(meta_dataset)
+        d
+      end
+
+      before do
+        local_mod = Module.new do
+          define_singleton_method(:connection)  { nil } # overridden per example
+          define_singleton_method(:connected?)  { true }
+        end
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Data::Local', local_mod)
+        allow(Legion::Data::Local).to receive(:connection).and_return(db)
+      end
+
+      it 'calls insert on the fingerprint dataset during save_to_local' do
+        fp = described_class.new
+        expect(fp_dataset).to receive(:insert).at_least(:once)
+        fp.save_to_local
+      end
+
+      it 'calls insert on the meta dataset during save_to_local' do
+        fp = described_class.new
+        expect(meta_dataset).to receive(:insert).once
+        fp.save_to_local
+      end
+
+      it 'does not raise when local is unavailable (Legion::Data::Local not defined)' do
+        # Remove the stub so defined? check returns false
+        hide_const('Legion::Data::Local')
+        expect { described_class.new }.not_to raise_error
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Behaviour when Legion::Data::Local is not defined (always run)
+  # ---------------------------------------------------------------------------
+
+  describe 'when Legion::Data::Local is not available' do
+    before do
+      hide_const('Legion::Data::Local') if defined?(Legion::Data::Local)
+    end
+
+    it 'initialize completes without error' do
+      expect { described_class.new }.not_to raise_error
+    end
+
+    it 'save_to_local returns nil (guard short-circuits)' do
+      fp = described_class.new
+      expect(fp.save_to_local).to be_nil
+    end
+
+    it 'load_from_local returns nil (guard short-circuits)' do
+      fp = described_class.new
+      expect(fp.load_from_local).to be_nil
+    end
+
+    it 'model starts with fresh defaults' do
+      fp = described_class.new
+      expect(fp.model[:communication_cadence][:mean]).to eq(0.5)
+      expect(fp.observation_count).to eq(0)
+      expect(fp.entropy_history).to be_empty
+    end
+  end
+end