lex-mind-growth 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 811a3676ca7c7fd4168c30606006adeca6020be69398bb94128130ab6da89c34
+  data.tar.gz: c40ec71e46d799b65100fa378c8840ca55579147159bd39eee9a8b6858b6ab97
+SHA512:
+  metadata.gz: 997b9b014e37450333f475b4dd2ab8c70cc4bf7cd355d5cbc73a9873aa73dae4b7394b925f61cd97b9a8102ca038e0b6902bf32bee1a86b119b93f745380d8a7
+  data.tar.gz: 4765d190fee92ce1c98e20a40955fa85521adc98dfe2b4013817fd4a01b7b4e18348323e665cafc605967196c367180f157cf28894ca70b089a955fb2cb470ef

data/Gemfile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec', '~> 3.13'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec'
+  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'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LegionIO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lex-mind-growth.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/mind_growth/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-mind-growth'
+  spec.version       = Legion::Extensions::MindGrowth::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Mind Growth'
+  spec.description   = 'Autonomous cognitive architecture expansion for LegionIO'
+  spec.homepage      = 'https://github.com/LegionIO/lex-mind-growth'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = 'https://github.com/LegionIO/lex-mind-growth'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-mind-growth'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-mind-growth'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-mind-growth/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-mind-growth.gemspec Gemfile LICENSE]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Actor
+        class GrowthCycle < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::MindGrowth::Runners::Orchestrator
+          end
+
+          def runner_function
+            'run_growth_cycle'
+          end
+
+          def time
+            3600
+          end
+
+          def enabled?
+            codegen_loaded? || exec_loaded?
+          end
+
+          def run_now?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+
+          private
+
+          def codegen_loaded?
+            defined?(Legion::Extensions::Codegen)
+          end
+
+          def exec_loaded?
+            defined?(Legion::Extensions::Exec)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      class Client
+        def initialize; end
+
+        # Proposer delegation
+        def analyze_gaps(**)       = Runners::Proposer.analyze_gaps(**)
+        def propose_concept(**)    = Runners::Proposer.propose_concept(**)
+        def evaluate_proposal(**)  = Runners::Proposer.evaluate_proposal(**)
+        def list_proposals(**)     = Runners::Proposer.list_proposals(**)
+        def proposal_stats(**)     = Runners::Proposer.proposal_stats(**)
+
+        # Analyzer delegation
+        def cognitive_profile(**)    = Runners::Analyzer.cognitive_profile(**)
+        def identify_weak_links(**)  = Runners::Analyzer.identify_weak_links(**)
+        def recommend_priorities(**) = Runners::Analyzer.recommend_priorities(**)
+
+        # Builder delegation
+        def build_extension(**) = Runners::Builder.build_extension(**)
+        def build_status(**)    = Runners::Builder.build_status(**)
+
+        # Validator delegation
+        def validate_proposal(**) = Runners::Validator.validate_proposal(**)
+        def validate_scores(**)   = Runners::Validator.validate_scores(**)
+        def validate_fitness(**)  = Runners::Validator.validate_fitness(**)
+
+        # Orchestrator delegation
+        def run_growth_cycle(**) = Runners::Orchestrator.run_growth_cycle(**)
+        def growth_status(**)    = Runners::Orchestrator.growth_status(**)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        class BuildPipeline
+          STAGES = %i[scaffold implement test validate register complete failed].freeze
+
+          attr_reader :proposal, :stage, :errors, :artifacts, :started_at, :completed_at
+
+          def initialize(proposal)
+            @proposal     = proposal
+            @stage        = :scaffold
+            @errors       = []
+            @artifacts    = {}
+            @started_at   = Time.now.utc
+            @completed_at = nil
+          end
+
+          def advance!(result)
+            return if complete? || failed?
+
+            if result[:success]
+              @artifacts[@stage] = result
+              next_idx      = STAGES.index(@stage) + 1
+              @stage        = STAGES[next_idx] || :complete
+              @completed_at = Time.now.utc if @stage == :complete
+            else
+              @errors << { stage: @stage, error: result[:error], at: Time.now.utc }
+              @stage = :failed if @errors.size >= Helpers::Constants::MAX_FIX_ATTEMPTS
+            end
+          end
+
+          def complete?
+            @stage == :complete
+          end
+
+          def failed?
+            @stage == :failed
+          end
+
+          def to_h
+            {
+              proposal_id:  @proposal.id,
+              stage:        @stage,
+              errors:       @errors,
+              artifacts:    @artifacts,
+              started_at:   @started_at,
+              completed_at: @completed_at,
+              duration_ms:  duration_ms
+            }
+          end
+
+          def duration_ms
+            end_time = @completed_at || Time.now.utc
+            ((end_time - @started_at) * 1000).round
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module CognitiveModels
+          module_function
+
+          MODELS = {
+            global_workspace: {
+              name:        'Global Workspace Theory (Baars)',
+              required:    %i[attention global_workspace broadcasting working_memory consciousness],
+              description: 'Conscious access via global broadcasting to specialized processors'
+            },
+            free_energy:      {
+              name:        'Free Energy Principle (Friston)',
+              required:    %i[prediction free_energy predictive_coding belief_revision active_inference error_monitoring],
+              description: 'Minimize surprise through predictive models and active inference'
+            },
+            dual_process:     {
+              name:        'Dual Process Theory (Kahneman)',
+              required:    %i[intuition dual_process inhibition executive_function cognitive_control],
+              description: 'System 1 (fast/automatic) vs System 2 (slow/deliberate) processing'
+            },
+            somatic_marker:   {
+              name:        'Somatic Marker Hypothesis (Damasio)',
+              required:    %i[emotion somatic_marker interoception appraisal embodied_simulation],
+              description: 'Emotion-cognition integration for decision making'
+            },
+            working_memory:   {
+              name:        'Working Memory Model (Baddeley)',
+              required:    %i[working_memory episodic_buffer attention executive_function cognitive_load],
+              description: 'Multi-component model with central executive and slave systems'
+            }
+          }.freeze
+
+          def gap_analysis(existing_extensions)
+            existing_names = existing_extensions.map { |e| e.to_s.downcase.to_sym }
+            MODELS.map do |key, model|
+              missing  = model[:required] - existing_names
+              coverage = 1.0 - (missing.size.to_f / model[:required].size)
+              {
+                model:          key,
+                name:           model[:name],
+                coverage:       coverage.round(2),
+                missing:        missing,
+                total_required: model[:required].size
+              }
+            end
+          end
+
+          def recommend_from_gaps(gap_results)
+            gap_results.flat_map { |g| g[:missing] }.tally.sort_by { |_, count| -count }.map(&:first)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        class ConceptProposal
+          FIELDS = %i[
+            id name module_name category description metaphor helpers runner_methods
+            rationale scores status origin created_at evaluated_at built_at
+          ].freeze
+
+          attr_reader(*FIELDS)
+
+          def initialize(name:, module_name:, category:, description:, metaphor: nil, helpers: [],
+                         runner_methods: [], rationale: nil, origin: :proposer)
+            @id             = SecureRandom.uuid
+            @name           = name
+            @module_name    = module_name
+            @category       = category.to_sym
+            @description    = description
+            @metaphor       = metaphor
+            @helpers        = helpers         # array of { name:, methods: [] }
+            @runner_methods = runner_methods  # array of { name:, params: [], returns: '' }
+            @rationale      = rationale
+            @scores         = {}              # { novelty: 0.0..1.0, fit: 0.0..1.0, ... }
+            @status         = :proposed
+            @origin         = origin
+            @created_at     = Time.now.utc
+            @evaluated_at   = nil
+            @built_at       = nil
+          end
+
+          def evaluate!(scores)
+            @scores       = scores
+            @evaluated_at = Time.now.utc
+            @status       = passing_evaluation? ? :approved : :rejected
+          end
+
+          def passing_evaluation?
+            return false if @scores.empty?
+
+            Helpers::Constants::EVALUATION_DIMENSIONS.all? { |dim| (@scores[dim] || 0) >= Helpers::Constants::MIN_DIMENSION_SCORE }
+          end
+
+          def auto_approvable?
+            return false if @scores.empty?
+
+            Helpers::Constants::EVALUATION_DIMENSIONS.all? { |dim| (@scores[dim] || 0) >= Helpers::Constants::AUTO_APPROVE_THRESHOLD }
+          end
+
+          def transition!(new_status)
+            new_status = new_status.to_sym
+            unless Helpers::Constants::PROPOSAL_STATUSES.include?(new_status)
+              raise ArgumentError, "invalid status: #{new_status} (valid: #{Helpers::Constants::PROPOSAL_STATUSES.join(', ')})"
+            end
+
+            @status   = new_status
+            @built_at = Time.now.utc if new_status == :passing
+          end
+
+          def to_h
+            FIELDS.to_h { |f| [f, send(f)] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module Constants
+          # Proposal status lifecycle
+          PROPOSAL_STATUSES = %i[
+            proposed evaluating approved rejected building testing passing wired active degraded pruned build_failed
+          ].freeze
+
+          # Cognitive categories and target distribution
+          CATEGORIES = %i[cognition perception introspection safety communication memory motivation coordination].freeze
+
+          TARGET_DISTRIBUTION = {
+            cognition:     0.30,
+            perception:    0.15,
+            introspection: 0.12,
+            safety:        0.12,
+            communication: 0.10,
+            memory:        0.10,
+            motivation:    0.06,
+            coordination:  0.05
+          }.freeze
+
+          # Evaluation dimensions
+          EVALUATION_DIMENSIONS = %i[novelty fit cognitive_value implementability composability].freeze
+          MIN_DIMENSION_SCORE   = 0.6
+          AUTO_APPROVE_THRESHOLD = 0.9
+          REDUNDANCY_THRESHOLD   = 0.8
+
+          # Build pipeline
+          MAX_FIX_ATTEMPTS  = 3
+          BUILD_TIMEOUT_MS  = 600_000 # 10 minutes
+
+          # Fitness function weights
+          FITNESS_WEIGHTS = {
+            invocation_rate: 0.25,
+            impact_score:    0.30,
+            health:          0.25,
+            error_penalty:   -0.15,
+            latency_penalty: -0.05
+          }.freeze
+
+          PRUNE_THRESHOLD       = 0.2
+          IMPROVEMENT_THRESHOLD = 0.4
+
+          # Reference cognitive models
+          COGNITIVE_MODELS = %i[global_workspace free_energy dual_process somatic_marker working_memory].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module FitnessEvaluator
+          extend self
+
+          def fitness(extension)
+            w             = Helpers::Constants::FITNESS_WEIGHTS
+            invocation    = normalize_invocations(extension[:invocation_count] || 0)
+            impact        = extension[:impact_score] || 0.5
+            health        = extension[:health_score] || 1.0
+            error_rate    = extension[:error_rate] || 0.0
+            latency       = normalize_latency(extension[:avg_latency_ms] || 0)
+
+            score = (w[:invocation_rate] * invocation) +
+                    (w[:impact_score] * impact) +
+                    (w[:health] * health) +
+                    (w[:error_penalty] * error_rate) +
+                    (w[:latency_penalty] * latency)
+            score.clamp(0.0, 1.0).round(3)
+          end
+
+          def rank(extensions)
+            extensions.map { |e| e.merge(fitness: fitness(e)) }.sort_by { |e| -e[:fitness] }
+          end
+
+          def prune_candidates(extensions)
+            extensions.select { |e| fitness(e) < Helpers::Constants::PRUNE_THRESHOLD }
+          end
+
+          def improvement_candidates(extensions)
+            extensions.select do |e|
+              f = fitness(e)
+              f >= Helpers::Constants::PRUNE_THRESHOLD && f < Helpers::Constants::IMPROVEMENT_THRESHOLD
+            end
+          end
+
+          private
+
+          def normalize_invocations(count)
+            # Log scale: 0 invocations = 0.0, 1000+ = 1.0
+            return 0.0 if count.zero?
+
+            (Math.log10(count + 1) / 3.0).clamp(0.0, 1.0)
+          end
+
+          def normalize_latency(ms_val)
+            # Higher latency = higher penalty (0-1 scale, 5000ms = 1.0)
+            (ms_val / 5000.0).clamp(0.0, 1.0)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        class ProposalStore
+          MAX_PROPOSALS = 500
+
+          def initialize
+            @proposals = {}
+            @mutex     = Mutex.new
+          end
+
+          def store(proposal)
+            @mutex.synchronize do
+              evict_oldest if @proposals.size >= MAX_PROPOSALS
+              @proposals[proposal.id] = proposal
+            end
+          end
+
+          def get(id)
+            @mutex.synchronize { @proposals[id] }
+          end
+
+          def all
+            @mutex.synchronize { @proposals.values.dup }
+          end
+
+          def by_status(status)
+            @mutex.synchronize { @proposals.values.select { |p| p.status == status.to_sym } }
+          end
+
+          def by_category(category)
+            @mutex.synchronize { @proposals.values.select { |p| p.category == category.to_sym } }
+          end
+
+          def approved
+            by_status(:approved)
+          end
+
+          def build_queue
+            by_status(:approved).sort_by { |p| -(p.scores.values.sum / p.scores.size.to_f) }
+          end
+
+          def recent(limit: 20)
+            @mutex.synchronize { @proposals.values.sort_by { |p| -p.created_at.to_f }.first(limit) }
+          end
+
+          def stats
+            @mutex.synchronize do
+              statuses = @proposals.values.group_by(&:status).transform_values(&:count)
+              { total: @proposals.size, by_status: statuses }
+            end
+          end
+
+          def clear
+            @mutex.synchronize { @proposals.clear }
+          end
+
+          private
+
+          def evict_oldest
+            oldest = @proposals.values.min_by { |p| p.created_at.to_f }
+            @proposals.delete(oldest.id) if oldest
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Analyzer
+          extend self
+
+          def cognitive_profile(existing_extensions: nil, **)
+            extensions = existing_extensions || current_extensions
+            gap_data   = Helpers::CognitiveModels.gap_analysis(extensions)
+            {
+              success:          true,
+              total_extensions: extensions.size,
+              model_coverage:   gap_data,
+              overall_coverage: (gap_data.sum { |g| g[:coverage] } / gap_data.size.to_f).round(2)
+            }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def identify_weak_links(extensions: [], **)
+            weak = extensions.select { |e| Helpers::FitnessEvaluator.fitness(e) < Helpers::Constants::IMPROVEMENT_THRESHOLD }
+            { success: true, weak_links: Helpers::FitnessEvaluator.rank(weak), count: weak.size }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def recommend_priorities(existing_extensions: nil, **)
+            gaps = Helpers::CognitiveModels.recommend_from_gaps(
+              Helpers::CognitiveModels.gap_analysis(existing_extensions || current_extensions)
+            )
+            { success: true, priorities: gaps.first(10), rationale: 'Based on cognitive model gap analysis' }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def current_extensions
+            if defined?(Legion::Extensions::Metacognition::Helpers::Constants::SUBSYSTEMS)
+              Legion::Extensions::Metacognition::Helpers::Constants::SUBSYSTEMS
+            else
+              []
+            end
+          end
+        end
+      end
+    end
+  end
+end