lex-mind-growth 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40f7d638167956b7c52bd79a6946c7489ad677e2cf8ed0afd095530cf907ad08
-  data.tar.gz: 9054302975661892f60a91fa9d3b41eae764e8c48509d480b2242cc213b737c0
+  metadata.gz: '0855bf68cbc39002e5c08851edd6f3ce71afddb38f0633078a68d878fe954dec'
+  data.tar.gz: dc106552129f3d41f91711c51fca3b2a90a0198aede48d14b4d589c0b319fea0
 SHA512:
-  metadata.gz: e966570dcfdf4bd5b5e0d6ff1b176772e62d0cbe77d6f25cdb88dec1afe091fbf0a77791084476f1423b93407ef3ff1f4733af8c713241ef982331faff7974c2
-  data.tar.gz: c07d864de3b898050838da167d1ec9e65424291df54af05a0628ba46821591899e84898a45f406f4edc1131c90c93bd0c4da4ff779903cde73f3db54ac2a07b7
+  metadata.gz: 7d423da820af5d21f8b8f33f3c86850ae6cc6734d717386d31a862b800573694148626ade4587f5d2dbf10bafa14a61f0c973a2b1cefb1fe92817ef6c38527cd
+  data.tar.gz: 613aabc82f554a7de59965e8bb6a6543a72e346e74ea6618a6de65c15b4b40a2d2c4220230281dbf51e613aaa87d06b40738988627137244e9c7247229aef1be

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

@@ -30,6 +30,11 @@ module Legion
         # Orchestrator delegation
         def run_growth_cycle(**) = Runners::Orchestrator.run_growth_cycle(**)
         def growth_status(**)    = Runners::Orchestrator.growth_status(**)
+
+        # Retrospective delegation
+        def session_report(**)      = Runners::Retrospective.session_report(**)
+        def trend_analysis(**)      = Runners::Retrospective.trend_analysis(**)
+        def learning_extraction(**) = Runners::Retrospective.learning_extraction(**)
       end
     end
   end

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/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/retrospective.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Retrospective
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          # 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]) }
+
+            {
+              success:      true,
+              summary:      {
+                total_proposals: proposals[:stats][:total],
+                by_status:       proposals[:stats][:by_status],
+                recent_built:    built.map { |p| { id: p[:id], name: p[:name], status: p[:status] } },
+                recent_failed:   failed.map { |p| { id: p[:id], name: p[:name], status: p[:status] } },
+                in_progress:     in_progress.map { |p| { id: p[:id], name: p[:name], status: p[:status] } }
+              },
+              generated_at: Time.now.utc
+            }
+          end
+
+          # Tracks extension count, quality, coverage over time
+          # Returns snapshot metrics suitable for time-series storage
+          def trend_analysis(extensions: [], **)
+            profile = Runners::Analyzer.cognitive_profile(existing_extensions: extensions.empty? ? nil : extensions)
+            ranked = extensions.empty? ? [] : Helpers::FitnessEvaluator.rank(extensions)
+
+            avg_fitness = ranked.empty? ? 0.0 : (ranked.sum { |e| e[:fitness] } / ranked.size).round(3)
+            prune_count = ranked.count { |e| e[:fitness] < Helpers::Constants::PRUNE_THRESHOLD }
+            healthy_count = ranked.count { |e| e[:fitness] >= Helpers::Constants::IMPROVEMENT_THRESHOLD }
+
+            {
+              success:      true,
+              snapshot:     {
+                extension_count:        ranked.size,
+                overall_coverage:       profile[:overall_coverage],
+                model_coverage:         profile[:model_coverage]&.map { |m| { model: m[:model], coverage: m[:coverage] } },
+                avg_fitness:            avg_fitness,
+                healthy_extensions:     healthy_count,
+                prune_candidates:       prune_count,
+                improvement_candidates: ranked.size - healthy_count - prune_count
+              },
+              generated_at: Time.now.utc
+            }
+          end
+
+          # Identifies patterns from build failures to improve future LLM prompts
+          def learning_extraction(**)
+            all_proposals = Runners::Proposer.list_proposals(limit: 100)
+            proposals = all_proposals[:proposals]
+
+            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]) }
+
+            # Category success rates
+            category_stats = compute_category_stats(proposals)
+
+            # Extract patterns from failures
+            failure_patterns = extract_failure_patterns(failed)
+
+            {
+              success:      true,
+              learnings:    {
+                total_analyzed:     proposals.size,
+                success_rate:       proposals.empty? ? 0.0 : (succeeded.size.to_f / proposals.size).round(3),
+                rejection_rate:     proposals.empty? ? 0.0 : (rejected.size.to_f / proposals.size).round(3),
+                build_failure_rate: proposals.empty? ? 0.0 : (failed.size.to_f / proposals.size).round(3),
+                category_stats:     category_stats,
+                failure_patterns:   failure_patterns,
+                recommendations:    generate_recommendations(category_stats, failure_patterns)
+              },
+              generated_at: Time.now.utc
+            }
+          end
+
+          private
+
+          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]) }
+              {
+                total:        cat_proposals.size,
+                succeeded:    succeeded,
+                success_rate: cat_proposals.empty? ? 0.0 : (succeeded.to_f / cat_proposals.size).round(3)
+              }
+            end
+          end
+
+          def extract_failure_patterns(failed_proposals)
+            return [] if failed_proposals.empty?
+
+            # Group failures by category to identify problematic areas
+            by_category = failed_proposals.group_by { |p| p[:category] }
+            patterns = by_category.map do |category, proposals|
+              { category: category, failure_count: proposals.size,
+                names: proposals.map { |p| p[:name] } }
+            end
+            patterns.sort_by { |p| -p[:failure_count] }
+          end
+
+          def generate_recommendations(category_stats, failure_patterns)
+            recs = []
+
+            # Recommend avoiding categories with high failure rates
+            category_stats.each do |category, stats|
+              if stats[:total] >= 3 && stats[:success_rate] < 0.3
+                recs << { type: :avoid_category, category: category,
+                          reason: "low success rate (#{(stats[:success_rate] * 100).round}%)" }
+              end
+
+              # Recommend focus on categories with high success rates
+              if stats[:total] >= 3 && stats[:success_rate] > 0.8
+                recs << { type: :focus_category, category: category,
+                          reason: "high success rate (#{(stats[:success_rate] * 100).round}%)" }
+              end
+            end
+
+            # Flag recurring failure patterns
+            failure_patterns.each do |pattern|
+              if pattern[:failure_count] >= 3
+                recs << { type: :investigate_failures, category: pattern[:category],
+                          reason: "#{pattern[:failure_count]} build failures" }
+              end
+            end
+
+            recs
+          end
+        end
+      end
+    end
+  end
+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.4'
+      VERSION = '0.1.6'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -9,11 +9,15 @@ 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/runners/retrospective'
 require 'legion/extensions/mind_growth/client'
 
 module Legion