lex-mind-growth 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ee2be00d683bb637298c7cd47ade31afe6164e69d00d032577ede07a85e23c7
-  data.tar.gz: aa60548111e18409e2cf09476e8e37cfa9bd4eb8912a57e174b41d6c1e80bfb0
+  metadata.gz: e8f21cd00a0fb432c27fd057addf7294b2d84425c7927d6298bab0c87496d868
+  data.tar.gz: c0a512a778e049b13d5442ab3f72bf513ce5104bc0be3632891eda965b1fa668
 SHA512:
-  metadata.gz: 3f82c6da963f5ff2eea9a603e0b1c509ac643ebac93039bff7855cb3c673f927153e664412dc1ecf97bed571102793ecd3ac0859f58c55ce159e596ca82cb532
-  data.tar.gz: 2c8517423557a7e7c77c2c76b2ac8adbdddb08e3570d1eb430ba25b479b7da664d39af19f6f7800e2200f33af53d475b25c44a5bfb35ff93ab44631e613507f5
+  metadata.gz: f772d447b870acf41484209df88a82352e4b27b00a7f30335dfb0b5fee1e26c6cc7b06d6194aaf46d2d7506e55cb7e5d264aa9b005872db00c632f3caea1a4bf
+  data.tar.gz: d4aee3639b1cec1a35015c9a432cb7041715bd3f3ad0571534a9d441ce11e79481a6361e72295076fb06605cc2afd357805e385ff04bf28503302c7f003bcbd5

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

@@ -12,7 +12,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

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/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
 
@@ -59,13 +59,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 +87,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 +106,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 +125,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 +190,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 +211,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 +247,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

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

@@ -9,6 +9,7 @@ module Legion
 
           CONSENSUS_THRESHOLD               = 0.67
           DISAGREEMENT_ESCALATION_THRESHOLD = 0.5
+          DECIDED_CONSENSUSES               = %i[approved rejected].freeze
 
           def propose_to_swarm(charter_id:, proposal_id:, proposer_agent_id:, **)
             if swarm_available?
@@ -52,8 +53,8 @@ module Legion
           def tally_swarm_votes(charter_id:, proposal_id:, **)
             votes = fetch_votes(charter_id, proposal_id)
 
-            approve_count = votes.count { |v| [:approve, 'approve'].include?(v[:vote]) }
-            reject_count  = votes.count { |v| [:reject, 'reject'].include?(v[:vote]) }
+            approve_count = votes.count { |v| v[:vote].to_s == 'approve' }
+            reject_count  = votes.count { |v| v[:vote].to_s == 'reject' }
             total         = votes.size
 
             consensus = if !total.zero? && (approve_count.to_f / total) >= CONSENSUS_THRESHOLD
@@ -95,7 +96,7 @@ module Legion
               record = { proposal_id: pid, consensus: tally[:consensus],
                          approve_count: tally[:approve_count], reject_count: tally[:reject_count] }
 
-              if %i[approved rejected].include?(tally[:consensus])
+              if DECIDED_CONSENSUSES.include?(tally[:consensus])
                 decided << record
               else
                 pending << record

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Dashboard
-          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)
 
           module_function
 

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module DreamIdeation
-          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
 

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

@@ -5,19 +5,20 @@ module Legion
     module MindGrowth
       module Runners
         module Evolver
-          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
 
-          BOTTOM_PERCENTILE = 0.05
+          BOTTOM_PERCENTILE          = 0.05
           SPECIATION_DRIFT_THRESHOLD = 0.5
+          INELIGIBLE_STATUSES        = %i[building testing].freeze
 
           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) }
+            eligible = exts.reject { |e| INELIGIBLE_STATUSES.include?((e[:status] || :active).to_sym) }
             ranked   = Helpers::FitnessEvaluator.rank(eligible)
             bottom_n = ranked.last(count)
 
@@ -50,7 +51,7 @@ module Legion
             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-/, '')}"
+            merged = merged_name || "lex-merged-#{name_a.to_s.delete_prefix('lex-')}-#{name_b.to_s.delete_prefix('lex-')}"
             desc   = "Merged extension combining capabilities of #{name_a} and #{name_b}"
 
             proposal = Runners::Proposer.propose_concept(
@@ -126,11 +127,17 @@ module Legion
           end
 
           def llm_suggestions(name, fitness, weaknesses)
+            # rubocop:disable Legion/HelperMigration/DirectLlm
             response = Legion::LLM.chat(
-              caller: { extension: 'lex-mind-growth', operation: 'evolver', phase: 'suggest' }
+              caller: {
+                extension: 'lex-mind-growth',
+                operation: 'evolver',
+                phase:     'suggest'
+              }
             ).ask(improvement_prompt(name, fitness, weaknesses))
+            # rubocop:enable Legion/HelperMigration/DirectLlm
             parse_llm_suggestions(response.content)
-          rescue StandardError
+          rescue StandardError => _e
             nil
           end
 
@@ -151,7 +158,7 @@ module Legion
             return nil unless data.is_a?(Array)
 
             data.map(&:to_s).reject(&:empty?)
-          rescue ::JSON::ParserError
+          rescue ::JSON::ParserError => _e
             nil
           end
 

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Governance
-          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
 

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module IntegrationTester
-          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
 
@@ -42,8 +42,9 @@ module Legion
 
           def benchmark_tick(with_extension: nil, iterations: 5, **)
             return { success: false, reason: :gaia_not_available } unless gaia_available?
+            return { success: false, reason: :invalid_iterations, iterations: iterations } unless iterations.is_a?(Integer) && iterations >= 1
 
-            timings = iterations.times.map do
+            timings = Array.new(iterations) do
               start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
               Legion::Gaia.heartbeat if Legion::Gaia.respond_to?(:heartbeat)
               finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Monitor
-          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
 

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Orchestrator
-          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
 

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

@@ -7,8 +7,8 @@ module Legion
     module MindGrowth
       module Runners
         module Proposer
-          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
 
@@ -96,7 +96,7 @@ module Legion
           end
 
           def derive_module_name(gem_name)
-            gem_name.to_s.sub(/\Alex-/, '').split('-').map(&:capitalize).join
+            gem_name.to_s.delete_prefix('lex-').split('-').map(&:capitalize).join
           end
 
           def suggest_category
@@ -117,8 +117,15 @@ module Legion
           def enrich_proposal(name, category, description)
             return {} unless llm_available?
 
-            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose',
-phase: 'capability' }).ask(enrichment_prompt(name, category, description))
+            # rubocop:disable Legion/HelperMigration/DirectLlm
+            response = Legion::LLM.chat(
+              caller: {
+                extension: 'lex-mind-growth',
+                operation: 'propose',
+                phase:     'capability'
+              }
+            ).ask(enrichment_prompt(name, category, description))
+            # rubocop:enable Legion/HelperMigration/DirectLlm
             parse_enrichment(response.content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM enrichment failed: #{e.message}"
@@ -151,7 +158,7 @@ phase: 'capability' }).ask(enrichment_prompt(name, category, description))
                 { name: r[:name].to_s, params: Array(r[:params]).map(&:to_s), returns: r[:returns].to_s }
               end
             }
-          rescue ::JSON::ParserError, NoMethodError
+          rescue ::JSON::ParserError, NoMethodError => _e
             {}
           end
 
@@ -162,7 +169,7 @@ phase: 'capability' }).ask(enrichment_prompt(name, category, description))
           def score_with_llm(proposal)
             return nil unless llm_available?
 
-            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose', phase: 'score' }).ask(scoring_prompt(proposal))
+            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose', phase: 'score' }).ask(scoring_prompt(proposal)) # rubocop:disable Legion/HelperMigration/DirectLlm
             parse_scores(response.content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM scoring failed: #{e.message}"
@@ -203,7 +210,7 @@ phase: 'capability' }).ask(enrichment_prompt(name, category, description))
 
               [dim, val.to_f.clamp(0.0, 1.0)]
             end
-          rescue ::JSON::ParserError, NoMethodError
+          rescue ::JSON::ParserError, NoMethodError => _e
             nil
           end
 
@@ -225,8 +232,15 @@ phase: 'capability' }).ask(enrichment_prompt(name, category, description))
             return nil unless llm_available?
 
             candidates = existing.last(20).map { |p| { name: p.name, description: p.description } }
-            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose',
-phase: 'validate' }).ask(redundancy_prompt(name, description, candidates))
+            # rubocop:disable Legion/HelperMigration/DirectLlm
+            response = Legion::LLM.chat(
+              caller: {
+                extension: 'lex-mind-growth',
+                operation: 'propose',
+                phase:     'validate'
+              }
+            ).ask(redundancy_prompt(name, description, candidates))
+            # rubocop:enable Legion/HelperMigration/DirectLlm
             parse_redundancy(response.content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM redundancy check failed: #{e.message}"
@@ -264,7 +278,7 @@ phase: 'validate' }).ask(redundancy_prompt(name, description, candidates))
               similar_to: data[:similar_to],
               score:      score
             }
-          rescue ::JSON::ParserError, NoMethodError
+          rescue ::JSON::ParserError, NoMethodError => _e
             nil
           end
         end

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

@@ -5,19 +5,24 @@ module Legion
     module MindGrowth
       module Runners
         module Retrospective
-          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
 
+          BUILT_STATUSES       = %i[passing wired active].freeze
+          FAILED_STATUSES      = %i[build_failed rejected pruned].freeze
+          IN_PROGRESS_STATUSES = %i[proposed evaluating approved building testing].freeze
+          SUCCEEDED_STATUSES   = BUILT_STATUSES
+
           # Generates a summary of growth activity: proposals by status, recent builds, failures
           def session_report(**)
             proposals = Runners::Proposer.proposal_stats
             recent = Runners::Proposer.list_proposals(limit: 10)
 
-            built = recent[:proposals].select { |p| %i[passing wired active].include?(p[:status]) }
-            failed = recent[:proposals].select { |p| %i[build_failed rejected pruned].include?(p[:status]) }
-            in_progress = recent[:proposals].select { |p| %i[proposed evaluating approved building testing].include?(p[:status]) }
+            built       = recent[:proposals].select { |p| BUILT_STATUSES.include?(p[:status]) }
+            failed      = recent[:proposals].select { |p| FAILED_STATUSES.include?(p[:status]) }
+            in_progress = recent[:proposals].select { |p| IN_PROGRESS_STATUSES.include?(p[:status]) }
 
             {
               success:      true,
@@ -64,7 +69,7 @@ module Legion
 
             failed = proposals.select { |p| p[:status] == :build_failed }
             rejected = proposals.select { |p| p[:status] == :rejected }
-            succeeded = proposals.select { |p| %i[passing wired active].include?(p[:status]) }
+            succeeded = proposals.select { |p| SUCCEEDED_STATUSES.include?(p[:status]) }
 
             # Category success rates
             category_stats = compute_category_stats(proposals)
@@ -92,7 +97,7 @@ module Legion
           def compute_category_stats(proposals)
             by_category = proposals.group_by { |p| p[:category] }
             by_category.transform_values do |cat_proposals|
-              succeeded = cat_proposals.count { |p| %i[passing wired active].include?(p[:status]) }
+              succeeded = cat_proposals.count { |p| SUCCEEDED_STATUSES.include?(p[:status]) }
               {
                 total:        cat_proposals.size,
                 succeeded:    succeeded,

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module RiskAssessor
-          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
 

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

@@ -67,7 +67,7 @@ module Legion
                       when :integration_sweep   then execute_integration_sweep(charter_id)
                       end
 
-            { success: true, charter_type: charter_type, results: Array(results) }
+            { success: true, charter_id: charter_id, charter_type: charter_type, results: Array(results) }
           end
 
           def complete_build_swarm(charter_id:, outcome: :success, **)

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

@@ -5,8 +5,8 @@ module Legion
     module MindGrowth
       module Runners
         module Wirer
-          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
 

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.2.5'
+      VERSION = '0.2.7'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -34,7 +34,7 @@ require 'legion/extensions/mind_growth/client'
 module Legion
   module Extensions
     module MindGrowth
-      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core)
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core, false)
 
       def self.remote_invocable?
         false

data/spec/legion/extensions/mind_growth/actors/growth_cycle_spec.rb

@@ -68,8 +68,8 @@ RSpec.describe Legion::Extensions::MindGrowth::Actor::GrowthCycle do
   end
 
   describe '#check_subtask?' do
-    it 'returns false' do
-      expect(actor.check_subtask?).to be false
+    it 'returns true' do
+      expect(actor.check_subtask?).to be true
     end
   end
 

data/spec/legion/extensions/mind_growth/helpers/composition_map_spec.rb

@@ -235,7 +235,7 @@ RSpec.describe Legion::Extensions::MindGrowth::Helpers::CompositionMap do
 
   describe 'thread safety' do
     it 'records all rules when added concurrently' do
-      threads = 20.times.map do |i|
+      threads = Array.new(20) do |i|
         Thread.new do
           map.add_rule(source_extension: "lex-#{i}", output_key: :result,
                        target_extension: 'lex-target', target_method: :run)

data/spec/legion/extensions/mind_growth/helpers/proposal_store_spec.rb

@@ -160,7 +160,7 @@ RSpec.describe Legion::Extensions::MindGrowth::Helpers::ProposalStore do
     it 'evicts the oldest proposal when at capacity' do
       stub_const("#{described_class}::MAX_PROPOSALS", 3)
       small_store = described_class.new
-      proposals = 4.times.map do |i|
+      proposals = Array.new(4) do |i|
         Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
           name: "lex-evict-#{i}", module_name: "E#{i}", category: :cognition, description: "evict #{i}"
         )
@@ -188,7 +188,7 @@ RSpec.describe Legion::Extensions::MindGrowth::Helpers::ProposalStore do
 
   describe 'thread safety' do
     it 'handles concurrent stores without error' do
-      threads = 10.times.map do |i|
+      threads = Array.new(10) do |i|
         Thread.new do
           p = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
             name: "lex-thread-#{i}", module_name: "T#{i}", category: :cognition, description: "thread #{i}"

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

@@ -329,7 +329,7 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::CompetitiveEvolver do
 
   describe 'thread safety' do
     it 'handles concurrent competition creation' do
-      threads = 10.times.map do |i|
+      threads = Array.new(10) do |i|
         Thread.new { evolver.create_competition(gap: "gap-#{i}", proposal_ids: %w[a b]) }
       end
       results = threads.map(&:value)

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

@@ -154,7 +154,7 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Governance do
 
     context 'thread safety' do
       it 'records all votes when cast concurrently' do
-        threads = 10.times.map do |i|
+        threads = Array.new(10) do |i|
           Thread.new { governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "t#{i}") }
         end
         threads.each(&:join)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - Esity