lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/default_mode_network/helpers/wandering_thought_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::WanderingThought do
+  subject(:thought) do
+    described_class.new(
+      seed:              :identity,
+      association_chain: %i[identity values purpose],
+      domain:            :self,
+      thought_type:      :self_referential,
+      salience:          0.6
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns all fields' do
+      expect(thought.seed).to eq(:identity)
+      expect(thought.association_chain).to eq(%i[identity values purpose])
+      expect(thought.domain).to eq(:self)
+      expect(thought.thought_type).to eq(:self_referential)
+      expect(thought.salience).to eq(0.6)
+    end
+
+    it 'generates a UUID id' do
+      expect(thought.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'records created_at as a Time' do
+      expect(thought.created_at).to be_a(Time)
+    end
+
+    it 'clamps salience to 0..1' do
+      high = described_class.new(seed: :x, association_chain: [], domain: :d, thought_type: :wandering, salience: 5.0)
+      low  = described_class.new(seed: :x, association_chain: [], domain: :d, thought_type: :wandering, salience: -1.0)
+      expect(high.salience).to eq(1.0)
+      expect(low.salience).to eq(0.0)
+    end
+
+    it 'coerces thought_type to symbol' do
+      t = described_class.new(seed: :x, association_chain: [], domain: :d, thought_type: 'wandering')
+      expect(t.thought_type).to eq(:wandering)
+    end
+
+    it 'wraps non-array association_chain in an array' do
+      t = described_class.new(seed: :x, association_chain: :single, domain: :d, thought_type: :wandering)
+      expect(t.association_chain).to eq([:single])
+    end
+  end
+
+  describe '#boost_salience' do
+    it 'increases salience by SALIENCE_ALPHA by default' do
+      before = thought.salience
+      thought.boost_salience
+      expect(thought.salience).to be_within(0.001).of(before + described_module::SALIENCE_ALPHA)
+    end
+
+    it 'accepts a custom amount' do
+      before = thought.salience
+      thought.boost_salience(0.2)
+      expect(thought.salience).to be_within(0.001).of(before + 0.2)
+    end
+
+    it 'caps at 1.0' do
+      thought.salience = 0.99
+      thought.boost_salience(0.5)
+      expect(thought.salience).to eq(1.0)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces salience by THOUGHT_DECAY' do
+      before = thought.salience
+      thought.decay
+      expect(thought.salience).to be_within(0.001).of(before - described_module::THOUGHT_DECAY)
+    end
+
+    it 'does not drop below THOUGHT_SALIENCE_FLOOR' do
+      500.times { thought.decay }
+      expect(thought.salience).to be >= described_module::THOUGHT_SALIENCE_FLOOR
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns false for a strong thought' do
+      expect(thought.faded?).to be false
+    end
+
+    it 'returns true at the salience floor' do
+      thought.salience = described_module::THOUGHT_SALIENCE_FLOOR
+      expect(thought.faded?).to be true
+    end
+
+    it 'returns false just above the floor' do
+      thought.salience = described_module::THOUGHT_SALIENCE_FLOOR + 0.01
+      expect(thought.faded?).to be false
+    end
+  end
+
+  describe '#label' do
+    it 'returns :significant for salience 0.7' do
+      thought.salience = 0.7
+      expect(thought.label).to eq(:significant)
+    end
+
+    it 'returns :breakthrough for salience 0.9' do
+      thought.salience = 0.9
+      expect(thought.label).to eq(:breakthrough)
+    end
+
+    it 'returns :fleeting for salience 0.1' do
+      thought.salience = 0.1
+      expect(thought.label).to eq(:fleeting)
+    end
+
+    it 'returns :notable for salience 0.5' do
+      thought.salience = 0.5
+      expect(thought.label).to eq(:notable)
+    end
+
+    it 'returns :passing for salience 0.3' do
+      thought.salience = 0.3
+      expect(thought.label).to eq(:passing)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = thought.to_h
+      expect(h).to include(:id, :seed, :association_chain, :domain, :thought_type, :salience, :label, :created_at)
+    end
+
+    it 'includes the current label' do
+      thought.salience = 0.9
+      expect(thought.to_h[:label]).to eq(:breakthrough)
+    end
+
+    it 'rounds salience to 4 decimal places' do
+      thought.salience = 0.123456789
+      expect(thought.to_h[:salience]).to eq(0.1235)
+    end
+  end
+
+  def described_module
+    Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants
+  end
+end

data/spec/legion/extensions/agentic/self/default_mode_network/runners/default_mode_network_spec.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::DefaultModeNetwork::Runners::DefaultModeNetwork do
+  let(:client) { Legion::Extensions::Agentic::Self::DefaultModeNetwork::Client.new }
+
+  describe '#register_external_stimulus' do
+    it 'returns success' do
+      result = client.register_external_stimulus(source: :user_request)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns mode fields' do
+      result = client.register_external_stimulus(source: :test)
+      expect(result).to have_key(:previous_mode)
+      expect(result).to have_key(:current_mode)
+    end
+
+    it 'resets to :active mode' do
+      result = client.register_external_stimulus
+      expect(result[:current_mode]).to eq(:active)
+    end
+
+    it 'includes source in result' do
+      result = client.register_external_stimulus(source: :webhook)
+      expect(result[:source]).to eq(:webhook)
+    end
+  end
+
+  describe '#generate_idle_thought' do
+    it 'returns success' do
+      result = client.generate_idle_thought
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a thought hash' do
+      result = client.generate_idle_thought
+      expect(result[:thought]).to be_a(Hash)
+      expect(result[:thought]).to include(:id, :seed, :thought_type, :salience)
+    end
+
+    it 'thought has a valid type' do
+      valid_types = %w[self_referential social_replay spontaneous_plan wandering]
+      result      = client.generate_idle_thought
+      expect(valid_types).to include(result[:thought][:thought_type].to_s)
+    end
+  end
+
+  describe '#trigger_self_reflection' do
+    it 'returns success' do
+      result = client.trigger_self_reflection
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a self_referential thought' do
+      result = client.trigger_self_reflection
+      expect(result[:thought][:thought_type]).to eq(:self_referential)
+    end
+
+    it 'thought has domain :self' do
+      result = client.trigger_self_reflection
+      expect(result[:thought][:domain]).to eq(:self)
+    end
+
+    it 'includes association chain' do
+      result = client.trigger_self_reflection
+      expect(result[:thought][:association_chain]).to be_an(Array)
+      expect(result[:thought][:association_chain]).not_to be_empty
+    end
+  end
+
+  describe '#trigger_social_replay' do
+    it 'returns success' do
+      result = client.trigger_social_replay(interaction: :standup)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a social_replay thought' do
+      result = client.trigger_social_replay
+      expect(result[:thought][:thought_type]).to eq(:social_replay)
+    end
+
+    it 'uses provided interaction as seed' do
+      result = client.trigger_social_replay(interaction: :team_meeting)
+      expect(result[:thought][:seed]).to eq(:team_meeting)
+    end
+
+    it 'uses default seed when interaction is nil' do
+      result = client.trigger_social_replay
+      expect(result[:thought][:seed]).not_to be_nil
+    end
+
+    it 'thought domain is :social' do
+      result = client.trigger_social_replay
+      expect(result[:thought][:domain]).to eq(:social)
+    end
+  end
+
+  describe '#trigger_spontaneous_plan' do
+    it 'returns success' do
+      result = client.trigger_spontaneous_plan(goal: :reduce_latency)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a spontaneous_plan thought' do
+      result = client.trigger_spontaneous_plan
+      expect(result[:thought][:thought_type]).to eq(:spontaneous_plan)
+    end
+
+    it 'uses provided goal as seed' do
+      result = client.trigger_spontaneous_plan(goal: :scale_out)
+      expect(result[:thought][:seed]).to eq(:scale_out)
+    end
+
+    it 'thought domain is :planning' do
+      result = client.trigger_spontaneous_plan
+      expect(result[:thought][:domain]).to eq(:planning)
+    end
+
+    it 'salience is in range 0..1' do
+      result = client.trigger_spontaneous_plan
+      expect(result[:thought][:salience]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#trigger_wandering' do
+    it 'returns success' do
+      result = client.trigger_wandering(seed: :curiosity)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a wandering thought' do
+      result = client.trigger_wandering
+      expect(result[:thought][:thought_type]).to eq(:wandering)
+    end
+
+    it 'uses provided seed' do
+      result = client.trigger_wandering(seed: :pattern)
+      expect(result[:thought][:seed]).to eq(:pattern)
+    end
+
+    it 'thought domain is :associative' do
+      result = client.trigger_wandering
+      expect(result[:thought][:domain]).to eq(:associative)
+    end
+
+    it 'association chain starts with the seed' do
+      result = client.trigger_wandering(seed: :creativity)
+      expect(result[:thought][:association_chain].first).to eq(:creativity)
+    end
+  end
+
+  describe '#salient_thoughts' do
+    before do
+      3.times { client.generate_idle_thought }
+    end
+
+    it 'returns success' do
+      result = client.salient_thoughts(count: 2)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns up to count thoughts' do
+      result = client.salient_thoughts(count: 2)
+      expect(result[:thoughts].size).to be <= 2
+    end
+
+    it 'includes count in result' do
+      result = client.salient_thoughts(count: 3)
+      expect(result[:count]).to eq(result[:thoughts].size)
+    end
+
+    it 'thoughts are hashes with expected keys' do
+      result = client.salient_thoughts(count: 1)
+      result[:thoughts].each do |t|
+        expect(t).to include(:id, :thought_type, :salience)
+      end
+    end
+
+    it 'returns empty array when no thoughts exist' do
+      fresh_client = Legion::Extensions::Agentic::Self::DefaultModeNetwork::Client.new
+      result       = fresh_client.salient_thoughts
+      expect(result[:thoughts]).to be_empty
+    end
+  end
+
+  describe '#dmn_mode_status' do
+    it 'returns success' do
+      result = client.dmn_mode_status
+      expect(result[:success]).to be true
+    end
+
+    it 'returns mode as symbol' do
+      result = client.dmn_mode_status
+      expect(%i[active transitioning idle deep_idle]).to include(result[:mode])
+    end
+
+    it 'includes mode_label' do
+      result = client.dmn_mode_status
+      labels = Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants::ACTIVITY_LABELS.values
+      expect(labels).to include(result[:mode_label])
+    end
+
+    it 'includes idle_duration as float' do
+      result = client.dmn_mode_status
+      expect(result[:idle_duration]).to be_a(Float)
+    end
+
+    it 'includes thought_count' do
+      result = client.dmn_mode_status
+      expect(result).to have_key(:thought_count)
+    end
+  end
+
+  describe '#update_dmn' do
+    it 'returns success' do
+      result = client.update_dmn
+      expect(result[:success]).to be true
+    end
+
+    it 'returns mode after tick' do
+      result = client.update_dmn
+      expect(%i[active transitioning idle deep_idle]).to include(result[:mode])
+    end
+
+    it 'returns previous_mode' do
+      result = client.update_dmn
+      expect(result).to have_key(:previous_mode)
+    end
+
+    it 'returns faded_count' do
+      result = client.update_dmn
+      expect(result[:faded_count]).to be_a(Integer)
+    end
+
+    it 'returns thought_count after decay' do
+      result = client.update_dmn
+      expect(result[:thought_count]).to be_a(Integer)
+    end
+
+    it 'generates a new thought when idle' do
+      engine = Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::DmnEngine.new
+      allow(engine).to receive(:idle_duration).and_return(60.0)
+      engine.tick_mode # force to :idle
+      idle_client = Legion::Extensions::Agentic::Self::DefaultModeNetwork::Client.new(dmn_engine: engine)
+      result      = idle_client.update_dmn
+      expect(result[:new_thought]).not_to be_nil
+    end
+
+    it 'new_thought is nil when active' do
+      result = client.update_dmn
+      # When just initialized, mode is active — no thought generated by update_dmn
+      # (may be nil or a thought depending on mode after tick)
+      expect(result).to have_key(:new_thought)
+    end
+  end
+
+  describe '#dmn_stats' do
+    it 'returns success' do
+      result = client.dmn_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes stats hash' do
+      result = client.dmn_stats
+      expect(result[:stats]).to be_a(Hash)
+      expect(result[:stats]).to include(:mode, :mode_label, :idle_duration, :thought_count)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/fingerprint/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Fingerprint::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to record_observation' do
+    expect(client).to respond_to(:record_observation)
+  end
+
+  it 'responds to verify_identity' do
+    expect(client).to respond_to(:verify_identity)
+  end
+
+  it 'responds to anomaly_check' do
+    expect(client).to respond_to(:anomaly_check)
+  end
+
+  it 'responds to trait_profile' do
+    expect(client).to respond_to(:trait_profile)
+  end
+
+  it 'responds to strongest_traits' do
+    expect(client).to respond_to(:strongest_traits)
+  end
+
+  it 'responds to weakest_traits' do
+    expect(client).to respond_to(:weakest_traits)
+  end
+
+  it 'responds to identity_confidence' do
+    expect(client).to respond_to(:identity_confidence)
+  end
+
+  it 'responds to fingerprint_hash' do
+    expect(client).to respond_to(:fingerprint_hash)
+  end
+
+  it 'responds to fingerprint_report' do
+    expect(client).to respond_to(:fingerprint_report)
+  end
+
+  it 'responds to fingerprint_status' do
+    expect(client).to respond_to(:fingerprint_status)
+  end
+
+  it 'each instance has independent state' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.record_observation(category: :accuracy, value: 0.9)
+    expect(c2.fingerprint_status[:trait_count]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/self/fingerprint/helpers/cognitive_trait_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Fingerprint::Helpers::CognitiveTrait do
+  let(:trait) { described_class.new(category: :accuracy) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(trait.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets category' do
+      expect(trait.category).to eq(:accuracy)
+    end
+
+    it 'starts with baseline 0.5' do
+      expect(trait.baseline).to eq(0.5)
+    end
+
+    it 'starts with zero variance' do
+      expect(trait.variance).to eq(0.0)
+    end
+
+    it 'starts with zero sample count' do
+      expect(trait.sample_count).to eq(0)
+    end
+
+    it 'sets last_updated to a Time' do
+      expect(trait.last_updated).to be_a(Time)
+    end
+
+    it 'raises for unknown category' do
+      expect { described_class.new(category: :nonexistent) }.to raise_error(ArgumentError, /unknown category/)
+    end
+
+    it 'accepts all valid categories' do
+      Legion::Extensions::Agentic::Self::Fingerprint::Helpers::Constants::TRAIT_CATEGORIES.each do |cat|
+        expect { described_class.new(category: cat) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#record_sample!' do
+    it 'returns self for chaining' do
+      expect(trait.record_sample!(0.8)).to eq(trait)
+    end
+
+    it 'shifts baseline toward sample (EMA)' do
+      original = trait.baseline
+      trait.record_sample!(1.0)
+      expect(trait.baseline).to be > original
+    end
+
+    it 'shifts baseline down for low samples' do
+      original = trait.baseline
+      trait.record_sample!(0.0)
+      expect(trait.baseline).to be < original
+    end
+
+    it 'increments sample_count' do
+      trait.record_sample!(0.7)
+      expect(trait.sample_count).to eq(1)
+    end
+
+    it 'applies EMA_ALPHA correctly for one update' do
+      expected = (0.15 * 0.8) + (0.85 * 0.5)
+      trait.record_sample!(0.8)
+      expect(trait.baseline).to be_within(0.0000001).of(expected)
+    end
+
+    it 'clamps input values above 1.0' do
+      trait.record_sample!(5.0)
+      expect(trait.baseline).to be <= 1.0
+    end
+
+    it 'clamps input values below 0.0' do
+      trait.record_sample!(-2.0)
+      expect(trait.baseline).to be >= 0.0
+    end
+
+    it 'updates last_updated' do
+      before = trait.last_updated
+      trait.record_sample!(0.6)
+      expect(trait.last_updated).to be >= before
+    end
+
+    it 'caps sample_count at MAX_SAMPLES' do
+      (Legion::Extensions::Agentic::Self::Fingerprint::Helpers::Constants::MAX_SAMPLES + 10).times do
+        trait.record_sample!(0.5)
+      end
+      expect(trait.sample_count).to eq(Legion::Extensions::Agentic::Self::Fingerprint::Helpers::Constants::MAX_SAMPLES)
+    end
+
+    it 'accumulates variance over varying samples' do
+      trait.record_sample!(0.1)
+      trait.record_sample!(0.9)
+      expect(trait.variance).to be > 0.0
+    end
+
+    it 'rounds baseline to 10 decimal places' do
+      trait.record_sample!(0.333333333)
+      expect(trait.baseline.to_s.split('.').last.length).to be <= 10
+    end
+  end
+
+  describe '#deviation_from' do
+    it 'returns 0.0 for baseline value' do
+      expect(trait.deviation_from(0.5)).to eq(0.0)
+    end
+
+    it 'returns positive deviation for values above baseline' do
+      expect(trait.deviation_from(0.9)).to be > 0.0
+    end
+
+    it 'returns positive deviation for values below baseline' do
+      expect(trait.deviation_from(0.1)).to be > 0.0
+    end
+
+    it 'is always non-negative' do
+      expect(trait.deviation_from(0.0)).to be >= 0.0
+      expect(trait.deviation_from(1.0)).to be >= 0.0
+    end
+
+    it 'clamps out-of-range inputs' do
+      dev_low  = trait.deviation_from(-1.0)
+      dev_zero = trait.deviation_from(0.0)
+      expect(dev_low).to eq(dev_zero)
+    end
+  end
+
+  describe '#stable?' do
+    it 'is stable with zero variance' do
+      expect(trait.stable?).to be true
+    end
+
+    it 'is not stable when variance exceeds 0.1' do
+      5.times { trait.record_sample!(0.1) }
+      5.times { trait.record_sample!(0.9) }
+      # After divergent samples variance should grow beyond threshold
+      trait.record_sample!(0.0)
+      trait.record_sample!(1.0)
+      # variance might still be low from EMA; just check the boundary condition
+      low_var_trait = described_class.new(category: :accuracy)
+      expect(low_var_trait.stable?).to be true
+    end
+  end
+
+  describe '#volatile?' do
+    it 'is not volatile with zero variance' do
+      expect(trait.volatile?).to be false
+    end
+  end
+
+  describe '#strength_label' do
+    it 'returns a valid label symbol' do
+      valid = %i[dominant strong moderate weak absent]
+      expect(valid).to include(trait.strength_label)
+    end
+
+    it 'returns :moderate for default baseline of 0.5' do
+      expect(trait.strength_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { trait.to_h }
+
+    it 'includes required keys' do
+      %i[id category baseline variance sample_count stable volatile strength last_updated].each do |key|
+        expect(hash).to have_key(key)
+      end
+    end
+
+    it 'reflects current state' do
+      trait.record_sample!(0.8)
+      h = trait.to_h
+      expect(h[:sample_count]).to eq(1)
+      expect(h[:baseline]).to be > 0.5
+    end
+  end
+end