lex-agentic-self 0.1.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/identity/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Identity::Runners::Identity do
+  let(:client) { Legion::Extensions::Agentic::Self::Identity::Client.new }
+
+  describe '#observe_behavior' do
+    it 'records a single observation' do
+      result = client.observe_behavior(dimension: :communication_cadence, value: 0.7)
+      expect(result[:recorded]).to be true
+      expect(result[:observation_count]).to eq(1)
+    end
+  end
+
+  describe '#observe_all' do
+    it 'records multiple observations' do
+      result = client.observe_all(observations: {
+                                    communication_cadence: 0.6,
+                                    vocabulary_patterns:   0.7,
+                                    emotional_response:    0.5
+                                  })
+      expect(result[:dimensions_observed].size).to eq(3)
+      expect(result[:observation_count]).to eq(3)
+    end
+  end
+
+  describe '#check_entropy' do
+    it 'returns entropy classification' do
+      result = client.check_entropy
+      expect(result[:entropy]).to be_between(0.0, 1.0)
+      expect(result).to have_key(:classification)
+      expect(result).to have_key(:trend)
+      expect(result).to have_key(:in_range)
+    end
+
+    it 'warns on high entropy observations' do
+      # Build baseline
+      20.times { client.observe_behavior(dimension: :communication_cadence, value: 0.5) }
+      # Check with very different observation
+      result = client.check_entropy(observations: { communication_cadence: 10.0 })
+      expect(result[:warning]).to eq(:possible_impersonation_or_drift) if result[:classification] == :high_entropy
+    end
+  end
+
+  describe '#identity_status' do
+    it 'returns model state' do
+      status = client.identity_status
+      expect(status).to have_key(:model)
+      expect(status).to have_key(:maturity)
+      expect(status).to have_key(:observation_count)
+    end
+  end
+
+  describe '#identity_maturity' do
+    it 'returns maturity level' do
+      result = client.identity_maturity
+      expect(result[:maturity]).to eq(:nascent)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Client do
+  describe '#initialize' do
+    it 'creates a default snapshot store' do
+      client = described_class.new
+      expect(client.snapshot_store).to be_a(Legion::Extensions::Agentic::Self::Metacognition::Helpers::SnapshotStore)
+    end
+
+    it 'accepts an injected snapshot store' do
+      store = Legion::Extensions::Agentic::Self::Metacognition::Helpers::SnapshotStore.new
+      client = described_class.new(snapshot_store: store)
+      expect(client.snapshot_store).to equal(store)
+    end
+  end
+
+  it 'includes Runners::Metacognition' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition)
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/helpers/constants_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Helpers::Constants do
+  it 'defines MAX_SNAPSHOTS' do
+    expect(described_class::MAX_SNAPSHOTS).to eq(50)
+  end
+
+  it 'defines SNAPSHOT_TTL' do
+    expect(described_class::SNAPSHOT_TTL).to eq(30)
+  end
+
+  it 'defines SUBSYSTEMS as frozen array' do
+    expect(described_class::SUBSYSTEMS).to be_frozen
+    expect(described_class::SUBSYSTEMS).to include(:tick, :cortex, :memory)
+  end
+
+  it 'defines CAPABILITY_CATEGORIES' do
+    expect(described_class::CAPABILITY_CATEGORIES).to include(:perception, :cognition, :memory, :motivation, :safety)
+  end
+
+  it 'maps every extension to a capability category' do
+    described_class::EXTENSION_CAPABILITIES.each_value do |cat|
+      expect(described_class::CAPABILITY_CATEGORIES).to include(cat)
+    end
+  end
+
+  it 'defines HEALTH_LABELS for full range' do
+    labels = described_class::HEALTH_LABELS
+    expect(labels.size).to eq(5)
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/helpers/narrator_bridge_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Helpers::NarratorBridge do
+  let(:model) do
+    {
+      identity:     { framework: 'LegionIO', role: :cognitive_agent, model: :brain_modeled, extensions: 24 },
+      architecture: { total_extensions: 24, loaded_count: 18, unloaded_count: 6, loaded: Array.new(18, :Ext), unloaded: %i[A B C D E F] },
+      cognitive:    { mode: :full_active, phases_run: 12, health: 0.92, active_drives: %i[curiosity corrective], attention: { spotlight: 3 },
+curiosity: { open_wonders: 4 } },
+      capabilities: { perception: { active: true }, cognition: { active: true }, memory: { active: true }, motivation: { active: true },
+safety: { active: false } }
+    }
+  end
+
+  describe '.narrate_self_model' do
+    it 'produces a prose string' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to be_a(String)
+      expect(prose.length).to be > 50
+    end
+
+    it 'includes identity info' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to include('brain_modeled')
+      expect(prose).to include('LegionIO')
+    end
+
+    it 'includes architecture stats' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to include('18 of 24')
+    end
+
+    it 'includes cognitive state' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to include('full_active')
+      expect(prose).to include('12 phases')
+    end
+
+    it 'includes health label' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to include('excellent')
+    end
+
+    it 'includes active drives' do
+      prose = described_class.narrate_self_model(model)
+      expect(prose).to include('curiosity')
+    end
+  end
+
+  describe '.narrate_identity' do
+    it 'returns nil for non-hash' do
+      expect(described_class.narrate_identity(nil)).to be_nil
+    end
+
+    it 'describes the agent identity' do
+      result = described_class.narrate_identity(model[:identity])
+      expect(result).to include('24 extension slots')
+    end
+  end
+
+  describe '.narrate_architecture' do
+    it 'mentions missing extensions' do
+      result = described_class.narrate_architecture(model[:architecture])
+      expect(result).to include('Missing:')
+    end
+
+    it 'omits missing section when all loaded' do
+      arch = model[:architecture].merge(unloaded: [])
+      result = described_class.narrate_architecture(arch)
+      expect(result).not_to include('Missing')
+    end
+  end
+
+  describe '.narrate_cognitive' do
+    it 'returns no tick data message' do
+      result = described_class.narrate_cognitive(status: :no_tick_data)
+      expect(result).to include('No tick data')
+    end
+
+    it 'includes spotlight count' do
+      result = described_class.narrate_cognitive(model[:cognitive])
+      expect(result).to include('3 signals in spotlight')
+    end
+
+    it 'includes open wonders' do
+      result = described_class.narrate_cognitive(model[:cognitive])
+      expect(result).to include('4 open questions')
+    end
+  end
+
+  describe '.narrate_capabilities' do
+    it 'lists active capability categories' do
+      result = described_class.narrate_capabilities(model[:capabilities])
+      expect(result).to include('perception')
+      expect(result).not_to include('safety')
+    end
+
+    it 'returns nil for empty capabilities' do
+      expect(described_class.narrate_capabilities({})).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/helpers/registry_store_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Helpers::RegistryStore do
+  subject(:store) { described_class.new }
+
+  let(:entry) do
+    {
+      name:         'lex-memory',
+      module_name:  'Memory',
+      category:     'memory',
+      status:       'active',
+      health_score: 1.0
+    }
+  end
+
+  let(:entry2) do
+    {
+      name:         'lex-emotion',
+      module_name:  'Emotion',
+      category:     'perception',
+      status:       'active',
+      health_score: 0.9
+    }
+  end
+
+  describe '#register' do
+    it 'stores an entry by name' do
+      store.register(entry)
+      expect(store.count).to eq(1)
+    end
+
+    it 'sets created_at and updated_at on register' do
+      store.register(entry)
+      result = store.get('lex-memory')
+      expect(result[:created_at]).to be_a(Time)
+      expect(result[:updated_at]).to be_a(Time)
+    end
+
+    it 'sets invocation_count to 0 on register' do
+      store.register(entry)
+      expect(store.get('lex-memory')[:invocation_count]).to eq(0)
+    end
+
+    it 'sets health_score to 1.0 on register' do
+      entry_no_health = entry.except(:health_score)
+      store.register(entry_no_health)
+      expect(store.get('lex-memory')[:health_score]).to eq(1.0)
+    end
+
+    it 'overwrites an existing entry with the same name' do
+      store.register(entry)
+      store.register(entry.merge(category: 'cognition'))
+      expect(store.get('lex-memory')[:category]).to eq('cognition')
+      expect(store.count).to eq(1)
+    end
+  end
+
+  describe '#deregister' do
+    it 'removes an entry by name' do
+      store.register(entry)
+      store.deregister('lex-memory')
+      expect(store.count).to eq(0)
+    end
+
+    it 'returns nil when deregistering a non-existent name' do
+      expect(store.deregister('lex-nonexistent')).to be_nil
+    end
+  end
+
+  describe '#get' do
+    it 'returns nil for unknown name' do
+      expect(store.get('lex-unknown')).to be_nil
+    end
+
+    it 'returns a copy of the entry' do
+      store.register(entry)
+      result = store.get('lex-memory')
+      expect(result[:name]).to eq('lex-memory')
+    end
+
+    it 'returns a dup (not the same object)' do
+      store.register(entry)
+      result1 = store.get('lex-memory')
+      result2 = store.get('lex-memory')
+      expect(result1).not_to be(result2)
+    end
+  end
+
+  describe '#list' do
+    before do
+      store.register(entry)
+      store.register(entry2)
+      store.register(entry.merge(name: 'lex-episodic', category: 'memory', status: 'inactive'))
+    end
+
+    it 'returns all entries with no filters' do
+      expect(store.list.size).to eq(3)
+    end
+
+    it 'filters by status' do
+      active = store.list(status: 'active')
+      expect(active.size).to eq(2)
+      expect(active.map { |e| e[:status] }.uniq).to eq(['active'])
+    end
+
+    it 'filters by category' do
+      memory = store.list(category: 'memory')
+      expect(memory.size).to eq(2)
+    end
+
+    it 'filters by both status and category' do
+      result = store.list(status: 'active', category: 'memory')
+      expect(result.size).to eq(1)
+      expect(result.first[:name]).to eq('lex-memory')
+    end
+
+    it 'returns empty array when no match' do
+      expect(store.list(category: 'nonexistent')).to eq([])
+    end
+  end
+
+  describe '#update' do
+    it 'returns nil for unknown name' do
+      expect(store.update('lex-missing', { health_score: 0.5 })).to be_nil
+    end
+
+    it 'updates the specified attributes' do
+      store.register(entry)
+      result = store.update('lex-memory', { health_score: 0.75, status: 'degraded' })
+      expect(result[:health_score]).to eq(0.75)
+      expect(result[:status]).to eq('degraded')
+    end
+
+    it 'updates updated_at on modification' do
+      store.register(entry)
+      original_time = store.get('lex-memory')[:updated_at]
+      result = store.update('lex-memory', { health_score: 0.5 })
+      expect(result[:updated_at]).to be >= original_time
+    end
+
+    it 'preserves unchanged attributes' do
+      store.register(entry)
+      store.update('lex-memory', { health_score: 0.5 })
+      expect(store.get('lex-memory')[:module_name]).to eq('Memory')
+    end
+  end
+
+  describe '#category_distribution' do
+    it 'returns empty hash when no entries' do
+      expect(store.category_distribution).to eq({})
+    end
+
+    it 'counts entries per category' do
+      store.register(entry)
+      store.register(entry2)
+      store.register(entry.merge(name: 'lex-episodic', category: 'memory'))
+      dist = store.category_distribution
+      expect(dist['memory']).to eq(2)
+      expect(dist['perception']).to eq(1)
+    end
+  end
+
+  describe '#count' do
+    it 'returns 0 when empty' do
+      expect(store.count).to eq(0)
+    end
+
+    it 'returns the number of registered entries' do
+      store.register(entry)
+      store.register(entry2)
+      expect(store.count).to eq(2)
+    end
+  end
+
+  describe '#by_health' do
+    before do
+      store.register(entry.merge(health_score: 0.9))
+      store.register(entry2.merge(health_score: 0.3))
+      store.register(entry.merge(name: 'lex-prediction', module_name: 'Prediction', category: 'cognition', health_score: 0.1))
+    end
+
+    it 'returns entries below default threshold of 0.4' do
+      result = store.by_health
+      expect(result.size).to eq(2)
+      result.each { |e| expect(e[:health_score]).to be < 0.4 }
+    end
+
+    it 'accepts a custom threshold' do
+      result = store.by_health(threshold: 0.2)
+      expect(result.size).to eq(1)
+      expect(result.first[:health_score]).to eq(0.1)
+    end
+
+    it 'returns empty array when all entries are healthy' do
+      healthy_store = described_class.new
+      healthy_store.register(entry.merge(health_score: 0.95))
+      expect(healthy_store.by_health).to eq([])
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent registrations without data corruption' do
+      threads = 20.times.map do |i|
+        Thread.new do
+          store.register(entry.merge(name: "lex-thread-#{i}", module_name: "Mod#{i}"))
+        end
+      end
+      threads.each(&:join)
+      expect(store.count).to eq(20)
+    end
+
+    it 'handles concurrent reads and writes safely' do
+      store.register(entry)
+      errors = []
+      threads = 10.times.map do
+        Thread.new do
+          store.get('lex-memory')
+          store.update('lex-memory', { health_score: rand })
+        rescue StandardError => e
+          errors << e
+        end
+      end
+      threads.each(&:join)
+      expect(errors).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/helpers/self_model_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Helpers::SelfModel do
+  describe '.build' do
+    it 'returns a structured self-model' do
+      model = described_class.build
+      expect(model).to have_key(:identity)
+      expect(model).to have_key(:architecture)
+      expect(model).to have_key(:capabilities)
+      expect(model).to have_key(:subsystems)
+      expect(model).to have_key(:cognitive)
+      expect(model).to have_key(:assembled_at)
+    end
+
+    it 'includes identity information' do
+      model = described_class.build
+      expect(model[:identity][:framework]).to eq('LegionIO')
+      expect(model[:identity][:role]).to eq(:cognitive_agent)
+      expect(model[:identity][:model]).to eq(:brain_modeled)
+    end
+
+    it 'discovers Metacognition as loaded' do
+      model = described_class.build
+      expect(model[:architecture][:loaded]).to include(:Metacognition)
+    end
+
+    it 'includes cognitive snapshot from tick_results' do
+      tick_results = {
+        post_tick_reflection: { cognitive_health: 0.85 },
+        action_selection:     { intentions: [{ drive: :curiosity }] }
+      }
+      model = described_class.build(tick_results: tick_results)
+      expect(model[:cognitive][:health]).to eq(0.85)
+      expect(model[:cognitive][:active_drives]).to eq([:curiosity])
+    end
+
+    it 'returns no_tick_data for empty tick_results' do
+      model = described_class.build(tick_results: {})
+      expect(model[:cognitive][:status]).to eq(:no_tick_data)
+    end
+  end
+
+  describe '.discover_loaded_extensions' do
+    it 'returns hash of extension availability' do
+      result = described_class.discover_loaded_extensions
+      expect(result).to be_a(Hash)
+      expect(result[:Metacognition][:loaded]).to be true
+    end
+  end
+
+  describe '.map_capabilities' do
+    it 'groups loaded extensions by category' do
+      loaded = { Metacognition: { loaded: true }, Memory: { loaded: false } }
+      caps = described_class.map_capabilities(loaded)
+      expect(caps[:introspection][:active]).to be true
+      expect(caps[:memory][:active]).to be false
+    end
+
+    it 'lists extensions per category' do
+      loaded = { Metacognition: { loaded: true }, Reflection: { loaded: true } }
+      caps = described_class.map_capabilities(loaded)
+      expect(caps[:introspection][:extensions]).to include(:Metacognition, :Reflection)
+    end
+  end
+
+  describe '.build_cognitive_snapshot' do
+    it 'extracts attention data' do
+      tick_results = {
+        sensory_processing: { spotlight_count: 3, total_signals: 10 }
+      }
+      snapshot = described_class.build_cognitive_snapshot(tick_results)
+      expect(snapshot[:attention]).to eq(spotlight: 3, total: 10)
+    end
+
+    it 'extracts curiosity data' do
+      tick_results = {
+        working_memory_integration: { curiosity_intensity: 0.7, open_wonders: 4 }
+      }
+      snapshot = described_class.build_cognitive_snapshot(tick_results)
+      expect(snapshot[:curiosity]).to eq(intensity: 0.7, open_wonders: 4)
+    end
+
+    it 'extracts prediction data' do
+      tick_results = {
+        prediction_engine: { confidence: 0.9, mode: :functional_mapping }
+      }
+      snapshot = described_class.build_cognitive_snapshot(tick_results)
+      expect(snapshot[:prediction]).to eq(confidence: 0.9, mode: :functional_mapping)
+    end
+  end
+
+  describe '.health_label' do
+    it 'returns :excellent for >= 0.8' do
+      expect(described_class.health_label(0.92)).to eq(:excellent)
+    end
+
+    it 'returns :good for 0.6-0.8' do
+      expect(described_class.health_label(0.7)).to eq(:good)
+    end
+
+    it 'returns :fair for 0.4-0.6' do
+      expect(described_class.health_label(0.5)).to eq(:fair)
+    end
+
+    it 'returns :degraded for 0.2-0.4' do
+      expect(described_class.health_label(0.3)).to eq(:degraded)
+    end
+
+    it 'returns :critical for < 0.2' do
+      expect(described_class.health_label(0.1)).to eq(:critical)
+    end
+
+    it 'returns :unknown for nil' do
+      expect(described_class.health_label(nil)).to eq(:unknown)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/helpers/snapshot_store_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Helpers::SnapshotStore do
+  subject(:store) { described_class.new }
+
+  let(:model) do
+    {
+      identity:     { framework: 'LegionIO' },
+      architecture: { loaded: %i[Tick Memory], loaded_count: 2, total_extensions: 5, unloaded: %i[Emotion Prediction Cortex] },
+      capabilities: {},
+      subsystems:   {},
+      cognitive:    { health: 0.85, mode: :full_active },
+      assembled_at: Time.now.utc
+    }
+  end
+
+  describe '#store' do
+    it 'adds a model snapshot' do
+      store.store(model)
+      expect(store.size).to eq(1)
+    end
+
+    it 'caps at MAX_SNAPSHOTS' do
+      55.times { |i| store.store(model.merge(assembled_at: Time.now.utc + i)) }
+      expect(store.size).to eq(50)
+    end
+  end
+
+  describe '#latest' do
+    it 'returns nil when empty' do
+      expect(store.latest).to be_nil
+    end
+
+    it 'returns the most recent snapshot' do
+      store.store(model)
+      expect(store.latest[:identity][:framework]).to eq('LegionIO')
+    end
+  end
+
+  describe '#stale?' do
+    it 'returns true when empty' do
+      expect(store.stale?).to be true
+    end
+
+    it 'returns false for fresh snapshot' do
+      store.store(model)
+      expect(store.stale?).to be false
+    end
+
+    it 'returns true for old snapshot' do
+      old = model.merge(assembled_at: Time.now.utc - 60)
+      store.store(old)
+      expect(store.stale?).to be true
+    end
+  end
+
+  describe '#history' do
+    it 'returns limited history' do
+      5.times { |i| store.store(model.merge(assembled_at: Time.now.utc + i)) }
+      expect(store.history(limit: 3).size).to eq(3)
+    end
+  end
+
+  describe '#architecture_changes' do
+    it 'returns empty array with fewer than 2 snapshots' do
+      store.store(model)
+      expect(store.architecture_changes).to eq([])
+    end
+
+    it 'detects added extensions' do
+      store.store(model)
+      updated = model.merge(
+        architecture: { loaded: %i[Tick Memory Emotion], loaded_count: 3, total_extensions: 5, unloaded: %i[Prediction Cortex] },
+        assembled_at: Time.now.utc + 1
+      )
+      store.store(updated)
+
+      changes = store.architecture_changes
+      expect(changes.size).to eq(1)
+      expect(changes.first[:added]).to eq([:Emotion])
+      expect(changes.first[:removed]).to eq([])
+    end
+
+    it 'detects removed extensions' do
+      store.store(model)
+      updated = model.merge(
+        architecture: { loaded: [:Tick], loaded_count: 1, total_extensions: 5, unloaded: %i[Memory Emotion Prediction Cortex] },
+        assembled_at: Time.now.utc + 1
+      )
+      store.store(updated)
+
+      changes = store.architecture_changes
+      expect(changes.first[:removed]).to eq([:Memory])
+    end
+
+    it 'skips snapshots with no changes' do
+      3.times { |i| store.store(model.merge(assembled_at: Time.now.utc + i)) }
+      expect(store.architecture_changes).to eq([])
+    end
+  end
+
+  describe '#health_trend' do
+    it 'extracts health scores from snapshots' do
+      3.times do |i|
+        store.store(model.merge(
+                      cognitive:    { health: 0.8 + (i * 0.05) },
+                      assembled_at: Time.now.utc + i
+                    ))
+      end
+      trend = store.health_trend(limit: 3)
+      expect(trend.size).to eq(3)
+      expect(trend.last[:health]).to eq(0.9)
+    end
+
+    it 'skips snapshots without health' do
+      store.store(model.merge(cognitive: { status: :no_tick_data }, assembled_at: Time.now.utc))
+      expect(store.health_trend).to eq([])
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all snapshots' do
+      store.store(model)
+      store.clear
+      expect(store.size).to eq(0)
+    end
+  end
+end