lex-mind-growth 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 811a3676ca7c7fd4168c30606006adeca6020be69398bb94128130ab6da89c34
-  data.tar.gz: c40ec71e46d799b65100fa378c8840ca55579147159bd39eee9a8b6858b6ab97
+  metadata.gz: 3749e6e3fd39af6abe591e437da33b0c159db29b6e3463bd96dfb46f17b65d47
+  data.tar.gz: c702f090f36a6279fcded74bc19fccfa16cf8149d549d2603d0d38ed8b706432
 SHA512:
-  metadata.gz: 997b9b014e37450333f475b4dd2ab8c70cc4bf7cd355d5cbc73a9873aa73dae4b7394b925f61cd97b9a8102ca038e0b6902bf32bee1a86b119b93f745380d8a7
-  data.tar.gz: 4765d190fee92ce1c98e20a40955fa85521adc98dfe2b4013817fd4a01b7b4e18348323e665cafc605967196c367180f157cf28894ca70b089a955fb2cb470ef
+  metadata.gz: 5a70ad32a8ca26d122eae4d6e176d3d680f8943c08fa9c74379e3e03bbc99f1f7663b1b0abf6ecb5ef3d06f997107fd2c3d04d48ab32306f458a78419f92e39d
+  data.tar.gz: 9861dfcd32bad6bcb08b398be0a1a1fc3e3f564e2cb8d17a58cb30cdd43218d1ce1600c7d2f0af559f38c0ce5868f639e14fb59f8dc00fd6ac13b551770cb197

data/Gemfile

@@ -12,8 +12,7 @@ group :test do
   gem 'simplecov'
 end
 
-gem 'legion-llm', path: '../../legion-llm', require: false
-gem 'lex-codegen', path: '../../extensions-core/lex-codegen', require: false
-gem 'lex-exec', path: '../../extensions-core/lex-exec', require: false
-
-gem 'legion-gaia', path: '../../legion-gaia'
+gem 'legion-gaia', path: '../../legion-gaia' if File.directory?(File.expand_path('../../legion-gaia', __dir__))
+gem 'legion-llm', path: '../../legion-llm', require: false if File.directory?(File.expand_path('../../legion-llm', __dir__))
+gem 'lex-codegen', path: '../../extensions-core/lex-codegen', require: false if File.directory?(File.expand_path('../../extensions-core/lex-codegen', __dir__))
+gem 'lex-exec', path: '../../extensions-core/lex-exec', require: false if File.directory?(File.expand_path('../../extensions-core/lex-exec', __dir__))

data/lex-mind-growth.gemspec

@@ -25,5 +25,13 @@ Gem::Specification.new do |spec|
     Dir.glob('{lib,spec}/**/*') + %w[lex-mind-growth.gemspec Gemfile LICENSE]
   end
   spec.require_paths = ['lib']
-  spec.add_development_dependency 'legion-gaia'
+  spec.add_dependency 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
+
+  spec.add_development_dependency 'legion-gaia', '>= 0.9.9'
 end

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

@@ -21,6 +21,12 @@ module Legion
           def advance!(result)
             return if complete? || failed?
 
+            if timed_out?
+              @errors << { stage: @stage, error: 'build timeout exceeded', at: Time.now.utc }
+              @stage = :failed
+              return
+            end
+
             if result[:success]
               @artifacts[@stage] = result
               next_idx      = STAGES.index(@stage) + 1
@@ -40,6 +46,10 @@ module Legion
             @stage == :failed
           end
 
+          def timed_out?
+            duration_ms >= Helpers::Constants::BUILD_TIMEOUT_MS
+          end
+
           def to_h
             {
               proposal_id:  @proposal.id,

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module PhaseAllocator
+          # Maps cognitive categories to GAIA tick phases
+          CATEGORY_PHASE_MAP = {
+            perception:    :sensory_processing,
+            attention:     :sensory_processing,
+            emotion:       :emotional_evaluation,
+            affect:        :emotional_evaluation,
+            memory:        :memory_retrieval,
+            knowledge:     :knowledge_retrieval,
+            identity:      :identity_entropy_check,
+            cognition:     :working_memory_integration,
+            reasoning:     :working_memory_integration,
+            safety:        :procedural_check,
+            defense:       :procedural_check,
+            prediction:    :prediction_engine,
+            inference:     :prediction_engine,
+            communication: :mesh_interface,
+            social:        :mesh_interface,
+            coordination:  :mesh_interface,
+            motivation:    :action_selection,
+            executive:     :action_selection,
+            learning:      :memory_consolidation,
+            consolidation: :memory_consolidation,
+            introspection: :post_tick_reflection,
+            self:          :post_tick_reflection,
+            reflection:    :post_tick_reflection
+          }.freeze
+
+          # Dream cycle phase mappings
+          DREAM_PHASE_MAP = {
+            memory:        :memory_audit,
+            association:   :association_walk,
+            conflict:      :contradiction_resolution,
+            curiosity:     :agenda_formation,
+            consolidation: :consolidation_commit,
+            knowledge:     :knowledge_promotion,
+            reflection:    :dream_reflection,
+            narrative:     :dream_narration
+          }.freeze
+
+          # Maps method name substrings to inferred GAIA phases for unknown categories
+          METHOD_INFERENCE_MAP = [
+            [%w[filter sense detect], :sensory_processing],
+            [%w[predict forecast estimate],      :prediction_engine],
+            [%w[reflect evaluate assess],        :post_tick_reflection],
+            [%w[store retrieve recall],          :memory_retrieval],
+            [%w[decide select choose],           :action_selection]
+          ].freeze
+
+          module_function
+
+          def allocate_phase(category:, runner_methods: [])
+            category_sym = category.to_s.downcase.to_sym
+
+            # Check active phases first
+            phase = CATEGORY_PHASE_MAP[category_sym]
+            return { phase: phase, cycle: :active, confidence: :high } if phase
+
+            # Try to infer from runner method names
+            inferred = infer_from_methods(runner_methods)
+            return inferred if inferred
+
+            # Default to working_memory_integration (safest catch-all)
+            { phase: :working_memory_integration, cycle: :active, confidence: :low }
+          end
+
+          def allocate_dream_phase(category:)
+            category_sym = category.to_s.downcase.to_sym
+            phase = DREAM_PHASE_MAP[category_sym]
+            return { phase: phase, cycle: :dream, confidence: :high } if phase
+
+            nil
+          end
+
+          def infer_from_methods(methods)
+            method_names = methods.map(&:to_s)
+            match = METHOD_INFERENCE_MAP.find do |keywords, _phase|
+              method_names.any? { |m| keywords.any? { |kw| m.include?(kw) } }
+            end
+            return nil unless match
+
+            { phase: match[1], cycle: :active, confidence: :medium }
+          end
+
+          def valid_phase?(phase)
+            CATEGORY_PHASE_MAP.values.include?(phase) || DREAM_PHASE_MAP.values.include?(phase)
+          end
+
+          def phases_for_category(category)
+            category_sym = category.to_s.downcase.to_sym
+            results = []
+            results << CATEGORY_PHASE_MAP[category_sym] if CATEGORY_PHASE_MAP.key?(category_sym)
+            results << DREAM_PHASE_MAP[category_sym] if DREAM_PHASE_MAP.key?(category_sym)
+            results.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,9 @@ 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)
+
           extend self
 
           def build_extension(proposal_id:, base_path: nil, **)
@@ -22,7 +25,7 @@ module Legion
             run_stage(pipeline, :register,  -> { register_stage(proposal) }) unless pipeline.failed?
 
             proposal.transition!(pipeline.complete? ? :passing : :build_failed)
-            Legion::Logging.info "[mind_growth:builder] #{proposal.name}: #{pipeline.stage}" if defined?(Legion::Logging)
+            log.info "[mind_growth:builder] #{proposal.name}: #{pipeline.stage}"
             { success: pipeline.complete?, pipeline: pipeline.to_h, proposal: proposal.to_h }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -178,7 +181,7 @@ module Legion
           def implement_file(file_path, proposal)
             stub_content = ::File.read(file_path)
 
-            chat = Legion::LLM.chat
+            chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning })
             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/integration_tester.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module IntegrationTester
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          TICK_BUDGET_MS = 5000
+
+          def test_extension_in_tick(ext_module:, runner_module:, fn:, phase:, test_args: {}, **) # rubocop:disable Naming/MethodParameterName
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            runner_class = resolve_runner_class(ext_module, runner_module)
+            return { success: false, reason: :runner_not_found } unless runner_class
+
+            # Test 1: Method exists and is callable
+            method_check = test_method_callable(runner_class, fn)
+            return method_check unless method_check[:success]
+
+            # Test 2: Method returns valid response hash
+            response_check = test_valid_response(runner_class, fn, test_args)
+            return response_check unless response_check[:success]
+
+            # Test 3: Method completes within budget
+            perf_check = test_performance(runner_class, fn, test_args)
+
+            {
+              success:         true,
+              method_callable: method_check[:success],
+              valid_response:  response_check[:success],
+              performance:     perf_check,
+              phase:           phase
+            }
+          rescue StandardError => e
+            { success: false, reason: :exception, error: e.message }
+          end
+
+          def benchmark_tick(with_extension: nil, iterations: 5, **)
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            timings = iterations.times.map do
+              start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+              Legion::Gaia.heartbeat if Legion::Gaia.respond_to?(:heartbeat)
+              finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+              ((finish - start) * 1000).round(2)
+            end
+
+            {
+              success:        true,
+              with_extension: with_extension,
+              iterations:     iterations,
+              avg_ms:         (timings.sum / timings.size).round(2),
+              max_ms:         timings.max,
+              min_ms:         timings.min,
+              within_budget:  timings.max <= TICK_BUDGET_MS
+            }
+          rescue StandardError => e
+            { success: false, reason: :benchmark_failed, error: e.message }
+          end
+
+          private
+
+          def gaia_available?
+            defined?(Legion::Gaia)
+          end
+
+          def resolve_runner_class(ext_module, runner_module)
+            return nil unless defined?(Legion::Gaia::PhaseWiring)
+
+            Legion::Gaia::PhaseWiring.resolve_runner_class(ext_module.to_sym, runner_module.to_sym)
+          end
+
+          def test_method_callable(runner_class, fn) # rubocop:disable Naming/MethodParameterName
+            if runner_class.method_defined?(fn) || runner_class.respond_to?(fn)
+              { success: true, method: fn }
+            else
+              { success: false, reason: :method_not_defined, method: fn }
+            end
+          end
+
+          def test_valid_response(runner_class, fn, args) # rubocop:disable Naming/MethodParameterName
+            host = Object.new.extend(runner_class)
+            result = host.send(fn, **args)
+
+            if result.is_a?(Hash)
+              { success: true, response_type: :hash, keys: result.keys }
+            elsif result.nil?
+              { success: true, response_type: :nil }
+            else
+              { success: true, response_type: result.class.name }
+            end
+          rescue StandardError => e
+            { success: false, reason: :invocation_error, error: e.message }
+          end
+
+          def test_performance(runner_class, fn, args) # rubocop:disable Naming/MethodParameterName
+            host = Object.new.extend(runner_class)
+            start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            host.send(fn, **args)
+            finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            duration_ms = ((finish - start) * 1000).round(2)
+
+            { duration_ms: duration_ms, within_budget: duration_ms <= TICK_BUDGET_MS }
+          rescue StandardError => e
+            { duration_ms: nil, error: e.message, within_budget: false }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,9 @@ 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)
+
           extend self
 
           def run_growth_cycle(existing_extensions: nil, base_path: nil, max_proposals: 3, force: false, **)
@@ -165,11 +168,9 @@ module Legion
           end
 
           def log_cycle_summary(trace)
-            return unless defined?(Legion::Logging)
-
             build_step = trace[:steps].find { |s| s[:step] == :build }
             succeeded = build_step ? build_step[:succeeded] : 0
-            Legion::Logging.info "[mind_growth:orchestrator] cycle complete: #{succeeded} extensions built"
+            log.info "[mind_growth:orchestrator] cycle complete: #{succeeded} extensions built"
           end
         end
       end

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

@@ -7,13 +7,16 @@ 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)
+
           extend self
 
           def analyze_gaps(existing_extensions: nil, **)
             extensions    = existing_extensions || current_extensions
             analysis      = Helpers::CognitiveModels.gap_analysis(extensions)
             recommendations = Helpers::CognitiveModels.recommend_from_gaps(analysis)
-            Legion::Logging.debug "[mind_growth:proposer] gap analysis: #{recommendations.size} recommendations" if defined?(Legion::Logging)
+            log.debug "[mind_growth:proposer] gap analysis: #{recommendations.size} recommendations"
             { success: true, models: analysis, recommendations: recommendations.first(10) }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -27,7 +30,7 @@ module Legion
 
             redundancy = check_redundancy(gem_name, desc)
             if redundancy[:redundant]
-              Legion::Logging.info "[mind_growth:proposer] rejected redundant: #{gem_name} (#{redundancy[:score]})" if defined?(Legion::Logging)
+              log.info "[mind_growth:proposer] rejected redundant: #{gem_name} (#{redundancy[:score]})"
               return { success: false, error: :redundant, similar_to: redundancy[:similar_to],
                        score: redundancy[:score] }
             end
@@ -46,7 +49,7 @@ module Legion
               origin:         :manual
             )
             proposal_store.store(proposal)
-            Legion::Logging.info "[mind_growth:proposer] proposed: #{proposal.name} (#{cat})" if defined?(Legion::Logging)
+            log.info "[mind_growth:proposer] proposed: #{proposal.name} (#{cat})"
             { success: true, proposal: proposal.to_h }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -58,7 +61,7 @@ module Legion
 
             eval_scores = scores || score_with_llm(proposal) || default_scores
             proposal.evaluate!(eval_scores)
-            Legion::Logging.info "[mind_growth:proposer] evaluated #{proposal.name}: #{proposal.status}" if defined?(Legion::Logging)
+            log.info "[mind_growth:proposer] evaluated #{proposal.name}: #{proposal.status}"
             { success: true, proposal: proposal.to_h, approved: proposal.status == :approved,
               auto_approved: proposal.auto_approvable? }
           rescue ArgumentError => e
@@ -114,10 +117,11 @@ module Legion
           def enrich_proposal(name, category, description)
             return {} unless llm_available?
 
-            response = Legion::LLM.chat.ask(enrichment_prompt(name, category, description))
+            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose',
+phase: 'capability' }).ask(enrichment_prompt(name, category, description))
             parse_enrichment(response.content)
           rescue StandardError => e
-            Legion::Logging.debug "[mind_growth:proposer] LLM enrichment failed: #{e.message}" if defined?(Legion::Logging)
+            log.debug "[mind_growth:proposer] LLM enrichment failed: #{e.message}"
             {}
           end
 
@@ -158,10 +162,10 @@ module Legion
           def score_with_llm(proposal)
             return nil unless llm_available?
 
-            response = Legion::LLM.chat.ask(scoring_prompt(proposal))
+            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose', phase: 'score' }).ask(scoring_prompt(proposal))
             parse_scores(response.content)
           rescue StandardError => e
-            Legion::Logging.debug "[mind_growth:proposer] LLM scoring failed: #{e.message}" if defined?(Legion::Logging)
+            log.debug "[mind_growth:proposer] LLM scoring failed: #{e.message}"
             nil
           end
 
@@ -221,10 +225,11 @@ module Legion
             return nil unless llm_available?
 
             candidates = existing.last(20).map { |p| { name: p.name, description: p.description } }
-            response = Legion::LLM.chat.ask(redundancy_prompt(name, description, candidates))
+            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose',
+phase: 'validate' }).ask(redundancy_prompt(name, description, candidates))
             parse_redundancy(response.content)
           rescue StandardError => e
-            Legion::Logging.debug "[mind_growth:proposer] LLM redundancy check failed: #{e.message}" if defined?(Legion::Logging)
+            log.debug "[mind_growth:proposer] LLM redundancy check failed: #{e.message}"
             nil
           end
 

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Wirer
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          def analyze_fit(extension_name:, category:, runner_module: nil, runner_methods: [], **) # rubocop:disable Lint/UnusedMethodArgument
+            allocation = Helpers::PhaseAllocator.allocate_phase(
+              category:       category,
+              runner_methods: runner_methods
+            )
+
+            dream_allocation = Helpers::PhaseAllocator.allocate_dream_phase(category: category)
+
+            {
+              success:        true,
+              extension:      extension_name,
+              active_phase:   allocation,
+              dream_phase:    dream_allocation,
+              recommendation: build_recommendation(allocation, dream_allocation)
+            }
+          end
+
+          def wire_extension(extension_name:, ext_module:, runner_module:, fn:, phase:, **) # rubocop:disable Naming/MethodParameterName
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+            return { success: false, reason: :invalid_phase } unless Helpers::PhaseAllocator.valid_phase?(phase)
+
+            # Verify the runner class exists and has the method
+            runner_class = resolve_runner(ext_module: ext_module, runner_module: runner_module)
+            return { success: false, reason: :runner_not_found } unless runner_class
+
+            return { success: false, reason: :method_not_found, method: fn } unless runner_class.method_defined?(fn) || runner_class.respond_to?(fn)
+
+            # Record the wiring in our registry
+            wiring_registry[extension_name] = {
+              ext_module:    ext_module,
+              runner_module: runner_module,
+              fn:            fn,
+              phase:         phase,
+              wired_at:      Time.now,
+              enabled:       true
+            }
+
+            # Trigger GAIA rediscovery to pick up the new wiring
+            rediscover_result = trigger_rediscovery
+
+            {
+              success:     true,
+              extension:   extension_name,
+              phase:       phase,
+              fn:          fn,
+              rediscovery: rediscover_result
+            }
+          end
+
+          def unwire_extension(extension_name:, **)
+            entry = wiring_registry.delete(extension_name)
+            return { success: false, reason: :not_wired } unless entry
+
+            trigger_rediscovery
+
+            { success: true, extension: extension_name, unwired_phase: entry[:phase] }
+          end
+
+          def disable_extension(extension_name:, **)
+            entry = wiring_registry[extension_name]
+            return { success: false, reason: :not_wired } unless entry
+
+            entry[:enabled] = false
+            { success: true, extension: extension_name, status: :disabled }
+          end
+
+          def enable_extension(extension_name:, **)
+            entry = wiring_registry[extension_name]
+            return { success: false, reason: :not_wired } unless entry
+
+            entry[:enabled] = true
+            trigger_rediscovery
+            { success: true, extension: extension_name, status: :enabled }
+          end
+
+          def wiring_status(**)
+            {
+              success:       true,
+              wired_count:   wiring_registry.size,
+              enabled_count: wiring_registry.count { |_, v| v[:enabled] },
+              extensions:    wiring_registry.transform_values { |v| v.slice(:phase, :fn, :enabled, :wired_at) }
+            }
+          end
+
+          def rewire_all(**)
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            result = trigger_rediscovery
+            { success: true, rediscovery: result }
+          end
+
+          private
+
+          def gaia_available?
+            defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:registry)
+          end
+
+          def resolve_runner(ext_module:, runner_module:)
+            return nil unless defined?(Legion::Gaia::PhaseWiring)
+
+            Legion::Gaia::PhaseWiring.resolve_runner_class(ext_module.to_sym, runner_module.to_sym)
+          end
+
+          def trigger_rediscovery
+            return { rediscovered: false, reason: :gaia_not_available } unless gaia_available?
+
+            Legion::Gaia.registry.rediscover
+          rescue StandardError => e
+            { rediscovered: false, error: e.message }
+          end
+
+          def wiring_registry
+            @wiring_registry ||= {}
+          end
+
+          def build_recommendation(active_alloc, dream_alloc)
+            parts = []
+            parts << case active_alloc[:confidence]
+                     when :high
+                       "Wire to #{active_alloc[:phase]} (high confidence)"
+                     when :medium
+                       "Suggest #{active_alloc[:phase]} (medium confidence, verify manually)"
+                     else
+                       "Default to #{active_alloc[:phase]} (low confidence, manual review recommended)"
+                     end
+            parts << "Also wire dream phase: #{dream_alloc[:phase]}" if dream_alloc
+            parts.join('. ')
+          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.0'
+      VERSION = '0.1.5'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -9,11 +9,14 @@ require 'legion/extensions/mind_growth/helpers/proposal_store'
 require 'legion/extensions/mind_growth/helpers/cognitive_models'
 require 'legion/extensions/mind_growth/helpers/build_pipeline'
 require 'legion/extensions/mind_growth/helpers/fitness_evaluator'
+require 'legion/extensions/mind_growth/helpers/phase_allocator'
 require 'legion/extensions/mind_growth/runners/proposer'
 require 'legion/extensions/mind_growth/runners/analyzer'
 require 'legion/extensions/mind_growth/runners/builder'
 require 'legion/extensions/mind_growth/runners/validator'
 require 'legion/extensions/mind_growth/runners/orchestrator'
+require 'legion/extensions/mind_growth/runners/wirer'
+require 'legion/extensions/mind_growth/runners/integration_tester'
 require 'legion/extensions/mind_growth/client'
 
 module Legion

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

@@ -118,6 +118,35 @@ RSpec.describe Legion::Extensions::MindGrowth::Helpers::BuildPipeline do
     end
   end
 
+  describe '#timed_out?' do
+    it 'returns false when within time budget' do
+      expect(pipeline.timed_out?).to be false
+    end
+
+    it 'returns true when duration exceeds BUILD_TIMEOUT_MS' do
+      pipeline.instance_variable_set(:@started_at, Time.now.utc - 700)
+      expect(pipeline.timed_out?).to be true
+    end
+
+    it 'transitions to failed on advance! when timed out' do
+      pipeline.instance_variable_set(:@started_at, Time.now.utc - 700)
+      pipeline.advance!({ success: true })
+      expect(pipeline.stage).to eq(:failed)
+    end
+
+    it 'records timeout error message' do
+      pipeline.instance_variable_set(:@started_at, Time.now.utc - 700)
+      pipeline.advance!({ success: true })
+      expect(pipeline.errors.last[:error]).to eq('build timeout exceeded')
+    end
+
+    it 'records the stage where timeout occurred' do
+      pipeline.instance_variable_set(:@started_at, Time.now.utc - 700)
+      pipeline.advance!({ success: true })
+      expect(pipeline.errors.last[:stage]).to eq(:scaffold)
+    end
+  end
+
   describe '#complete?' do
     it 'returns false initially' do
       expect(pipeline.complete?).to be false