lex-mind-growth 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87d35372e2ef409b603807723d816df60439d40bc8f4289d48799d31b731d232
-  data.tar.gz: fd49c0c8bb06f49374cbbb3afb497f45ee58193e71ff66b1ef1c622b94bbeaa6
+  metadata.gz: 647d99aa35555ba0ff36f584ad78d0c2104a9c09e83d72fbee7b897d097c7380
+  data.tar.gz: b7803d7ea950fb03154b695b5631f8a2e523adfad0df4963f8a22bf98e952f67
 SHA512:
-  metadata.gz: d3c07088c0173a6e5669af58bf3fbd315f2ef9098fa9e3f3f65228815159e6a061860c05aba14b75a0f0dcd9f01aea50f5a89ec9455a5796484037c6e1571328
-  data.tar.gz: 98b9b07557efbb5a3546a4018300ab984a0bfecc24ae93ab2534c35c90b991877d5564863460a75137525b262c996b7536ca14c6bbd20f77671225a8501ba402
+  metadata.gz: d2874a80b17163ad6b0d9f92f6ce221b22e4bbecf317c779315279f5a7c4426154f342892c7765cf0d7e29f55941e9561d28a1d2d92cee5d7298151d5d47fc4c
+  data.tar.gz: 01c677bf65ca0c841f5740a7d1f89a41d160e1bb8bcd39f43ad247b4676a11d2c55bb67d4eaad7ed32c73e8838e1e1064839d0e4e461897b5a8af4c8c36945ca

data/lib/legion/extensions/mind_growth/client.rb

@@ -68,6 +68,22 @@ module Legion
         def generate_dream_proposals(**) = Runners::DreamIdeation.generate_dream_proposals(**)
         def dream_agenda_items(**)       = Runners::DreamIdeation.dream_agenda_items(**)
         def enrich_from_dream_context(**) = Runners::DreamIdeation.enrich_from_dream_context(**)
+
+        # Evolver delegation
+        def select_for_improvement(**) = Runners::Evolver.select_for_improvement(**)
+        def propose_improvement(**)    = Runners::Evolver.propose_improvement(**)
+        def replace_extension(**)      = Runners::Evolver.replace_extension(**)
+        def merge_extensions(**)       = Runners::Evolver.merge_extensions(**)
+        def evolution_summary(**)      = Runners::Evolver.evolution_summary(**)
+
+        # Dashboard delegation
+        def extension_timeline(**)     = Runners::Dashboard.extension_timeline(**)
+        def category_distribution(**) = Runners::Dashboard.category_distribution(**)
+        def build_metrics(**)          = Runners::Dashboard.build_metrics(**)
+        def top_extensions(**)         = Runners::Dashboard.top_extensions(**)
+        def bottom_extensions(**)      = Runners::Dashboard.bottom_extensions(**)
+        def recent_proposals(**)       = Runners::Dashboard.recent_proposals(**)
+        def full_dashboard(**)         = Runners::Dashboard.full_dashboard(**)
       end
     end
   end

data/lib/legion/extensions/mind_growth/runners/dashboard.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Dashboard
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          module_function
+
+          def extension_timeline(extensions:, days: 30, **)
+            count = Array(extensions).size
+            today = Time.now.utc.strftime('%Y-%m-%d')
+            series = [{ date: today, count: count }]
+
+            { success: true, series: series, range_days: days }
+          end
+
+          def category_distribution(extensions:, **)
+            exts = Array(extensions)
+            dist = Helpers::Constants::CATEGORIES.to_h { |c| [c, 0] }
+
+            exts.each do |ext|
+              cat = (ext[:category] || :cognition).to_sym
+              dist[cat] = (dist[cat] || 0) + 1
+            end
+
+            { success: true, distribution: dist, total: exts.size }
+          end
+
+          def build_metrics(**)
+            stats = Runners::Proposer.proposal_stats[:stats]
+            by_status = stats[:by_status] || {}
+            total     = stats[:total] || 0
+
+            approved = by_status[:approved].to_i
+            rejected = by_status[:rejected].to_i
+            built    = (by_status[:passing].to_i + by_status[:wired].to_i + by_status[:active].to_i)
+            failed   = by_status[:build_failed].to_i
+
+            attempted    = built + failed
+            success_rate = attempted.positive? ? (built.to_f / attempted).round(3) : 0.0
+
+            evaluated = approved + rejected
+            approval_rate = evaluated.positive? ? (approved.to_f / evaluated).round(3) : 0.0
+
+            { success:         true,
+              total_proposals: total,
+              approved:        approved,
+              rejected:        rejected,
+              built:           built,
+              failed:          failed,
+              success_rate:    success_rate,
+              approval_rate:   approval_rate }
+          end
+
+          def top_extensions(extensions:, limit: 10, **)
+            exts = Array(extensions)
+            ranked = Helpers::FitnessEvaluator.rank(exts)
+            top = ranked.first(limit).map do |e|
+              { name:             e[:name] || e[:extension_name],
+                invocation_count: e[:invocation_count] || 0,
+                fitness:          e[:fitness] }
+            end
+
+            { success: true, top: top, limit: limit }
+          end
+
+          def bottom_extensions(extensions:, limit: 10, **)
+            exts = Array(extensions)
+            ranked = Helpers::FitnessEvaluator.rank(exts)
+            bottom = ranked.last(limit).reverse.map do |e|
+              { name:             e[:name] || e[:extension_name],
+                invocation_count: e[:invocation_count] || 0,
+                fitness:          e[:fitness] }
+            end
+
+            { success: true, bottom: bottom, limit: limit }
+          end
+
+          def recent_proposals(limit: 10, **)
+            result = Runners::Proposer.list_proposals(limit: limit)
+            { success: true, proposals: result[:proposals], count: result[:count] }
+          end
+
+          def full_dashboard(extensions:, **)
+            exts = Array(extensions)
+
+            { success:               true,
+              category_distribution: category_distribution(extensions: exts)[:distribution],
+              build_metrics:         build_metrics,
+              top_extensions:        top_extensions(extensions: exts)[:top],
+              bottom_extensions:     bottom_extensions(extensions: exts)[:bottom],
+              recent_proposals:      recent_proposals[:proposals],
+              health_summary:        Runners::Monitor.health_summary(extensions: exts),
+              timestamp:             Time.now.utc.iso8601 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mind_growth/runners/evolver.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Evolver
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          BOTTOM_PERCENTILE = 0.05
+          SPECIATION_DRIFT_THRESHOLD = 0.5
+
+          def select_for_improvement(extensions:, count: 3, **)
+            exts = Array(extensions)
+            return { success: true, candidates: [], count: 0, total_evaluated: 0 } if exts.empty?
+
+            eligible = exts.reject { |e| %i[building testing].include?((e[:status] || :active).to_sym) }
+            ranked   = Helpers::FitnessEvaluator.rank(eligible)
+            bottom_n = ranked.last(count)
+
+            { success: true, candidates: bottom_n, count: bottom_n.size, total_evaluated: eligible.size }
+          end
+
+          def propose_improvement(extension:, **)
+            name     = extension[:name] || extension[:extension_name]
+            fitness  = Helpers::FitnessEvaluator.fitness(extension)
+
+            weaknesses = identify_weaknesses(extension)
+            suggestions = generate_suggestions(weaknesses)
+
+            if defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+              suggestions = llm_suggestions(name, fitness, weaknesses) || suggestions
+            end
+
+            { success: true, extension_name: name, fitness: fitness,
+              weaknesses: weaknesses, suggestions: suggestions }
+          end
+
+          def replace_extension(old_name:, new_proposal_id:, **)
+            status_store[old_name] = :pruned
+            replacement_map[old_name] = new_proposal_id
+
+            { success: true, replaced: old_name, replacement_proposal_id: new_proposal_id }
+          end
+
+          def merge_extensions(extension_a:, extension_b:, merged_name: nil, **)
+            name_a = extension_a[:name] || extension_a[:extension_name]
+            name_b = extension_b[:name] || extension_b[:extension_name]
+            cat_a  = (extension_a[:category] || :cognition).to_sym
+            merged = merged_name || "lex-merged-#{name_a.to_s.sub(/\Alex-/, '')}-#{name_b.to_s.sub(/\Alex-/, '')}"
+            desc   = "Merged extension combining capabilities of #{name_a} and #{name_b}"
+
+            proposal = Runners::Proposer.propose_concept(
+              name:        merged,
+              category:    cat_a,
+              description: desc,
+              enrich:      false
+            )
+
+            { success: true, merged_proposal: proposal, sources: [name_a, name_b] }
+          end
+
+          def evolution_summary(extensions:, **)
+            exts = Array(extensions)
+
+            improvement_candidates = select_for_improvement(extensions: exts, count: 5)[:candidates]
+
+            prune_candidates = Helpers::FitnessEvaluator.prune_candidates(exts).map do |e|
+              e[:name] || e[:extension_name]
+            end
+
+            speciation_candidates = exts.filter_map do |e|
+              e[:name] || e[:extension_name] if (e[:drift_score] || 0.0) >= SPECIATION_DRIFT_THRESHOLD
+            end
+
+            fitnesses = exts.map { |e| Helpers::FitnessEvaluator.fitness(e) }
+
+            distribution = if fitnesses.empty?
+                             { min: 0.0, max: 0.0, mean: 0.0, median: 0.0 }
+                           else
+                             sorted = fitnesses.sort
+                             mid    = sorted.size / 2
+                             median = sorted.size.odd? ? sorted[mid] : ((sorted[mid - 1] + sorted[mid]) / 2.0).round(3)
+                             { min:    sorted.first.round(3),
+                               max:    sorted.last.round(3),
+                               mean:   (fitnesses.sum / fitnesses.size.to_f).round(3),
+                               median: median }
+                           end
+
+            { success:                true,
+              improvement_candidates: improvement_candidates,
+              prune_candidates:       prune_candidates,
+              speciation_candidates:  speciation_candidates,
+              fitness_distribution:   distribution }
+          end
+
+          SUGGESTION_MAP = {
+            low_invocations: 'improve wiring or broaden phase coverage',
+            high_error_rate: 'add error handling and input validation',
+            high_latency:    'optimize hot paths or add caching',
+            low_impact:      'enrich output or add downstream connections'
+          }.freeze
+
+          private
+
+          def identify_weaknesses(extension)
+            weaknesses = []
+            count = extension[:invocation_count] || 0
+            error = extension[:error_rate]       || 0.0
+            lat   = extension[:avg_latency_ms]   || 0
+            imp   = extension[:impact_score]     || 0.5
+
+            weaknesses << :low_invocations if count < Helpers::Constants::DECAY_INVOCATION_THRESHOLD
+            weaknesses << :high_error_rate if error > 0.2
+            weaknesses << :high_latency    if lat > 1000
+            weaknesses << :low_impact      if imp < 0.3
+            weaknesses
+          end
+
+          def generate_suggestions(weaknesses)
+            suggestions = weaknesses.filter_map { |w| SUGGESTION_MAP[w] }
+            suggestions.empty? ? ['review overall design for incremental improvements'] : suggestions
+          end
+
+          def llm_suggestions(name, fitness, weaknesses)
+            response = Legion::LLM.chat(
+              caller: { extension: 'lex-mind-growth', operation: 'evolver', phase: 'suggest' }
+            ).ask(improvement_prompt(name, fitness, weaknesses))
+            parse_llm_suggestions(response.content)
+          rescue StandardError
+            nil
+          end
+
+          def improvement_prompt(name, fitness, weaknesses)
+            <<~PROMPT
+              The LegionIO cognitive extension "#{name}" has a fitness score of #{fitness.round(3)}.
+              Identified weaknesses: #{weaknesses.join(', ')}.
+
+              Provide 2-4 concrete improvement suggestions as a JSON array of strings.
+              Example: ["suggestion one", "suggestion two"]
+              Return ONLY the JSON array, no markdown fencing.
+            PROMPT
+          end
+
+          def parse_llm_suggestions(content)
+            cleaned = content.gsub(/```(?:json)?\s*\n?/, '').strip
+            data = ::JSON.parse(cleaned)
+            return nil unless data.is_a?(Array)
+
+            data.map(&:to_s).reject(&:empty?)
+          rescue ::JSON::ParserError
+            nil
+          end
+
+          def status_store
+            @status_store ||= {}
+          end
+
+          def replacement_map
+            @replacement_map ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mind_growth/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.1.8'
+      VERSION = '0.1.9'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -24,6 +24,8 @@ require 'legion/extensions/mind_growth/helpers/composition_map'
 require 'legion/extensions/mind_growth/runners/monitor'
 require 'legion/extensions/mind_growth/runners/composer'
 require 'legion/extensions/mind_growth/runners/dream_ideation'
+require 'legion/extensions/mind_growth/runners/evolver'
+require 'legion/extensions/mind_growth/runners/dashboard'
 require 'legion/extensions/mind_growth/client'
 
 module Legion

data/spec/legion/extensions/mind_growth/runners/dashboard_spec.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::Dashboard do
+  subject(:dashboard) { described_class }
+
+  before { Legion::Extensions::MindGrowth::Runners::Proposer.instance_variable_set(:@proposal_store, nil) }
+
+  let(:cognition_ext) do
+    { name: 'lex-cognition', category: :cognition, invocation_count: 500,
+      impact_score: 0.8, health_score: 0.9, error_rate: 0.0, avg_latency_ms: 100 }
+  end
+
+  let(:memory_ext) do
+    { name: 'lex-memory', category: :memory, invocation_count: 200,
+      impact_score: 0.6, health_score: 0.7, error_rate: 0.05, avg_latency_ms: 150 }
+  end
+
+  let(:low_ext) do
+    { name: 'lex-low', category: :perception, invocation_count: 1,
+      impact_score: 0.1, health_score: 0.1, error_rate: 0.8, avg_latency_ms: 3000 }
+  end
+
+  let(:all_exts) { [cognition_ext, memory_ext, low_ext] }
+
+  # ─── extension_timeline ────────────────────────────────────────────────────
+
+  describe '.extension_timeline' do
+    it 'returns success: true' do
+      result = dashboard.extension_timeline(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a series array' do
+      result = dashboard.extension_timeline(extensions: all_exts)
+      expect(result[:series]).to be_an(Array)
+    end
+
+    it 'returns at least one series point' do
+      result = dashboard.extension_timeline(extensions: all_exts)
+      expect(result[:series].size).to be >= 1
+    end
+
+    it 'returns range_days matching requested days' do
+      result = dashboard.extension_timeline(extensions: all_exts, days: 7)
+      expect(result[:range_days]).to eq(7)
+    end
+
+    it 'series points include date and count keys' do
+      result = dashboard.extension_timeline(extensions: all_exts)
+      result[:series].each do |point|
+        expect(point).to have_key(:date)
+        expect(point).to have_key(:count)
+      end
+    end
+
+    it 'reflects current extension count in the series' do
+      result = dashboard.extension_timeline(extensions: all_exts)
+      expect(result[:series].last[:count]).to eq(3)
+    end
+
+    it 'returns count 0 for empty extensions' do
+      result = dashboard.extension_timeline(extensions: [])
+      expect(result[:series].last[:count]).to eq(0)
+    end
+  end
+
+  # ─── category_distribution ─────────────────────────────────────────────────
+
+  describe '.category_distribution' do
+    it 'returns success: true' do
+      result = dashboard.category_distribution(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a distribution hash' do
+      result = dashboard.category_distribution(extensions: all_exts)
+      expect(result[:distribution]).to be_a(Hash)
+    end
+
+    it 'returns total equal to extension count' do
+      result = dashboard.category_distribution(extensions: all_exts)
+      expect(result[:total]).to eq(3)
+    end
+
+    it 'includes all CATEGORIES keys in distribution' do
+      result = dashboard.category_distribution(extensions: all_exts)
+      Legion::Extensions::MindGrowth::Helpers::Constants::CATEGORIES.each do |cat|
+        expect(result[:distribution]).to have_key(cat)
+      end
+    end
+
+    it 'counts extensions per category correctly' do
+      result = dashboard.category_distribution(extensions: all_exts)
+      expect(result[:distribution][:cognition]).to eq(1)
+      expect(result[:distribution][:memory]).to eq(1)
+      expect(result[:distribution][:perception]).to eq(1)
+    end
+
+    it 'returns zero counts for unpopulated categories' do
+      result = dashboard.category_distribution(extensions: [cognition_ext])
+      expect(result[:distribution][:memory]).to eq(0)
+    end
+
+    it 'defaults missing category to :cognition' do
+      ext    = { name: 'lex-bare' }
+      result = dashboard.category_distribution(extensions: [ext])
+      expect(result[:distribution][:cognition]).to eq(1)
+    end
+
+    it 'returns total: 0 for empty extensions' do
+      result = dashboard.category_distribution(extensions: [])
+      expect(result[:total]).to eq(0)
+    end
+  end
+
+  # ─── build_metrics ─────────────────────────────────────────────────────────
+
+  describe '.build_metrics' do
+    it 'returns success: true' do
+      result = dashboard.build_metrics
+      expect(result[:success]).to be true
+    end
+
+    it 'returns total_proposals' do
+      result = dashboard.build_metrics
+      expect(result).to have_key(:total_proposals)
+    end
+
+    it 'returns approved count' do
+      result = dashboard.build_metrics
+      expect(result).to have_key(:approved)
+    end
+
+    it 'returns rejected count' do
+      result = dashboard.build_metrics
+      expect(result).to have_key(:rejected)
+    end
+
+    it 'returns built count' do
+      result = dashboard.build_metrics
+      expect(result).to have_key(:built)
+    end
+
+    it 'returns failed count' do
+      result = dashboard.build_metrics
+      expect(result).to have_key(:failed)
+    end
+
+    it 'returns success_rate as a numeric' do
+      result = dashboard.build_metrics
+      expect(result[:success_rate]).to be_a(Numeric)
+    end
+
+    it 'returns approval_rate as a numeric' do
+      result = dashboard.build_metrics
+      expect(result[:approval_rate]).to be_a(Numeric)
+    end
+
+    it 'returns success_rate 0.0 when no builds attempted' do
+      result = dashboard.build_metrics
+      expect(result[:success_rate]).to eq(0.0)
+    end
+
+    it 'returns approval_rate 0.0 when no proposals evaluated' do
+      result = dashboard.build_metrics
+      expect(result[:approval_rate]).to eq(0.0)
+    end
+  end
+
+  # ─── top_extensions ────────────────────────────────────────────────────────
+
+  describe '.top_extensions' do
+    it 'returns success: true' do
+      result = dashboard.top_extensions(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a top array' do
+      result = dashboard.top_extensions(extensions: all_exts)
+      expect(result[:top]).to be_an(Array)
+    end
+
+    it 'returns limit in response' do
+      result = dashboard.top_extensions(extensions: all_exts, limit: 2)
+      expect(result[:limit]).to eq(2)
+    end
+
+    it 'respects the limit parameter' do
+      result = dashboard.top_extensions(extensions: all_exts, limit: 2)
+      expect(result[:top].size).to be <= 2
+    end
+
+    it 'returns highest-fitness extension first' do
+      result = dashboard.top_extensions(extensions: all_exts, limit: 1)
+      expect(result[:top].first[:name]).to eq('lex-cognition')
+    end
+
+    it 'each entry includes name, invocation_count, and fitness' do
+      result = dashboard.top_extensions(extensions: all_exts)
+      result[:top].each do |entry|
+        expect(entry).to have_key(:name)
+        expect(entry).to have_key(:invocation_count)
+        expect(entry).to have_key(:fitness)
+      end
+    end
+
+    it 'returns empty top array for empty extensions' do
+      result = dashboard.top_extensions(extensions: [])
+      expect(result[:top]).to be_empty
+    end
+  end
+
+  # ─── bottom_extensions ─────────────────────────────────────────────────────
+
+  describe '.bottom_extensions' do
+    it 'returns success: true' do
+      result = dashboard.bottom_extensions(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a bottom array' do
+      result = dashboard.bottom_extensions(extensions: all_exts)
+      expect(result[:bottom]).to be_an(Array)
+    end
+
+    it 'returns limit in response' do
+      result = dashboard.bottom_extensions(extensions: all_exts, limit: 2)
+      expect(result[:limit]).to eq(2)
+    end
+
+    it 'respects the limit parameter' do
+      result = dashboard.bottom_extensions(extensions: all_exts, limit: 2)
+      expect(result[:bottom].size).to be <= 2
+    end
+
+    it 'returns lowest-fitness extension first' do
+      result = dashboard.bottom_extensions(extensions: all_exts, limit: 1)
+      expect(result[:bottom].first[:name]).to eq('lex-low')
+    end
+
+    it 'each entry includes name, invocation_count, and fitness' do
+      result = dashboard.bottom_extensions(extensions: all_exts)
+      result[:bottom].each do |entry|
+        expect(entry).to have_key(:name)
+        expect(entry).to have_key(:invocation_count)
+        expect(entry).to have_key(:fitness)
+      end
+    end
+
+    it 'returns empty bottom array for empty extensions' do
+      result = dashboard.bottom_extensions(extensions: [])
+      expect(result[:bottom]).to be_empty
+    end
+  end
+
+  # ─── recent_proposals ──────────────────────────────────────────────────────
+
+  describe '.recent_proposals' do
+    it 'returns success: true' do
+      result = dashboard.recent_proposals
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a proposals array' do
+      result = dashboard.recent_proposals
+      expect(result[:proposals]).to be_an(Array)
+    end
+
+    it 'returns count matching proposals array size' do
+      result = dashboard.recent_proposals
+      expect(result[:count]).to eq(result[:proposals].size)
+    end
+
+    it 'delegates to Proposer.list_proposals' do
+      allow(Legion::Extensions::MindGrowth::Runners::Proposer)
+        .to receive(:list_proposals).with(limit: 5).and_call_original
+      dashboard.recent_proposals(limit: 5)
+      expect(Legion::Extensions::MindGrowth::Runners::Proposer)
+        .to have_received(:list_proposals).with(limit: 5)
+    end
+
+    it 'returns proposals when store has entries' do
+      Legion::Extensions::MindGrowth::Runners::Proposer.propose_concept(
+        name: 'lex-dash-test', category: :cognition, description: 'dashboard test', enrich: false
+      )
+      result = dashboard.recent_proposals(limit: 10)
+      expect(result[:count]).to be >= 1
+    end
+
+    it 'returns empty list when no proposals exist' do
+      result = dashboard.recent_proposals
+      expect(result[:proposals]).to be_an(Array)
+    end
+  end
+
+  # ─── full_dashboard ────────────────────────────────────────────────────────
+
+  describe '.full_dashboard' do
+    it 'returns success: true' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes category_distribution' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:category_distribution]).to be_a(Hash)
+    end
+
+    it 'includes build_metrics' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:build_metrics]).to be_a(Hash)
+    end
+
+    it 'includes top_extensions array' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:top_extensions]).to be_an(Array)
+    end
+
+    it 'includes bottom_extensions array' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:bottom_extensions]).to be_an(Array)
+    end
+
+    it 'includes recent_proposals array' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:recent_proposals]).to be_an(Array)
+    end
+
+    it 'includes health_summary hash' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:health_summary]).to be_a(Hash)
+    end
+
+    it 'includes a timestamp string' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:timestamp]).to be_a(String)
+    end
+
+    it 'health_summary reflects extension count' do
+      result = dashboard.full_dashboard(extensions: all_exts)
+      expect(result[:health_summary][:total]).to eq(3)
+    end
+
+    it 'returns empty arrays and zero counts for empty extensions' do
+      result = dashboard.full_dashboard(extensions: [])
+      expect(result[:top_extensions]).to be_empty
+      expect(result[:bottom_extensions]).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/runners/evolver_spec.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::Evolver do
+  subject(:evolver) { described_class }
+
+  before do
+    Legion::Extensions::MindGrowth::Runners::Proposer.instance_variable_set(:@proposal_store, nil)
+    evolver.instance_variable_set(:@status_store, nil)
+    evolver.instance_variable_set(:@replacement_map, nil)
+  end
+
+  let(:high_ext) do
+    { name: 'lex-high', invocation_count: 5000, impact_score: 0.9,
+      health_score: 1.0, error_rate: 0.0, avg_latency_ms: 0, status: :active }
+  end
+
+  let(:mid_ext) do
+    { name: 'lex-mid', invocation_count: 50, impact_score: 0.5,
+      health_score: 0.7, error_rate: 0.1, avg_latency_ms: 200, status: :active }
+  end
+
+  let(:low_ext) do
+    { name: 'lex-low', invocation_count: 1, impact_score: 0.1,
+      health_score: 0.1, error_rate: 0.5, avg_latency_ms: 2000, status: :active }
+  end
+
+  let(:building_ext) do
+    { name: 'lex-building', invocation_count: 0, impact_score: 0.0,
+      health_score: 0.0, error_rate: 1.0, avg_latency_ms: 5000, status: :building }
+  end
+
+  let(:testing_ext) do
+    { name: 'lex-testing', invocation_count: 0, impact_score: 0.0,
+      health_score: 0.0, error_rate: 1.0, avg_latency_ms: 5000, status: :testing }
+  end
+
+  # ─── select_for_improvement ────────────────────────────────────────────────
+
+  describe '.select_for_improvement' do
+    it 'returns success: true' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext])
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a candidates array' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext])
+      expect(result[:candidates]).to be_an(Array)
+    end
+
+    it 'returns count matching candidates array size' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext])
+      expect(result[:count]).to eq(result[:candidates].size)
+    end
+
+    it 'returns total_evaluated count' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext])
+      expect(result[:total_evaluated]).to eq(3)
+    end
+
+    it 'selects the bottom N extensions by fitness' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext], count: 1)
+      expect(result[:candidates].first[:name]).to eq('lex-low')
+    end
+
+    it 'respects the count parameter' do
+      result = evolver.select_for_improvement(extensions: [high_ext, mid_ext, low_ext], count: 2)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'skips extensions with :building status' do
+      result = evolver.select_for_improvement(extensions: [high_ext, building_ext], count: 2)
+      names = result[:candidates].map { |c| c[:name] }
+      expect(names).not_to include('lex-building')
+    end
+
+    it 'skips extensions with :testing status' do
+      result = evolver.select_for_improvement(extensions: [high_ext, testing_ext], count: 2)
+      names = result[:candidates].map { |c| c[:name] }
+      expect(names).not_to include('lex-testing')
+    end
+
+    it 'does not count skipped extensions in total_evaluated' do
+      result = evolver.select_for_improvement(extensions: [high_ext, building_ext, low_ext], count: 2)
+      expect(result[:total_evaluated]).to eq(2)
+    end
+
+    it 'returns empty candidates for empty extensions list' do
+      result = evolver.select_for_improvement(extensions: [])
+      expect(result[:candidates]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'handles count greater than total extensions' do
+      result = evolver.select_for_improvement(extensions: [high_ext], count: 10)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns all extensions when count equals list size' do
+      result = evolver.select_for_improvement(extensions: [high_ext, low_ext], count: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  # ─── propose_improvement ───────────────────────────────────────────────────
+
+  describe '.propose_improvement' do
+    it 'returns success: true' do
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the extension_name' do
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:extension_name]).to eq('lex-low')
+    end
+
+    it 'returns a numeric fitness' do
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:fitness]).to be_a(Numeric)
+    end
+
+    it 'returns a weaknesses array' do
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:weaknesses]).to be_an(Array)
+    end
+
+    it 'returns a suggestions array' do
+      begin
+        evolver.propose_improve(extension: low_ext)
+      rescue StandardError
+        nil
+      end
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:suggestions]).to be_an(Array)
+    end
+
+    it 'identifies :low_invocations weakness for zero-invocation extension' do
+      ext    = { name: 'lex-zero', invocation_count: 0, impact_score: 0.5, error_rate: 0.0, avg_latency_ms: 0 }
+      result = evolver.propose_improvement(extension: ext)
+      expect(result[:weaknesses]).to include(:low_invocations)
+    end
+
+    it 'identifies :high_error_rate weakness when error_rate > 0.2' do
+      ext    = { name: 'lex-err', invocation_count: 100, impact_score: 0.5, error_rate: 0.5, avg_latency_ms: 0 }
+      result = evolver.propose_improvement(extension: ext)
+      expect(result[:weaknesses]).to include(:high_error_rate)
+    end
+
+    it 'identifies :high_latency weakness when avg_latency_ms > 1000' do
+      ext    = { name: 'lex-slow', invocation_count: 100, impact_score: 0.5, error_rate: 0.0, avg_latency_ms: 2000 }
+      result = evolver.propose_improvement(extension: ext)
+      expect(result[:weaknesses]).to include(:high_latency)
+    end
+
+    it 'identifies :low_impact weakness when impact_score < 0.3' do
+      ext    = { name: 'lex-lowin', invocation_count: 100, impact_score: 0.1, error_rate: 0.0, avg_latency_ms: 0 }
+      result = evolver.propose_improvement(extension: ext)
+      expect(result[:weaknesses]).to include(:low_impact)
+    end
+
+    it 'returns generic suggestion when no specific weaknesses detected' do
+      result = evolver.propose_improvement(extension: high_ext)
+      expect(result[:suggestions]).not_to be_empty
+    end
+
+    if defined?(Legion::LLM)
+      it 'returns LLM-enriched suggestions when LLM is available' do
+        mock_llm_session = double('session')
+        mock_response    = double('response', content: '["fix error handling", "add caching"]')
+        allow(mock_llm_session).to receive(:ask).and_return(mock_response)
+        allow(Legion::LLM).to receive(:started?).and_return(true)
+        allow(Legion::LLM).to receive(:chat).and_return(mock_llm_session)
+
+        result = evolver.propose_improvement(extension: low_ext)
+        expect(result[:suggestions]).to include('fix error handling')
+      end
+    end
+
+    it 'falls back to heuristic suggestions when LLM is unavailable' do
+      begin
+        allow(Legion).to receive(:const_defined?).with(:LLM).and_return(false)
+      rescue StandardError
+        nil
+      end
+      result = evolver.propose_improvement(extension: low_ext)
+      expect(result[:suggestions]).to be_an(Array)
+      expect(result[:suggestions]).not_to be_empty
+    end
+  end
+
+  # ─── replace_extension ─────────────────────────────────────────────────────
+
+  describe '.replace_extension' do
+    it 'returns success: true' do
+      result = evolver.replace_extension(old_name: 'lex-old', new_proposal_id: 'abc-123')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the replaced name' do
+      result = evolver.replace_extension(old_name: 'lex-old', new_proposal_id: 'abc-123')
+      expect(result[:replaced]).to eq('lex-old')
+    end
+
+    it 'returns the replacement_proposal_id' do
+      result = evolver.replace_extension(old_name: 'lex-old', new_proposal_id: 'abc-123')
+      expect(result[:replacement_proposal_id]).to eq('abc-123')
+    end
+
+    it 'marks the old extension as :pruned in the status store' do
+      evolver.replace_extension(old_name: 'lex-prunable', new_proposal_id: 'xyz-999')
+      expect(evolver.instance_variable_get(:@status_store)['lex-prunable']).to eq(:pruned)
+    end
+
+    it 'stores the replacement mapping' do
+      evolver.replace_extension(old_name: 'lex-old2', new_proposal_id: 'new-id')
+      expect(evolver.instance_variable_get(:@replacement_map)['lex-old2']).to eq('new-id')
+    end
+  end
+
+  # ─── merge_extensions ──────────────────────────────────────────────────────
+
+  describe '.merge_extensions' do
+    let(:ext_a) { { name: 'lex-alpha', category: :cognition } }
+    let(:ext_b) { { name: 'lex-beta',  category: :memory } }
+
+    it 'returns success: true' do
+      result = evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a merged_proposal' do
+      result = evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b)
+      expect(result[:merged_proposal]).to be_a(Hash)
+    end
+
+    it 'returns sources with both extension names' do
+      result = evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b)
+      expect(result[:sources]).to contain_exactly('lex-alpha', 'lex-beta')
+    end
+
+    it 'calls Proposer.propose_concept to create the merged proposal' do
+      allow(Legion::Extensions::MindGrowth::Runners::Proposer)
+        .to receive(:propose_concept).and_call_original
+      evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b)
+      expect(Legion::Extensions::MindGrowth::Runners::Proposer)
+        .to have_received(:propose_concept)
+    end
+
+    it 'uses provided merged_name when given' do
+      result = evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b, merged_name: 'lex-custom')
+      proposal = result[:merged_proposal]
+      expect(proposal[:success]).to be true
+    end
+
+    it 'auto-generates merged name from source names when none provided' do
+      allow(Legion::Extensions::MindGrowth::Runners::Proposer)
+        .to receive(:propose_concept) do |**args|
+          expect(args[:name]).to include('alpha')
+          { success: true, proposal: { name: args[:name] } }
+        end
+      evolver.merge_extensions(extension_a: ext_a, extension_b: ext_b)
+    end
+  end
+
+  # ─── evolution_summary ─────────────────────────────────────────────────────
+
+  describe '.evolution_summary' do
+    let(:all_exts) { [high_ext, mid_ext, low_ext] }
+
+    it 'returns success: true' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns improvement_candidates array' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      expect(result[:improvement_candidates]).to be_an(Array)
+    end
+
+    it 'returns prune_candidates array' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      expect(result[:prune_candidates]).to be_an(Array)
+    end
+
+    it 'returns speciation_candidates array' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      expect(result[:speciation_candidates]).to be_an(Array)
+    end
+
+    it 'returns fitness_distribution hash with min/max/mean/median' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      dist = result[:fitness_distribution]
+      expect(dist).to have_key(:min)
+      expect(dist).to have_key(:max)
+      expect(dist).to have_key(:mean)
+      expect(dist).to have_key(:median)
+    end
+
+    it 'fitness_distribution min <= mean <= max' do
+      result = evolver.evolution_summary(extensions: all_exts)
+      dist = result[:fitness_distribution]
+      expect(dist[:min]).to be <= dist[:mean]
+      expect(dist[:mean]).to be <= dist[:max]
+    end
+
+    it 'includes low-fitness extension in improvement_candidates' do
+      result = evolver.evolution_summary(extensions: [high_ext, low_ext], count: 1)
+      names = result[:improvement_candidates].map { |c| c[:name] }
+      expect(names).to include('lex-low')
+    end
+
+    it 'identifies speciation candidates by drift_score' do
+      drifted = { name: 'lex-drifted', drift_score: 0.8, invocation_count: 10,
+                  impact_score: 0.5, health_score: 0.5, error_rate: 0.0, avg_latency_ms: 0 }
+      result  = evolver.evolution_summary(extensions: [drifted])
+      expect(result[:speciation_candidates]).to include('lex-drifted')
+    end
+
+    it 'does not flag extension with drift_score below threshold as speciation candidate' do
+      stable = { name: 'lex-stable', drift_score: 0.1, invocation_count: 100,
+                 impact_score: 0.7, health_score: 0.9, error_rate: 0.0, avg_latency_ms: 0 }
+      result = evolver.evolution_summary(extensions: [stable])
+      expect(result[:speciation_candidates]).to be_empty
+    end
+
+    it 'returns all-zero distribution for empty extensions' do
+      result = evolver.evolution_summary(extensions: [])
+      dist = result[:fitness_distribution]
+      expect(dist[:min]).to eq(0.0)
+      expect(dist[:max]).to eq(0.0)
+      expect(dist[:mean]).to eq(0.0)
+      expect(dist[:median]).to eq(0.0)
+    end
+
+    it 'handles all extensions having the same fitness' do
+      same = Array.new(3) do |i|
+        { name: "lex-same-#{i}", invocation_count: 0, impact_score: 0.0,
+          health_score: 0.0, error_rate: 0.0, avg_latency_ms: 0 }
+      end
+      result = evolver.evolution_summary(extensions: same)
+      dist = result[:fitness_distribution]
+      expect(dist[:min]).to eq(dist[:max])
+    end
+  end
+
+  # ─── constants ─────────────────────────────────────────────────────────────
+
+  describe 'constants' do
+    it 'defines BOTTOM_PERCENTILE as 0.05' do
+      expect(described_class::BOTTOM_PERCENTILE).to eq(0.05)
+    end
+
+    it 'defines SPECIATION_DRIFT_THRESHOLD as 0.5' do
+      expect(described_class::SPECIATION_DRIFT_THRESHOLD).to eq(0.5)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Esity
@@ -145,7 +145,9 @@ files:
 - lib/legion/extensions/mind_growth/runners/analyzer.rb
 - lib/legion/extensions/mind_growth/runners/builder.rb
 - lib/legion/extensions/mind_growth/runners/composer.rb
+- lib/legion/extensions/mind_growth/runners/dashboard.rb
 - lib/legion/extensions/mind_growth/runners/dream_ideation.rb
+- lib/legion/extensions/mind_growth/runners/evolver.rb
 - lib/legion/extensions/mind_growth/runners/governance.rb
 - lib/legion/extensions/mind_growth/runners/integration_tester.rb
 - lib/legion/extensions/mind_growth/runners/monitor.rb
@@ -168,7 +170,9 @@ files:
 - spec/legion/extensions/mind_growth/runners/analyzer_spec.rb
 - spec/legion/extensions/mind_growth/runners/builder_spec.rb
 - spec/legion/extensions/mind_growth/runners/composer_spec.rb
+- spec/legion/extensions/mind_growth/runners/dashboard_spec.rb
 - spec/legion/extensions/mind_growth/runners/dream_ideation_spec.rb
+- spec/legion/extensions/mind_growth/runners/evolver_spec.rb
 - spec/legion/extensions/mind_growth/runners/governance_spec.rb
 - spec/legion/extensions/mind_growth/runners/integration_tester_spec.rb
 - spec/legion/extensions/mind_growth/runners/monitor_spec.rb