lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/architecture/runners/cognitive_architecture_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Architecture::Runners::CognitiveArchitecture do
+  subject(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#register_architecture_subsystem' do
+    it 'returns registered status and subsystem hash' do
+      result = runner.register_architecture_subsystem(name: :perception_hub, subsystem_type: :perception)
+      expect(result[:status]).to eq(:registered)
+      expect(result[:subsystem][:name]).to eq(:perception_hub)
+    end
+
+    it 'returns error status for duplicate subsystem' do
+      runner.register_architecture_subsystem(name: :dup_sub, subsystem_type: :cognition)
+      result = runner.register_architecture_subsystem(name: :dup_sub, subsystem_type: :memory)
+      expect(result[:status]).to eq(:error)
+      expect(result[:message]).to include('already registered')
+    end
+  end
+
+  describe '#create_architecture_connection' do
+    before do
+      runner.register_architecture_subsystem(name: :src, subsystem_type: :cognition)
+      runner.register_architecture_subsystem(name: :tgt, subsystem_type: :memory)
+    end
+
+    it 'returns created status and connection hash' do
+      result = runner.create_architecture_connection(source_name: :src, target_name: :tgt)
+      expect(result[:status]).to eq(:created)
+      expect(result[:connection][:connection_type]).to eq(:informational)
+    end
+
+    it 'accepts custom connection_type and weight' do
+      result = runner.create_architecture_connection(
+        source_name: :src, target_name: :tgt, connection_type: :excitatory, weight: 0.9
+      )
+      expect(result[:connection][:connection_type]).to eq(:excitatory)
+      expect(result[:connection][:weight]).to eq(0.9)
+    end
+
+    it 'returns error for unknown subsystem' do
+      result = runner.create_architecture_connection(source_name: :ghost, target_name: :tgt)
+      expect(result[:status]).to eq(:error)
+    end
+  end
+
+  describe '#activate_architecture_subsystem' do
+    before { runner.register_architecture_subsystem(name: :act_sub, subsystem_type: :cognition) }
+
+    it 'returns activated status' do
+      result = runner.activate_architecture_subsystem(name: :act_sub)
+      expect(result[:status]).to eq(:activated)
+    end
+
+    it 'returns error for unknown subsystem' do
+      result = runner.activate_architecture_subsystem(name: :missing)
+      expect(result[:status]).to eq(:error)
+    end
+  end
+
+  describe '#degrade_architecture_subsystem' do
+    before { runner.register_architecture_subsystem(name: :deg_sub, subsystem_type: :safety) }
+
+    it 'returns degraded status' do
+      result = runner.degrade_architecture_subsystem(name: :deg_sub)
+      expect(result[:status]).to eq(:degraded)
+    end
+
+    it 'returns error for unknown subsystem' do
+      result = runner.degrade_architecture_subsystem(name: :missing)
+      expect(result[:status]).to eq(:error)
+    end
+  end
+
+  describe '#subsystem_status_report' do
+    before { runner.register_architecture_subsystem(name: :status_sub, subsystem_type: :introspection) }
+
+    it 'returns subsystem hash' do
+      result = runner.subsystem_status_report(name: :status_sub)
+      expect(result[:name]).to eq(:status_sub)
+      expect(result[:subsystem_type]).to eq(:introspection)
+    end
+
+    it 'returns error hash for unknown subsystem' do
+      result = runner.subsystem_status_report(name: :nope)
+      expect(result[:status]).to eq(:error)
+    end
+  end
+
+  describe '#bottleneck_report' do
+    it 'returns a hash with bottlenecked_count and subsystems list' do
+      result = runner.bottleneck_report
+      expect(result).to include(:bottlenecked_count, :subsystems)
+    end
+
+    it 'returns 0 bottlenecked when subsystems are healthy' do
+      runner.register_architecture_subsystem(name: :healthy_sub, subsystem_type: :cognition)
+      expect(runner.bottleneck_report[:bottlenecked_count]).to eq(0)
+    end
+  end
+
+  describe '#architecture_health_report' do
+    it 'returns health, health_label, and active_count' do
+      result = runner.architecture_health_report
+      expect(result).to include(:health, :health_label, :active_count)
+    end
+
+    it 'reports 0.0 health when no subsystems' do
+      expect(runner.architecture_health_report[:health]).to eq(0.0)
+    end
+
+    it 'reports correct health_label' do
+      runner.register_architecture_subsystem(name: :good_sub, subsystem_type: :cognition, health: 0.9)
+      result = runner.architecture_health_report
+      expect(result[:health_label]).to eq(:excellent)
+    end
+  end
+
+  describe '#architecture_graph_report' do
+    it 'returns nodes and edges' do
+      runner.register_architecture_subsystem(name: :graph_sub, subsystem_type: :coordination)
+      result = runner.architecture_graph_report
+      expect(result).to include(:nodes, :edges)
+      expect(result[:nodes].size).to eq(1)
+    end
+  end
+
+  describe '#downstream_subsystems' do
+    before do
+      runner.register_architecture_subsystem(name: :root, subsystem_type: :cognition)
+      runner.register_architecture_subsystem(name: :child, subsystem_type: :memory)
+      runner.create_architecture_connection(source_name: :root, target_name: :child)
+    end
+
+    it 'returns reachable subsystems' do
+      result = runner.downstream_subsystems(name: :root)
+      names = result[:reachable].map { |s| s[:name] }
+      expect(names).to include(:child)
+    end
+
+    it 'returns count of reachable' do
+      result = runner.downstream_subsystems(name: :root)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns error for unknown source' do
+      result = runner.downstream_subsystems(name: :ghost)
+      expect(result[:status]).to eq(:error)
+    end
+  end
+
+  describe '#update_cognitive_architecture' do
+    it 'returns updated status' do
+      result = runner.update_cognitive_architecture
+      expect(result[:status]).to eq(:updated)
+      expect(result).to include(:decayed)
+    end
+
+    it 'decays subsystems health' do
+      runner.register_architecture_subsystem(name: :decay_sub, subsystem_type: :cognition)
+      before_health = runner.subsystem_status_report(name: :decay_sub)[:health]
+      runner.update_cognitive_architecture
+      after_health = runner.subsystem_status_report(name: :decay_sub)[:health]
+      expect(after_health).to be < before_health
+    end
+  end
+
+  describe '#cognitive_architecture_stats' do
+    it 'returns summary stats' do
+      runner.register_architecture_subsystem(name: :stats_sub, subsystem_type: :coordination)
+      result = runner.cognitive_architecture_stats
+      expect(result).to include(:subsystem_count, :connection_count, :active_count,
+                                :bottlenecked_count, :architecture_health)
+      expect(result[:subsystem_count]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::DefaultModeNetwork::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::DefaultModeNetwork' do
+    expect(described_class.ancestors).to include(
+      Legion::Extensions::Agentic::Self::DefaultModeNetwork::Runners::DefaultModeNetwork
+    )
+  end
+
+  it 'responds to all runner methods' do
+    %i[
+      register_external_stimulus
+      generate_idle_thought
+      trigger_self_reflection
+      trigger_social_replay
+      trigger_spontaneous_plan
+      trigger_wandering
+      salient_thoughts
+      dmn_mode_status
+      update_dmn
+      dmn_stats
+    ].each do |method|
+      expect(client).to respond_to(method)
+    end
+  end
+
+  it 'accepts a custom dmn_engine' do
+    engine = Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::DmnEngine.new
+    c      = described_class.new(dmn_engine: engine)
+    expect(c).to respond_to(:dmn_stats)
+  end
+
+  describe 'full DMN lifecycle scenario' do
+    it 'goes from active through idle and generates thoughts' do
+      # Start active — register stimulus
+      stimulus_result = client.register_external_stimulus(source: :test_harness)
+      expect(stimulus_result[:current_mode]).to eq(:active)
+
+      # Explicitly trigger various thought types
+      self_thought    = client.trigger_self_reflection
+      social_thought  = client.trigger_social_replay(interaction: :pair_programming)
+      plan_thought    = client.trigger_spontaneous_plan(goal: :optimize_query)
+      wander_thought  = client.trigger_wandering(seed: :pattern)
+
+      expect(self_thought[:thought][:thought_type]).to eq(:self_referential)
+      expect(social_thought[:thought][:thought_type]).to eq(:social_replay)
+      expect(plan_thought[:thought][:thought_type]).to eq(:spontaneous_plan)
+      expect(wander_thought[:thought][:thought_type]).to eq(:wandering)
+
+      # Check salient thoughts includes our injected thoughts
+      salient = client.salient_thoughts(count: 10)
+      expect(salient[:count]).to eq(4)
+
+      # Run several update ticks — thoughts decay
+      5.times { client.update_dmn }
+
+      # Stats should still be coherent
+      stats = client.dmn_stats
+      expect(stats[:stats][:thought_count]).to be_a(Integer)
+
+      # Mode status
+      status = client.dmn_mode_status
+      expect(status[:success]).to be true
+      expect(status[:idle_duration]).to be >= 0
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants do
+  subject(:mod) { Class.new { include Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants } }
+
+  describe 'idle thresholds' do
+    it 'IDLE_THRESHOLD is 30' do
+      expect(described_module::IDLE_THRESHOLD).to eq(30)
+    end
+
+    it 'DEEP_IDLE_THRESHOLD is 300' do
+      expect(described_module::DEEP_IDLE_THRESHOLD).to eq(300)
+    end
+  end
+
+  describe 'thought limits' do
+    it 'MAX_WANDERING_THOUGHTS is 100' do
+      expect(described_module::MAX_WANDERING_THOUGHTS).to eq(100)
+    end
+
+    it 'MAX_THOUGHT_HISTORY is 200' do
+      expect(described_module::MAX_THOUGHT_HISTORY).to eq(200)
+    end
+
+    it 'MAX_ASSOCIATION_CHAIN is 5' do
+      expect(described_module::MAX_ASSOCIATION_CHAIN).to eq(5)
+    end
+  end
+
+  describe 'salience parameters' do
+    it 'THOUGHT_SALIENCE_FLOOR is positive' do
+      expect(described_module::THOUGHT_SALIENCE_FLOOR).to be > 0
+    end
+
+    it 'DEFAULT_SALIENCE is between floor and 1' do
+      expect(described_module::DEFAULT_SALIENCE).to be_between(
+        described_module::THOUGHT_SALIENCE_FLOOR, 1.0
+      )
+    end
+  end
+
+  describe 'ACTIVITY_LABELS' do
+    it 'maps all four modes' do
+      labels = described_module::ACTIVITY_LABELS
+      expect(labels[:active]).to eq(:task_focused)
+      expect(labels[:transitioning]).to eq(:shifting)
+      expect(labels[:idle]).to eq(:daydreaming)
+      expect(labels[:deep_idle]).to eq(:deep_reflection)
+    end
+
+    it 'is frozen' do
+      expect(described_module::ACTIVITY_LABELS).to be_frozen
+    end
+  end
+
+  describe 'SALIENCE_LABELS' do
+    it 'maps ranges to quality labels' do
+      labels = described_module::SALIENCE_LABELS
+      expect(labels.values).to include(:breakthrough, :significant, :notable, :passing, :fleeting)
+    end
+
+    it 'covers 0.9 as breakthrough' do
+      result = described_module::SALIENCE_LABELS.each { |range, lbl| break lbl if range.cover?(0.9) }
+      expect(result).to eq(:breakthrough)
+    end
+
+    it 'covers 0.1 as fleeting' do
+      result = described_module::SALIENCE_LABELS.each { |range, lbl| break lbl if range.cover?(0.1) }
+      expect(result).to eq(:fleeting)
+    end
+  end
+
+  def described_module
+    Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants
+  end
+end

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::DmnEngine do
+  subject(:engine) { described_class.new }
+
+  let(:const) { Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts in :active mode' do
+      expect(engine.mode).to eq(:active)
+    end
+
+    it 'has an empty thought list' do
+      expect(engine.thoughts).to be_empty
+    end
+
+    it 'has an empty thought history' do
+      expect(engine.thought_history).to be_empty
+    end
+
+    it 'records last_stimulus_at as recent Time' do
+      expect(engine.last_stimulus_at).to be_a(Time)
+      expect(Time.now.utc - engine.last_stimulus_at).to be < 1
+    end
+  end
+
+  describe '#register_stimulus' do
+    it 'resets idle timer and returns mode info' do
+      result = engine.register_stimulus(source: :api_call)
+      expect(result[:current_mode]).to eq(:active)
+      expect(result[:source]).to eq(:api_call)
+      expect(result).to have_key(:previous_mode)
+    end
+
+    it 'switches mode back to active' do
+      allow(engine).to receive(:idle_duration).and_return(60.0)
+      engine.tick_mode
+      engine.register_stimulus
+      expect(engine.mode).to eq(:active)
+    end
+
+    it 'updates last_stimulus_at' do
+      before = engine.last_stimulus_at
+      sleep(0.01)
+      engine.register_stimulus
+      expect(engine.last_stimulus_at).to be > before
+    end
+  end
+
+  describe '#tick_mode' do
+    it 'remains active when recently stimulated' do
+      result = engine.tick_mode
+      # idle_duration is near 0, mode stays active or becomes transitioning
+      expect(%i[active transitioning]).to include(result[:current_mode])
+    end
+
+    it 'transitions to :idle after IDLE_THRESHOLD seconds' do
+      allow(engine).to receive(:idle_duration).and_return(const::IDLE_THRESHOLD.to_f + 1)
+      result = engine.tick_mode
+      expect(result[:current_mode]).to eq(:idle)
+    end
+
+    it 'transitions to :deep_idle after DEEP_IDLE_THRESHOLD seconds' do
+      allow(engine).to receive(:idle_duration).and_return(const::DEEP_IDLE_THRESHOLD.to_f + 1)
+      result = engine.tick_mode
+      expect(result[:current_mode]).to eq(:deep_idle)
+    end
+
+    it 'returns previous and current mode' do
+      result = engine.tick_mode
+      expect(result).to have_key(:previous_mode)
+      expect(result).to have_key(:current_mode)
+    end
+
+    it 'returns idle_duration in result' do
+      result = engine.tick_mode
+      expect(result[:idle_duration]).to be_a(Float)
+    end
+  end
+
+  describe '#idle_duration' do
+    it 'returns elapsed seconds since last stimulus' do
+      expect(engine.idle_duration).to be >= 0
+      expect(engine.idle_duration).to be < 5
+    end
+  end
+
+  describe '#generate_thought' do
+    it 'returns a WanderingThought' do
+      thought = engine.generate_thought
+      expect(thought).to be_a(Legion::Extensions::Agentic::Self::DefaultModeNetwork::Helpers::WanderingThought)
+    end
+
+    it 'stores the generated thought' do
+      engine.generate_thought
+      expect(engine.thought_count).to eq(1)
+    end
+
+    it 'increments thought count each call' do
+      3.times { engine.generate_thought }
+      expect(engine.thought_count).to eq(3)
+    end
+
+    it 'generates valid thought types' do
+      valid_types = %i[self_referential social_replay spontaneous_plan wandering]
+      10.times do
+        t = engine.generate_thought
+        expect(valid_types).to include(t.thought_type)
+      end
+    end
+  end
+
+  describe '#self_reflect' do
+    it 'creates a self_referential thought' do
+      thought = engine.self_reflect
+      expect(thought.thought_type).to eq(:self_referential)
+    end
+
+    it 'sets domain to :self' do
+      expect(engine.self_reflect.domain).to eq(:self)
+    end
+
+    it 'builds a non-empty association chain' do
+      expect(engine.self_reflect.association_chain).not_to be_empty
+    end
+
+    it 'accepts a custom topic' do
+      thought = engine.self_reflect(topic: :values)
+      expect(thought.seed).to eq(:values)
+    end
+
+    it 'has positive salience' do
+      expect(engine.self_reflect.salience).to be > 0
+    end
+  end
+
+  describe '#social_replay' do
+    it 'creates a social_replay thought' do
+      thought = engine.social_replay(interaction: :recent_chat)
+      expect(thought.thought_type).to eq(:social_replay)
+    end
+
+    it 'sets domain to :social' do
+      expect(engine.social_replay.domain).to eq(:social)
+    end
+
+    it 'uses provided interaction as seed' do
+      thought = engine.social_replay(interaction: :team_standup)
+      expect(thought.seed).to eq(:team_standup)
+    end
+
+    it 'uses a default seed when interaction is nil' do
+      thought = engine.social_replay
+      expect(thought.seed).not_to be_nil
+    end
+  end
+
+  describe '#plan_spontaneously' do
+    it 'creates a spontaneous_plan thought' do
+      thought = engine.plan_spontaneously(goal: :improve_latency)
+      expect(thought.thought_type).to eq(:spontaneous_plan)
+    end
+
+    it 'sets domain to :planning' do
+      expect(engine.plan_spontaneously.domain).to eq(:planning)
+    end
+
+    it 'uses provided goal as seed' do
+      thought = engine.plan_spontaneously(goal: :reduce_errors)
+      expect(thought.seed).to eq(:reduce_errors)
+    end
+
+    it 'generates higher salience than wandering (on average)' do
+      plans   = 20.times.map { engine.plan_spontaneously }
+      wanders = 20.times.map { engine.wander }
+      expect(plans.sum(&:salience) / plans.size).to be > wanders.sum(&:salience) / wanders.size
+    end
+  end
+
+  describe '#wander' do
+    it 'creates a wandering thought' do
+      thought = engine.wander(seed: :curiosity)
+      expect(thought.thought_type).to eq(:wandering)
+    end
+
+    it 'sets domain to :associative' do
+      expect(engine.wander.domain).to eq(:associative)
+    end
+
+    it 'uses provided seed' do
+      thought = engine.wander(seed: :efficiency)
+      expect(thought.seed).to eq(:efficiency)
+    end
+
+    it 'builds an association chain with the seed as first element' do
+      thought = engine.wander(seed: :pattern)
+      expect(thought.association_chain.first).to eq(:pattern)
+    end
+
+    it 'chain does not exceed MAX_ASSOCIATION_CHAIN' do
+      thought = engine.wander(seed: :root)
+      expect(thought.association_chain.size).to be <= const::MAX_ASSOCIATION_CHAIN + 1
+    end
+  end
+
+  describe '#salient_thoughts' do
+    before do
+      engine.wander(seed: :a).tap { |t| t.salience = 0.8 }.tap { |t| engine.send(:store_thought, t) }
+      engine.wander(seed: :b).tap { |t| t.salience = 0.3 }.tap { |t| engine.send(:store_thought, t) }
+      engine.wander(seed: :c).tap { |t| t.salience = 0.9 }.tap { |t| engine.send(:store_thought, t) }
+    end
+
+    it 'returns thoughts sorted by descending salience' do
+      thoughts = engine.salient_thoughts(count: 3)
+      saliences = thoughts.map(&:salience)
+      expect(saliences).to eq(saliences.sort.reverse)
+    end
+
+    it 'limits results by count' do
+      expect(engine.salient_thoughts(count: 2).size).to eq(2)
+    end
+
+    it 'returns top thought with highest salience' do
+      expect(engine.salient_thoughts(count: 1).first.seed).to eq(:c)
+    end
+  end
+
+  describe '#thoughts_of_type' do
+    before do
+      engine.self_reflect.tap { |t| engine.send(:store_thought, t) }
+      engine.social_replay.tap { |t| engine.send(:store_thought, t) }
+      engine.wander.tap { |t| engine.send(:store_thought, t) }
+    end
+
+    it 'filters by thought_type' do
+      results = engine.thoughts_of_type(type: :self_referential)
+      expect(results.all? { |t| t.thought_type == :self_referential }).to be true
+    end
+
+    it 'returns empty array for unknown type' do
+      expect(engine.thoughts_of_type(type: :unknown_type)).to be_empty
+    end
+
+    it 'accepts string type and coerces to symbol' do
+      results = engine.thoughts_of_type(type: 'wandering')
+      expect(results).not_to be_empty
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all stored thoughts' do
+      3.times { engine.generate_thought }
+      before_saliences = engine.thoughts.map(&:salience).dup
+      engine.decay_all
+      # All thoughts should have lower or equal salience
+      engine.thoughts.zip(before_saliences).each do |t, b|
+        expect(t.salience).to be <= b
+      end
+    end
+
+    it 'prunes thoughts that fade below floor' do
+      thought = engine.wander(seed: :test)
+      thought.salience = const::THOUGHT_SALIENCE_FLOOR + 0.001
+      engine.send(:store_thought, thought)
+      engine.decay_all
+      expect(engine.thoughts).not_to include(thought)
+    end
+
+    it 'archives faded thoughts in thought_history' do
+      thought = engine.wander(seed: :archive_me)
+      thought.salience = const::THOUGHT_SALIENCE_FLOOR + 0.001
+      engine.send(:store_thought, thought)
+      engine.decay_all
+      ids = engine.thought_history.map { |h| h[:id] }
+      expect(ids).to include(thought.id)
+    end
+
+    it 'returns the count of faded thoughts removed' do
+      thought = engine.wander(seed: :doomed)
+      thought.salience = const::THOUGHT_SALIENCE_FLOOR + 0.001
+      engine.send(:store_thought, thought)
+      removed = engine.decay_all
+      expect(removed).to eq(1)
+    end
+  end
+
+  describe '#thought_count' do
+    it 'returns 0 initially' do
+      expect(engine.thought_count).to eq(0)
+    end
+
+    it 'increments with each stored thought' do
+      5.times { engine.generate_thought }
+      expect(engine.thought_count).to eq(5)
+    end
+  end
+
+  describe 'thought pruning' do
+    it 'does not exceed MAX_WANDERING_THOUGHTS' do
+      (const::MAX_WANDERING_THOUGHTS + 10).times { engine.generate_thought }
+      expect(engine.thought_count).to be <= const::MAX_WANDERING_THOUGHTS
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = engine.to_h
+      expect(h).to include(:mode, :mode_label, :idle_duration, :thought_count, :history_count, :last_stimulus_at)
+    end
+
+    it 'includes the mode label from ACTIVITY_LABELS' do
+      h = engine.to_h
+      expect(const::ACTIVITY_LABELS.values).to include(h[:mode_label])
+    end
+
+    it 'reflects current thought count' do
+      3.times { engine.generate_thought }
+      expect(engine.to_h[:thought_count]).to eq(3)
+    end
+  end
+end