lex-mind-growth 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ee2be00d683bb637298c7cd47ade31afe6164e69d00d032577ede07a85e23c7
-  data.tar.gz: aa60548111e18409e2cf09476e8e37cfa9bd4eb8912a57e174b41d6c1e80bfb0
+  metadata.gz: 3fcaa84f5b0e455b0ac70019228ebe5bffdbd1c69228aafcad9bf92d7f91bb52
+  data.tar.gz: 4ea8b0c108d6bf0a957cd9709147e4cfaa3c78e0b297afc85e642331f9153e4a
 SHA512:
-  metadata.gz: 3f82c6da963f5ff2eea9a603e0b1c509ac643ebac93039bff7855cb3c673f927153e664412dc1ecf97bed571102793ecd3ac0859f58c55ce159e596ca82cb532
-  data.tar.gz: 2c8517423557a7e7c77c2c76b2ac8adbdddb08e3570d1eb430ba25b479b7da664d39af19f6f7800e2200f33af53d475b25c44a5bfb35ff93ab44631e613507f5
+  metadata.gz: 911dc8e13b4dfe4cb4ee0cd5dd7cd27fc2d93a529aca350cc4d02d4f3f27b9548ac8881945bb57d150ffa8cc8e169e8f62b3590e2bbab4188dbfc0046aa69eb3
+  data.tar.gz: d4f849194085b3b398dd41e3499b686c87b323ab4950a392eaca71133aeb943fcfe68557829a5cb6be92428bf781c90ab53d49cf877f26abe5b699562c25d07e

data/Gemfile

@@ -8,6 +8,7 @@ group :test do
   gem 'rspec', '~> 3.13'
   gem 'rspec_junit_formatter'
   gem 'rubocop', '~> 1.75'
+  gem 'rubocop-legion', '~> 0.1.7'
   gem 'rubocop-rspec'
   gem 'simplecov'
 end

data/lib/legion/extensions/mind_growth/actors/growth_cycle.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module MindGrowth
       module Actor
-        class GrowthCycle < Legion::Extensions::Actors::Every
+        class GrowthCycle < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
           def runner_class
             Legion::Extensions::MindGrowth::Runners::Orchestrator
           end
@@ -19,7 +19,7 @@ module Legion
             3600
           end
 
-          def enabled?
+          def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
             codegen_loaded? || exec_loaded?
           end
 
@@ -32,7 +32,7 @@ module Legion
           end
 
           def check_subtask?
-            false
+            true
           end
 
           def generate_task?

data/lib/legion/extensions/mind_growth/helpers/composition_map.rb

@@ -7,7 +7,7 @@ module Legion
         module CompositionMap
           module_function
 
-          @rules = {}
+          @rules = {} # rubocop:disable ThreadSafety/MutableClassInstanceVariable
           @mutex = Mutex.new
 
           def add_rule(source_extension:, output_key:, target_extension:, target_method:, transform: nil, **)
@@ -19,7 +19,7 @@ module Legion
               target_extension: target_extension.to_s,
               target_method:    target_method.to_sym,
               transform:        transform
-            }
+            }.freeze
             @mutex.synchronize { @rules[rule_id] = rule }
             { success: true, rule_id: rule_id }
           end
@@ -31,7 +31,7 @@ module Legion
 
           def rules_for(source_extension:, **)
             src = source_extension.to_s
-            @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src } }
+            @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src }.map(&:dup) }
           end
 
           def all_rules
@@ -41,7 +41,7 @@ module Legion
           def match_output(source_extension:, output:, **)
             src   = source_extension.to_s
             out_h = output.is_a?(Hash) ? output : {}
-            rules = @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src } }
+            rules = @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src }.map(&:dup) }
 
             rules.filter_map do |rule|
               key = rule[:output_key]

data/lib/legion/extensions/mind_growth/helpers/concept_proposal.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module Legion
   module Extensions
     module MindGrowth
@@ -12,7 +14,7 @@ module Legion
 
           attr_reader(*FIELDS)
 
-          def initialize(name:, module_name:, category:, description:, metaphor: nil, helpers: [],
+          def initialize(name:, module_name:, category:, description:, metaphor: nil, helpers: [], # rubocop:disable Metrics/ParameterLists
                          runner_methods: [], rationale: nil, origin: :proposer)
             @id             = SecureRandom.uuid
             @name           = name
@@ -59,6 +61,27 @@ module Legion
             @built_at = Time.now.utc if new_status == :passing
           end
 
+          def self.from_h(hash)
+            h = hash.transform_keys(&:to_sym)
+            proposal = allocate
+            proposal.instance_variable_set(:@id,             h[:id])
+            proposal.instance_variable_set(:@name,           h[:name])
+            proposal.instance_variable_set(:@module_name,    h[:module_name])
+            proposal.instance_variable_set(:@category,       h[:category]&.to_sym)
+            proposal.instance_variable_set(:@description,    h[:description])
+            proposal.instance_variable_set(:@metaphor,       h[:metaphor])
+            proposal.instance_variable_set(:@helpers,        h[:helpers] || [])
+            proposal.instance_variable_set(:@runner_methods, h[:runner_methods] || [])
+            proposal.instance_variable_set(:@rationale,      h[:rationale])
+            proposal.instance_variable_set(:@scores,         (h[:scores] || {}).transform_keys(&:to_sym))
+            proposal.instance_variable_set(:@status,         h[:status]&.to_sym || :proposed)
+            proposal.instance_variable_set(:@origin,         h[:origin]&.to_sym || :proposer)
+            proposal.instance_variable_set(:@created_at,     h[:created_at] ? Time.parse(h[:created_at].to_s) : Time.now.utc)
+            proposal.instance_variable_set(:@evaluated_at,   h[:evaluated_at] ? Time.parse(h[:evaluated_at].to_s) : nil)
+            proposal.instance_variable_set(:@built_at,       h[:built_at] ? Time.parse(h[:built_at].to_s) : nil)
+            proposal
+          end
+
           def to_h
             FIELDS.to_h { |f| [f, send(f)] }
           end

data/lib/legion/extensions/mind_growth/helpers/phase_allocator.rb

@@ -89,7 +89,7 @@ module Legion
           end
 
           def valid_phase?(phase)
-            CATEGORY_PHASE_MAP.values.include?(phase) || DREAM_PHASE_MAP.values.include?(phase)
+            CATEGORY_PHASE_MAP.value?(phase) || DREAM_PHASE_MAP.value?(phase)
           end
 
           def phases_for_category(category)

data/lib/legion/extensions/mind_growth/helpers/proposal_persistence.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        # Cache-backed persistence for proposals and governance votes.
+        # Best-effort: degrades to in-memory-only when cache is unavailable.
+        class ProposalPersistence
+          PROPOSAL_TTL     = 604_800 # 7 days
+          VOTES_KEY_SUFFIX = ':votes'
+          INDEX_KEY_SUFFIX = ':index'
+
+          def initialize(namespace: 'legion_mind_growth')
+            @namespace = namespace
+          end
+
+          def save_proposal(proposal_hash)
+            return false unless cache_available?
+
+            key = proposal_key(proposal_hash[:id])
+            Legion::Cache.set_sync(key, serialize(proposal_hash), ttl: PROPOSAL_TTL)
+            update_index(proposal_hash[:id], :add)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] save_proposal failed for #{proposal_hash[:id]}: #{e.message}"
+            false
+          end
+
+          def load_proposal(id)
+            return nil unless cache_available?
+
+            raw = Legion::Cache.get(proposal_key(id)) # rubocop:disable Legion/HelperMigration/DirectCache
+            return nil unless raw
+
+            deserialize(raw)
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_proposal failed for #{id}: #{e.message}"
+            nil
+          end
+
+          def delete_proposal(id)
+            return false unless cache_available?
+
+            Legion::Cache.delete_sync(proposal_key(id))
+            update_index(id, :remove)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] delete_proposal failed for #{id}: #{e.message}"
+            false
+          end
+
+          def load_all_proposals
+            return {} unless cache_available?
+
+            ids = load_index
+            return {} if ids.empty?
+
+            ids.each_with_object({}) do |id, result|
+              p = load_proposal(id)
+              result[id] = p if p
+            end
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_all_proposals failed: #{e.message}"
+            {}
+          end
+
+          def delete_all_proposals
+            return false unless cache_available?
+
+            ids = load_index
+            ids.each { |id| Legion::Cache.delete_sync(proposal_key(id)) }
+            Legion::Cache.delete_sync(index_key)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] delete_all_proposals failed: #{e.message}"
+            false
+          end
+
+          def save_votes(votes_hash)
+            return false unless cache_available?
+
+            Legion::Cache.set_sync(votes_key, serialize(votes_hash), ttl: PROPOSAL_TTL)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] save_votes failed: #{e.message}"
+            false
+          end
+
+          def load_votes
+            return {} unless cache_available?
+
+            raw = Legion::Cache.get(votes_key) # rubocop:disable Legion/HelperMigration/DirectCache
+            return {} unless raw
+
+            result = deserialize(raw)
+            result.is_a?(Hash) ? result : {}
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_votes failed: #{e.message}"
+            {}
+          end
+
+          private
+
+          def cache_available?
+            defined?(Legion::Cache) && Legion::Cache.connected? # rubocop:disable Legion/HelperMigration/DirectCache
+          end
+
+          def proposal_key(id) = "#{@namespace}:proposal:#{id}"
+          def votes_key        = "#{@namespace}#{VOTES_KEY_SUFFIX}"
+          def index_key        = "#{@namespace}#{INDEX_KEY_SUFFIX}"
+
+          def update_index(id, operation)
+            ids = load_index
+            case operation
+            when :add    then ids << id unless ids.include?(id)
+            when :remove then ids.delete(id)
+            end
+            Legion::Cache.set_sync(index_key, serialize(ids), ttl: PROPOSAL_TTL)
+          end
+
+          def load_index
+            raw = Legion::Cache.get(index_key) # rubocop:disable Legion/HelperMigration/DirectCache
+            return [] unless raw
+
+            result = deserialize(raw)
+            result.is_a?(Array) ? result : []
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_index failed: #{e.message}"
+            []
+          end
+
+          def serialize(obj)
+            Legion::JSON.dump(obj) # rubocop:disable Legion/HelperMigration/DirectJson
+          end
+
+          def deserialize(raw)
+            return raw if raw.is_a?(Hash) || raw.is_a?(Array)
+
+            Legion::JSON.load(raw) # rubocop:disable Legion/HelperMigration/DirectJson
+          rescue StandardError => _e
+            nil
+          end
+
+          def log
+            Legion::Logging
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mind_growth/helpers/proposal_store.rb

@@ -7,15 +7,18 @@ module Legion
         class ProposalStore
           MAX_PROPOSALS = 500
 
-          def initialize
-            @proposals = {}
-            @mutex     = Mutex.new
+          def initialize(rehydrate: true)
+            @proposals   = {}
+            @mutex       = Mutex.new
+            @persistence = ProposalPersistence.new
+            rehydrate_from_cache if rehydrate
           end
 
           def store(proposal)
             @mutex.synchronize do
               evict_oldest if @proposals.size >= MAX_PROPOSALS
               @proposals[proposal.id] = proposal
+              @persistence.save_proposal(proposal.to_h)
             end
           end
 
@@ -23,6 +26,13 @@ module Legion
             @mutex.synchronize { @proposals[id] }
           end
 
+          def update(proposal)
+            @mutex.synchronize do
+              @proposals[proposal.id] = proposal
+              @persistence.save_proposal(proposal.to_h)
+            end
+          end
+
           def all
             @mutex.synchronize { @proposals.values.dup }
           end
@@ -58,11 +68,36 @@ module Legion
             @mutex.synchronize { @proposals.clear }
           end
 
+          def clear_persisted!
+            @mutex.synchronize do
+              @proposals.clear
+              @persistence.delete_all_proposals
+            end
+          end
+
           private
 
           def evict_oldest
             oldest = @proposals.values.min_by { |p| p.created_at.to_f }
-            @proposals.delete(oldest.id) if oldest
+            return unless oldest
+
+            @proposals.delete(oldest.id)
+            @persistence.delete_proposal(oldest.id)
+          end
+
+          def rehydrate_from_cache
+            cached = @persistence.load_all_proposals
+            cached.each do |id, hash|
+              proposal = ConceptProposal.from_h(hash)
+              @proposals[id] = proposal
+            end
+            log.info "[proposal_store] rehydrated #{cached.size} proposals from cache" unless cached.empty?
+          rescue StandardError => e
+            log.error "[proposal_store] rehydrate_from_cache failed: #{e.message}"
+          end
+
+          def log
+            Legion::Logging
           end
         end
       end

data/lib/legion/extensions/mind_growth/hooks/governance_listener.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Hooks
+        module GovernanceListener
+          module_function
+
+          def register
+            return unless defined?(Legion::Events)
+
+            Legion::Events.on('governance.quorum_reached') do |event|
+              next unless event[:verdict] == :approved
+
+              base_path = event[:base_path] || GovernanceListener.configured_base_path
+              GovernanceListener.log.info "[governance_listener] quorum approved for #{event[:proposal_id]}, triggering build"
+              Runners::Governance.governance_resolved(proposal_id: event[:proposal_id], base_path: base_path)
+            end
+          end
+
+          def configured_base_path
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:mind_growth, :base_path)
+          rescue StandardError => e
+            log.debug "[governance_listener] configured_base_path failed: #{e.message}"
+            nil
+          end
+
+          def log
+            Legion::Logging
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Builder
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
           extend self
 
@@ -16,6 +16,7 @@ module Legion
 
             pipeline = Helpers::BuildPipeline.new(proposal)
             proposal.transition!(:building)
+            persist_proposal(proposal)
             base_path ||= ::Dir.pwd
 
             run_stage(pipeline, :scaffold,  -> { scaffold_stage(proposal, base_path) })
@@ -25,6 +26,7 @@ module Legion
             run_stage(pipeline, :register,  -> { register_stage(proposal) }) unless pipeline.failed?
 
             proposal.transition!(pipeline.complete? ? :passing : :build_failed)
+            persist_proposal(proposal)
             log.info "[mind_growth:builder] #{proposal.name}: #{pipeline.stage}"
             { success: pipeline.complete?, pipeline: pipeline.to_h, proposal: proposal.to_h }
           rescue ArgumentError => e
@@ -46,6 +48,12 @@ module Legion
             Runners::Proposer.get_proposal_object(proposal_id)
           end
 
+          def persist_proposal(proposal)
+            return unless defined?(Runners::Proposer) && Runners::Proposer.respond_to?(:persist_proposal)
+
+            Runners::Proposer.persist_proposal(proposal)
+          end
+
           def run_stage(pipeline, stage, callable)
             return if pipeline.stage != stage
 
@@ -59,13 +67,21 @@ module Legion
           end
 
           def strip_lex_prefix(name)
-            name.to_s.sub(/\Alex-/, '')
+            name.to_s.delete_prefix('lex-')
+          end
+
+          def proposal_id_for(proposal)
+            proposal.id if proposal.respond_to?(:id)
           end
 
           # --- Scaffold Stage ---
           # Delegates to lex-codegen when loaded; stubs otherwise
           def scaffold_stage(proposal, base_path)
-            return { success: true, stage: :scaffold, files: 0, message: 'scaffold requires lex-codegen' } unless codegen_available?
+            unless codegen_available?
+              return { success: true, stage: :scaffold, files: 0, message: 'scaffold requires lex-codegen',
+                       proposal_id: proposal_id_for(proposal),
+                       path: ext_path(proposal, base_path) }
+            end
 
             name = strip_lex_prefix(proposal.name)
             result = Legion::Extensions::Codegen::Runners::Generate.scaffold_extension(
@@ -79,14 +95,18 @@ module Legion
             )
 
             { success: result[:success], stage: :scaffold, files: result[:files_created] || 0,
-              path: result[:path], error: result[:error] }
+              path: result[:path] || ext_path(proposal, base_path), error: result[:error],
+              proposal_id: proposal_id_for(proposal) }
           end
 
           # --- Implement Stage ---
           # Delegates to lex-codegen FromGap when loaded; falls back to legion-llm; stubs otherwise
           def implement_stage(proposal, base_path)
             unless llm_available? || codegen_from_gap_available?
-              return { success: true, stage: :implement, message: 'implementation requires legion-llm or lex-codegen' }
+              return { success: true, stage: :implement,
+                       message: 'implementation requires legion-llm or lex-codegen',
+                       proposal_id: proposal_id_for(proposal),
+                       path: ext_path(proposal, base_path) }
             end
 
             path = ext_path(proposal, base_path)
@@ -94,7 +114,9 @@ module Legion
 
             if target_files.empty?
               return { success: true, stage: :implement, files_implemented: 0,
-                       message: 'no implementation targets found' }
+                       message: 'no implementation targets found',
+                       proposal_id: proposal_id_for(proposal),
+                       path: path }
             end
 
             files_implemented = 0
@@ -111,43 +133,64 @@ module Legion
 
             success = errors.empty?
             { success: success, stage: :implement, files_implemented: files_implemented,
-              total_files: target_files.size, error: success ? nil : errors.join('; ') }
+              total_files: target_files.size, error: success ? nil : errors.join('; '),
+              proposal_id: proposal_id_for(proposal),
+              path: path }
           end
 
           # --- Test Stage ---
           # Delegates to lex-exec bundler runners when loaded; stubs otherwise
           def test_stage(proposal, base_path)
-            return { success: true, stage: :test, message: 'testing requires lex-exec' } unless exec_available?
-
-            path = ext_path(proposal, base_path)
+            unless exec_available?
+              return { success: true, stage: :test, message: 'testing requires lex-exec',
+                       proposal_id: proposal_id_for(proposal),
+                       path: ext_path(proposal, base_path) }
+            end
 
+            path    = ext_path(proposal, base_path)
+            pid     = proposal_id_for(proposal)
             install = Legion::Extensions::Exec::Runners::Bundler.install(path: path)
             unless install[:success]
               return { success: false, stage: :test, step: :install,
-                       error: install[:stderr] || install[:error] }
+                       error: install[:stderr] || install[:error],
+                       proposal_id: pid, path: path }
             end
 
+            run_test_suite(path: path, pid: pid)
+          end
+
+          def run_test_suite(path:, pid:)
             rspec   = Legion::Extensions::Exec::Runners::Bundler.exec_rspec(path: path)
             rubocop = Legion::Extensions::Exec::Runners::Bundler.exec_rubocop(path: path)
 
             rspec_ok   = rspec[:success] && (rspec.dig(:parsed, :failures) || 0).zero?
             rubocop_ok = rubocop[:success]
 
-            errors = [
-              (rspec_ok ? nil : "rspec: #{rspec[:parsed] || rspec[:stderr]}"),
-              (rubocop_ok ? nil : "rubocop: #{rubocop[:parsed] || rubocop[:stderr]}")
-            ].compact.join('; ')
+            errors = build_test_errors(rspec: rspec, rubocop: rubocop, rspec_ok: rspec_ok, rubocop_ok: rubocop_ok)
 
             { success: rspec_ok && rubocop_ok, stage: :test,
               rspec: rspec[:parsed] || { raw: rspec[:stdout] },
               rubocop: rubocop[:parsed] || { raw: rubocop[:stdout] },
-              error: errors.empty? ? nil : errors }
+              error: errors.empty? ? nil : errors,
+              proposal_id: pid,
+              path: path }
+          end
+
+          def build_test_errors(rspec:, rubocop:, rspec_ok:, rubocop_ok:)
+            [
+              (rspec_ok ? nil : "rspec: #{rspec[:parsed] || rspec[:stderr]}"),
+              (rubocop_ok ? nil : "rubocop: #{rubocop[:parsed] || rubocop[:stderr]}")
+            ].compact.join('; ')
           end
 
           # --- Validate Stage ---
           # Delegates to lex-codegen validators when loaded; stubs otherwise
           def validate_stage(proposal, base_path)
-            return { success: true, stage: :validate, message: 'validation requires lex-codegen' } unless codegen_available?
+            unless codegen_available?
+              return { success: true, stage: :validate, message: 'validation requires lex-codegen',
+                       proposal_id: proposal_id_for(proposal),
+                       path: ext_path(proposal, base_path) }
+            end
 
             path      = ext_path(proposal, base_path)
             structure = Legion::Extensions::Codegen::Runners::Validate.validate_structure(path: path)
@@ -155,13 +198,19 @@ module Legion
 
             valid = structure[:valid] && gemspec[:valid]
             { success: valid, stage: :validate, structure: structure, gemspec: gemspec,
-              error: valid ? nil : "structure: #{structure[:missing]}, gemspec: #{gemspec[:issues]}" }
+              error: valid ? nil : "structure: #{structure[:missing]}, gemspec: #{gemspec[:issues]}",
+              proposal_id: proposal_id_for(proposal),
+              path: path }
           end
 
           # --- Register Stage ---
           # Delegates to lex-metacognition registry when loaded; stubs otherwise
           def register_stage(proposal)
-            return { success: true, stage: :register, message: 'registration requires lex-metacognition registry' } unless registry_available?
+            unless registry_available?
+              return { success: true, stage: :register,
+                       message: 'registration requires lex-metacognition registry',
+                       proposal_id: proposal_id_for(proposal) }
+            end
 
             result = Legion::Extensions::Metacognition::Runners::Registry.register_extension(
               name:        proposal.name,
@@ -170,7 +219,8 @@ module Legion
               description: proposal.description
             )
 
-            { success: result[:success], stage: :register, error: result[:error] }
+            { success: result[:success], stage: :register, error: result[:error],
+              proposal_id: proposal_id_for(proposal) }
           end
 
           # --- LLM implementation helpers ---
@@ -205,7 +255,7 @@ module Legion
           def legacy_implement_file(file_path, proposal)
             stub_content = ::File.read(file_path)
 
-            chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning })
+            chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning }) # rubocop:disable Legion/HelperMigration/DirectLlm
             chat.with_instructions(implementation_instructions)
             response = chat.ask(file_implementation_prompt(stub_content, proposal))
             code = extract_ruby_code(response.content)

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

@@ -7,7 +7,8 @@ module Legion
         module CompetitiveEvolver
           extend self
 
-          COMPETITION_STATUSES = %i[pending active evaluating decided cancelled].freeze
+          COMPETITION_STATUSES  = %i[pending active evaluating decided cancelled].freeze
+          ACTIVE_STATUSES       = %i[pending active evaluating].freeze
           MIN_TRIAL_ITERATIONS = 10
 
           def create_competition(gap:, proposal_ids:, **)
@@ -108,7 +109,7 @@ module Legion
           end
 
           def active_competitions(**)
-            comps = all_competitions.select { |c| %i[pending active evaluating].include?(c[:status]) }
+            comps = all_competitions.select { |c| ACTIVE_STATUSES.include?(c[:status]) }
             { success: true, competitions: comps.map { |c| { id: c[:id], gap: c[:gap], status: c[:status] } },
               count: comps.size }
           end

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Composer
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
           extend self
 
@@ -108,7 +108,7 @@ module Legion
           def suggest_with_llm(extensions)
             suggestions = heuristic_suggestions(extensions)
             { success: true, suggestions: suggestions, count: suggestions.size }
-          rescue StandardError
+          rescue StandardError => _e
             { success: true, suggestions: [], count: 0 }
           end
         end