lex-mind-growth 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 999d127eafaaedc61d385450a47bfbceb21d0f9ce7ef753205fc18dff5ca3de0
-  data.tar.gz: 2ee2545c17f817ed5df9be04b88d6869f6032709e5cdd621e351df29b82908f3
+  metadata.gz: 44ba3c4f6e43488f8e92edb6be0b6204890b58f76220efd964c924db011674b3
+  data.tar.gz: 571392567974177a54cc4d3df6b094ad895849f3de415b271f0133bb3ed6d40d
 SHA512:
-  metadata.gz: db4150d16a4a452f59ecdc32ee140031b9d8fc8d03bab1f082accadba07be7d708cee018106dbec216c0246f243e9086e435788e0ec426f96a56e46e82aa30d7
-  data.tar.gz: b8c2d52aeb38acde956b34c75df47aff07520c3047becae634e5e662118bbb65fc9747778326535dbe38e2f23b636f4432653b900a4d403560e5ababd8bc8ce8
+  metadata.gz: 23e9288fa07cce5693c0aa7f9475ad7f6f9c2f7e211fecf39c4dc4f2309ed674115537358dbcf65dda6b3091e1153927716b2d17798b16ff7b368d7576f6612c
+  data.tar.gz: 7a141886553785dca8178cacb63f5021be1ae3aa1eee80003f86e06b5b3a641778e5cc85f282db229916d4ab0d812a4c0c0d82b3d8e652061578043e51a961d2

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

@@ -91,6 +91,15 @@ module Legion
         def resolve_disagreement(**) = Runners::ConsensusBuilder.resolve_disagreement(**)
         def consensus_summary(**) = Runners::ConsensusBuilder.consensus_summary(**)
 
+        # CompetitiveEvolver delegation
+        def create_competition(**)    = Runners::CompetitiveEvolver.create_competition(**)
+        def run_trial(**)             = Runners::CompetitiveEvolver.run_trial(**)
+        def compare_results(**)       = Runners::CompetitiveEvolver.compare_results(**)
+        def declare_winner(**)        = Runners::CompetitiveEvolver.declare_winner(**)
+        def competition_status(**)    = Runners::CompetitiveEvolver.competition_status(**)
+        def active_competitions(**)   = Runners::CompetitiveEvolver.active_competitions(**)
+        def competition_history(**)   = Runners::CompetitiveEvolver.competition_history(**)
+
         # Dashboard delegation
         def extension_timeline(**) = Runners::Dashboard.extension_timeline(**)
         def category_distribution(**) = Runners::Dashboard.category_distribution(**)

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module CompetitiveEvolver
+          extend self
+
+          COMPETITION_STATUSES = %i[pending active evaluating decided cancelled].freeze
+          MIN_TRIAL_ITERATIONS = 10
+
+          def create_competition(gap:, proposal_ids:, **)
+            ids = Array(proposal_ids)
+            return { success: false, reason: :insufficient_competitors } if ids.size < 2
+
+            competition_id = SecureRandom.uuid
+            competition = {
+              id:           competition_id,
+              gap:          gap.to_s,
+              proposal_ids: ids,
+              status:       :pending,
+              trials:       {},
+              winner:       nil,
+              created_at:   Time.now.utc,
+              decided_at:   nil
+            }
+
+            store_competition(competition)
+            { success: true, competition_id: competition_id, gap: gap.to_s, competitors: ids.size }
+          end
+
+          def run_trial(competition_id:, extension:, iterations: MIN_TRIAL_ITERATIONS, **)
+            competition = get_competition(competition_id)
+            return { success: false, reason: :not_found } unless competition
+            return { success: false, reason: :already_decided } if competition[:status] == :decided
+
+            transition_competition(competition_id, :active) if competition[:status] == :pending
+
+            fitness = Helpers::FitnessEvaluator.fitness(extension)
+            name = extension[:name] || extension[:extension_name]
+
+            trial = {
+              extension_name: name,
+              fitness:        fitness,
+              error_rate:     extension[:error_rate] || 0.0,
+              avg_latency_ms: extension[:avg_latency_ms] || 0,
+              invocations:    extension[:invocation_count] || 0,
+              iterations:     iterations,
+              recorded_at:    Time.now.utc
+            }
+
+            record_trial(competition_id, name, trial)
+            { success: true, competition_id: competition_id, trial: trial }
+          end
+
+          def compare_results(competition_id:, **)
+            competition = get_competition(competition_id)
+            return { success: false, reason: :not_found } unless competition
+
+            trials = competition[:trials]
+            return { success: true, comparison: [], leader: nil } if trials.empty?
+
+            ranked = trials.values.sort_by { |t| [-t[:fitness], t[:avg_latency_ms]] }
+            leader = ranked.first
+
+            comparison = ranked.map.with_index(1) do |trial, rank|
+              {
+                extension_name: trial[:extension_name],
+                fitness:        trial[:fitness],
+                error_rate:     trial[:error_rate],
+                avg_latency_ms: trial[:avg_latency_ms],
+                rank:           rank
+              }
+            end
+
+            { success: true, comparison: comparison, leader: leader[:extension_name] }
+          end
+
+          def declare_winner(competition_id:, **)
+            competition = get_competition(competition_id)
+            return { success: false, reason: :not_found } unless competition
+            return { success: false, reason: :already_decided } if competition[:status] == :decided
+            return { success: false, reason: :no_trials } if competition[:trials].empty?
+
+            comparison = compare_results(competition_id: competition_id)
+            winner_name = comparison[:leader]
+
+            losers = competition[:trials].keys.reject { |name| name == winner_name }
+
+            losers.each do |loser_name|
+              Runners::Evolver.replace_extension(old_name: loser_name, new_proposal_id: "winner:#{winner_name}")
+            end
+
+            transition_competition(competition_id, :decided)
+            set_winner(competition_id, winner_name)
+
+            { success: true, winner: winner_name, losers: losers, competition_id: competition_id }
+          end
+
+          def competition_status(competition_id:, **)
+            competition = get_competition(competition_id)
+            return { success: false, reason: :not_found } unless competition
+
+            { success: true, id: competition[:id], gap: competition[:gap],
+              status: competition[:status], competitors: competition[:proposal_ids],
+              trial_count: competition[:trials].size, winner: competition[:winner] }
+          end
+
+          def active_competitions(**)
+            comps = all_competitions.select { |c| %i[pending active evaluating].include?(c[:status]) }
+            { success: true, competitions: comps.map { |c| { id: c[:id], gap: c[:gap], status: c[:status] } },
+              count: comps.size }
+          end
+
+          def competition_history(limit: 20, **)
+            comps = all_competitions.sort_by { |c| c[:created_at] }.reverse.first(limit)
+            entries = comps.map do |c|
+              { id: c[:id], gap: c[:gap], status: c[:status], winner: c[:winner],
+                competitors: c[:proposal_ids].size, trial_count: c[:trials].size }
+            end
+            { success: true, competitions: entries, count: entries.size }
+          end
+
+          private
+
+          def competitions
+            @competitions ||= {}
+          end
+
+          def mutex
+            @mutex ||= Mutex.new
+          end
+
+          def store_competition(competition)
+            mutex.synchronize { competitions[competition[:id]] = competition }
+          end
+
+          def get_competition(id)
+            mutex.synchronize { competitions[id]&.dup }
+          end
+
+          def all_competitions
+            mutex.synchronize { competitions.values.map(&:dup) }
+          end
+
+          def transition_competition(id, new_status)
+            mutex.synchronize do
+              competitions[id][:status] = new_status
+              competitions[id][:decided_at] = Time.now.utc if new_status == :decided
+            end
+          end
+
+          def set_winner(id, winner_name)
+            mutex.synchronize { competitions[id][:winner] = winner_name }
+          end
+
+          def record_trial(competition_id, name, trial)
+            mutex.synchronize { competitions[competition_id][:trials][name] = trial }
+          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.2.0'
+      VERSION = '0.2.1'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -28,6 +28,7 @@ require 'legion/extensions/mind_growth/runners/evolver'
 require 'legion/extensions/mind_growth/runners/dashboard'
 require 'legion/extensions/mind_growth/runners/swarm_builder'
 require 'legion/extensions/mind_growth/runners/consensus_builder'
+require 'legion/extensions/mind_growth/runners/competitive_evolver'
 require 'legion/extensions/mind_growth/client'
 
 module Legion

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

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::CompetitiveEvolver do
+  subject(:evolver) { described_class }
+
+  # Reset internal state between tests
+  after do
+    described_class.instance_variable_set(:@competitions, {})
+  end
+
+  # ─── helpers ──────────────────────────────────────────────────────────────
+
+  def build_extension(name:, invocation_count: 100, error_rate: 0.01, avg_latency_ms: 50,
+                      impact_score: 0.7, health_score: 0.8, category: :cognition)
+    { name: name, invocation_count: invocation_count, error_rate: error_rate,
+      avg_latency_ms: avg_latency_ms, impact_score: impact_score,
+      health_score: health_score, category: category }
+  end
+
+  def create_and_return_id(gap: 'working_memory', proposal_ids: %w[p1 p2])
+    result = evolver.create_competition(gap: gap, proposal_ids: proposal_ids)
+    result[:competition_id]
+  end
+
+  # ─── constants ───────────────────────────────────────────────────────────
+
+  describe 'constants' do
+    it 'defines COMPETITION_STATUSES' do
+      expect(described_class::COMPETITION_STATUSES).to contain_exactly(
+        :pending, :active, :evaluating, :decided, :cancelled
+      )
+    end
+
+    it 'defines MIN_TRIAL_ITERATIONS as 10' do
+      expect(described_class::MIN_TRIAL_ITERATIONS).to eq(10)
+    end
+  end
+
+  # ─── create_competition ─────────────────────────────────────────────────
+
+  describe '.create_competition' do
+    it 'returns success: true with a competition_id' do
+      result = evolver.create_competition(gap: 'attention', proposal_ids: %w[p1 p2])
+      expect(result[:success]).to be true
+      expect(result[:competition_id]).to be_a(String)
+    end
+
+    it 'returns the gap and competitor count' do
+      result = evolver.create_competition(gap: 'attention', proposal_ids: %w[p1 p2 p3])
+      expect(result[:gap]).to eq('attention')
+      expect(result[:competitors]).to eq(3)
+    end
+
+    it 'requires at least 2 competitors' do
+      result = evolver.create_competition(gap: 'attention', proposal_ids: ['p1'])
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:insufficient_competitors)
+    end
+
+    it 'returns failure for empty proposal_ids' do
+      result = evolver.create_competition(gap: 'attention', proposal_ids: [])
+      expect(result[:success]).to be false
+    end
+
+    it 'creates competition in :pending status' do
+      cid = create_and_return_id
+      status = evolver.competition_status(competition_id: cid)
+      expect(status[:status]).to eq(:pending)
+    end
+  end
+
+  # ─── run_trial ──────────────────────────────────────────────────────────
+
+  describe '.run_trial' do
+    let(:competition_id) { create_and_return_id }
+
+    it 'returns success: true with trial data' do
+      ext = build_extension(name: 'ext-a')
+      result = evolver.run_trial(competition_id: competition_id, extension: ext)
+      expect(result[:success]).to be true
+      expect(result[:trial][:extension_name]).to eq('ext-a')
+    end
+
+    it 'records the fitness score from FitnessEvaluator' do
+      ext = build_extension(name: 'ext-a', invocation_count: 1000, impact_score: 0.9, health_score: 1.0)
+      result = evolver.run_trial(competition_id: competition_id, extension: ext)
+      expect(result[:trial][:fitness]).to be > 0
+    end
+
+    it 'transitions competition to :active on first trial' do
+      ext = build_extension(name: 'ext-a')
+      evolver.run_trial(competition_id: competition_id, extension: ext)
+      status = evolver.competition_status(competition_id: competition_id)
+      expect(status[:status]).to eq(:active)
+    end
+
+    it 'returns failure for nonexistent competition' do
+      ext = build_extension(name: 'ext-a')
+      result = evolver.run_trial(competition_id: 'bogus', extension: ext)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns failure for decided competition' do
+      cid = create_and_return_id
+      ext_a = build_extension(name: 'ext-a', invocation_count: 1000, impact_score: 0.9)
+      ext_b = build_extension(name: 'ext-b', invocation_count: 10, impact_score: 0.1)
+      evolver.run_trial(competition_id: cid, extension: ext_a)
+      evolver.run_trial(competition_id: cid, extension: ext_b)
+      evolver.declare_winner(competition_id: cid)
+
+      result = evolver.run_trial(competition_id: cid, extension: ext_a)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:already_decided)
+    end
+
+    it 'uses extension_name if name is not present' do
+      ext = { extension_name: 'ext-fallback', invocation_count: 50, error_rate: 0.0,
+              avg_latency_ms: 10, impact_score: 0.5, health_score: 0.7 }
+      result = evolver.run_trial(competition_id: competition_id, extension: ext)
+      expect(result[:trial][:extension_name]).to eq('ext-fallback')
+    end
+
+    it 'records custom iteration count' do
+      ext = build_extension(name: 'ext-a')
+      result = evolver.run_trial(competition_id: competition_id, extension: ext, iterations: 50)
+      expect(result[:trial][:iterations]).to eq(50)
+    end
+  end
+
+  # ─── compare_results ────────────────────────────────────────────────────
+
+  describe '.compare_results' do
+    let(:competition_id) { create_and_return_id }
+
+    it 'returns empty comparison when no trials exist' do
+      result = evolver.compare_results(competition_id: competition_id)
+      expect(result[:success]).to be true
+      expect(result[:comparison]).to be_empty
+      expect(result[:leader]).to be_nil
+    end
+
+    it 'ranks extensions by fitness descending' do
+      ext_high = build_extension(name: 'winner', invocation_count: 1000, impact_score: 0.9, health_score: 1.0)
+      ext_low  = build_extension(name: 'loser', invocation_count: 10, impact_score: 0.1, health_score: 0.3)
+      evolver.run_trial(competition_id: competition_id, extension: ext_low)
+      evolver.run_trial(competition_id: competition_id, extension: ext_high)
+
+      result = evolver.compare_results(competition_id: competition_id)
+      expect(result[:leader]).to eq('winner')
+      expect(result[:comparison].first[:rank]).to eq(1)
+      expect(result[:comparison].first[:extension_name]).to eq('winner')
+    end
+
+    it 'breaks ties by lower latency' do
+      ext_a = build_extension(name: 'fast', invocation_count: 100, impact_score: 0.7,
+                              health_score: 0.8, avg_latency_ms: 10)
+      ext_b = build_extension(name: 'slow', invocation_count: 100, impact_score: 0.7,
+                              health_score: 0.8, avg_latency_ms: 500)
+      evolver.run_trial(competition_id: competition_id, extension: ext_a)
+      evolver.run_trial(competition_id: competition_id, extension: ext_b)
+
+      result = evolver.compare_results(competition_id: competition_id)
+      expect(result[:leader]).to eq('fast')
+    end
+
+    it 'returns failure for nonexistent competition' do
+      result = evolver.compare_results(competition_id: 'bogus')
+      expect(result[:success]).to be false
+    end
+
+    it 'includes all trial data in comparison' do
+      ext = build_extension(name: 'solo', error_rate: 0.05, avg_latency_ms: 42)
+      evolver.run_trial(competition_id: competition_id, extension: ext)
+      result = evolver.compare_results(competition_id: competition_id)
+      entry = result[:comparison].first
+      expect(entry).to include(:fitness, :error_rate, :avg_latency_ms, :rank)
+    end
+  end
+
+  # ─── declare_winner ─────────────────────────────────────────────────────
+
+  describe '.declare_winner' do
+    let(:competition_id) { create_and_return_id }
+
+    before do
+      ext_a = build_extension(name: 'champion', invocation_count: 1000, impact_score: 0.9, health_score: 1.0)
+      ext_b = build_extension(name: 'challenger', invocation_count: 10, impact_score: 0.1, health_score: 0.3)
+      evolver.run_trial(competition_id: competition_id, extension: ext_a)
+      evolver.run_trial(competition_id: competition_id, extension: ext_b)
+    end
+
+    it 'returns success: true with the winner' do
+      result = evolver.declare_winner(competition_id: competition_id)
+      expect(result[:success]).to be true
+      expect(result[:winner]).to eq('champion')
+    end
+
+    it 'returns the losers list' do
+      result = evolver.declare_winner(competition_id: competition_id)
+      expect(result[:losers]).to contain_exactly('challenger')
+    end
+
+    it 'transitions competition to :decided' do
+      evolver.declare_winner(competition_id: competition_id)
+      status = evolver.competition_status(competition_id: competition_id)
+      expect(status[:status]).to eq(:decided)
+    end
+
+    it 'sets the winner on the competition' do
+      evolver.declare_winner(competition_id: competition_id)
+      status = evolver.competition_status(competition_id: competition_id)
+      expect(status[:winner]).to eq('champion')
+    end
+
+    it 'calls Evolver.replace_extension for each loser' do
+      expect(Legion::Extensions::MindGrowth::Runners::Evolver).to receive(:replace_extension)
+        .with(old_name: 'challenger', new_proposal_id: 'winner:champion')
+        .and_return({ success: true, replaced: 'challenger' })
+      evolver.declare_winner(competition_id: competition_id)
+    end
+
+    it 'returns failure for nonexistent competition' do
+      result = evolver.declare_winner(competition_id: 'bogus')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns failure when already decided' do
+      evolver.declare_winner(competition_id: competition_id)
+      result = evolver.declare_winner(competition_id: competition_id)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:already_decided)
+    end
+
+    it 'returns failure when no trials exist' do
+      cid = create_and_return_id(proposal_ids: %w[x y])
+      result = evolver.declare_winner(competition_id: cid)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:no_trials)
+    end
+  end
+
+  # ─── competition_status ─────────────────────────────────────────────────
+
+  describe '.competition_status' do
+    it 'returns competition details' do
+      cid = create_and_return_id(gap: 'prediction', proposal_ids: %w[a b c])
+      result = evolver.competition_status(competition_id: cid)
+      expect(result[:success]).to be true
+      expect(result[:gap]).to eq('prediction')
+      expect(result[:competitors]).to eq(%w[a b c])
+      expect(result[:trial_count]).to eq(0)
+    end
+
+    it 'returns failure for nonexistent competition' do
+      result = evolver.competition_status(competition_id: 'missing')
+      expect(result[:success]).to be false
+    end
+  end
+
+  # ─── active_competitions ────────────────────────────────────────────────
+
+  describe '.active_competitions' do
+    it 'returns empty list when no competitions exist' do
+      result = evolver.active_competitions
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'includes pending and active competitions' do
+      create_and_return_id(gap: 'gap1')
+      cid2 = create_and_return_id(gap: 'gap2')
+      evolver.run_trial(competition_id: cid2, extension: build_extension(name: 'e1'))
+
+      result = evolver.active_competitions
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'excludes decided competitions' do
+      cid = create_and_return_id
+      evolver.run_trial(competition_id: cid, extension: build_extension(name: 'a', invocation_count: 1000))
+      evolver.run_trial(competition_id: cid, extension: build_extension(name: 'b', invocation_count: 1))
+      evolver.declare_winner(competition_id: cid)
+
+      result = evolver.active_competitions
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  # ─── competition_history ────────────────────────────────────────────────
+
+  describe '.competition_history' do
+    it 'returns empty list when no competitions exist' do
+      result = evolver.competition_history
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns competitions sorted by most recent first' do
+      create_and_return_id(gap: 'first')
+      _cid2 = create_and_return_id(gap: 'second')
+
+      result = evolver.competition_history
+      expect(result[:count]).to eq(2)
+      expect(result[:competitions].first[:gap]).to eq('second')
+    end
+
+    it 'respects the limit parameter' do
+      3.times { |i| create_and_return_id(gap: "gap-#{i}") }
+      result = evolver.competition_history(limit: 2)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'includes winner and trial_count for decided competitions' do
+      cid = create_and_return_id
+      evolver.run_trial(competition_id: cid, extension: build_extension(name: 'w', invocation_count: 1000))
+      evolver.run_trial(competition_id: cid, extension: build_extension(name: 'l', invocation_count: 1))
+      evolver.declare_winner(competition_id: cid)
+
+      result = evolver.competition_history
+      entry = result[:competitions].find { |c| c[:id] == cid }
+      expect(entry[:winner]).to eq('w')
+      expect(entry[:trial_count]).to eq(2)
+    end
+  end
+
+  # ─── thread safety ─────────────────────────────────────────────────────
+
+  describe 'thread safety' do
+    it 'handles concurrent competition creation' do
+      threads = 10.times.map do |i|
+        Thread.new { evolver.create_competition(gap: "gap-#{i}", proposal_ids: %w[a b]) }
+      end
+      results = threads.map(&:value)
+      expect(results.count { |r| r[:success] }).to eq(10)
+      expect(evolver.competition_history[:count]).to eq(10)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Esity
@@ -144,6 +144,7 @@ files:
 - lib/legion/extensions/mind_growth/helpers/proposal_store.rb
 - lib/legion/extensions/mind_growth/runners/analyzer.rb
 - lib/legion/extensions/mind_growth/runners/builder.rb
+- lib/legion/extensions/mind_growth/runners/competitive_evolver.rb
 - lib/legion/extensions/mind_growth/runners/composer.rb
 - lib/legion/extensions/mind_growth/runners/consensus_builder.rb
 - lib/legion/extensions/mind_growth/runners/dashboard.rb
@@ -171,6 +172,7 @@ files:
 - spec/legion/extensions/mind_growth/helpers/proposal_store_spec.rb
 - spec/legion/extensions/mind_growth/runners/analyzer_spec.rb
 - spec/legion/extensions/mind_growth/runners/builder_spec.rb
+- spec/legion/extensions/mind_growth/runners/competitive_evolver_spec.rb
 - spec/legion/extensions/mind_growth/runners/composer_spec.rb
 - spec/legion/extensions/mind_growth/runners/consensus_builder_spec.rb
 - spec/legion/extensions/mind_growth/runners/dashboard_spec.rb