lex-mind-growth 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2182f87f0f59f727c61f209083c225b1b31d9cbb5589af437618350433e8b692
-  data.tar.gz: 1ee0428c83686efdb168054b16d68af66443dfa60bd5f0bd8e2725f4d7d87ab4
+  metadata.gz: 87d35372e2ef409b603807723d816df60439d40bc8f4289d48799d31b731d232
+  data.tar.gz: fd49c0c8bb06f49374cbbb3afb497f45ee58193e71ff66b1ef1c622b94bbeaa6
 SHA512:
-  metadata.gz: 1e7320c15ecd31d531bd961b03f20baa8c30a77946f98e58c25557ebcd1027b42b7c9af7c9ce8ae781089e25966a76d183209922ce8b2e7a780c141853cf6d96
-  data.tar.gz: b7abcbc0ea3109d64a4cc1cda9508ea0ee8ab777271e205abc1ae4903d1f2bf349b78053aa071fe5835790a790f4974be95800cf57ad2bfa8ab96182b358d312
+  metadata.gz: d3c07088c0173a6e5669af58bf3fbd315f2ef9098fa9e3f3f65228815159e6a061860c05aba14b75a0f0dcd9f01aea50f5a89ec9455a5796484037c6e1571328
+  data.tar.gz: 98b9b07557efbb5a3546a4018300ab984a0bfecc24ae93ab2534c35c90b991877d5564863460a75137525b262c996b7536ca14c6bbd20f77671225a8501ba402

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

@@ -47,6 +47,27 @@ module Legion
         # RiskAssessor delegation
         def assess_risk(**)   = Runners::RiskAssessor.assess_risk(**)
         def risk_summary(**)  = Runners::RiskAssessor.risk_summary(**)
+
+        # Monitor delegation
+        def health_check(**)    = Runners::Monitor.health_check(**)
+        def usage_stats(**)     = Runners::Monitor.usage_stats(**)
+        def impact_score(**)    = Runners::Monitor.impact_score(**)
+        def decay_check(**)     = Runners::Monitor.decay_check(**)
+        def auto_prune(**)      = Runners::Monitor.auto_prune(**)
+        def health_summary(**)  = Runners::Monitor.health_summary(**)
+
+        # Composer delegation
+        def add_composition(**)      = Runners::Composer.add_composition(**)
+        def remove_composition(**)   = Runners::Composer.remove_composition(**)
+        def evaluate_output(**)      = Runners::Composer.evaluate_output(**)
+        def composition_stats(**)    = Runners::Composer.composition_stats(**)
+        def suggest_compositions(**) = Runners::Composer.suggest_compositions(**)
+        def list_compositions(**)    = Runners::Composer.list_compositions(**)
+
+        # DreamIdeation delegation
+        def generate_dream_proposals(**) = Runners::DreamIdeation.generate_dream_proposals(**)
+        def dream_agenda_items(**)       = Runners::DreamIdeation.dream_agenda_items(**)
+        def enrich_from_dream_context(**) = Runners::DreamIdeation.enrich_from_dream_context(**)
       end
     end
   end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module CompositionMap
+          module_function
+
+          @rules = {}
+          @mutex = Mutex.new
+
+          def add_rule(source_extension:, output_key:, target_extension:, target_method:, transform: nil, **)
+            rule_id = SecureRandom.uuid
+            rule = {
+              id:               rule_id,
+              source_extension: source_extension.to_s,
+              output_key:       output_key.to_sym,
+              target_extension: target_extension.to_s,
+              target_method:    target_method.to_sym,
+              transform:        transform
+            }
+            @mutex.synchronize { @rules[rule_id] = rule }
+            { success: true, rule_id: rule_id }
+          end
+
+          def remove_rule(rule_id:, **)
+            removed = @mutex.synchronize { @rules.delete(rule_id) }
+            { success: !removed.nil?, rule_id: rule_id }
+          end
+
+          def rules_for(source_extension:, **)
+            src = source_extension.to_s
+            @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src } }
+          end
+
+          def all_rules
+            @mutex.synchronize { @rules.values.dup }
+          end
+
+          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.filter_map do |rule|
+              key = rule[:output_key]
+              next unless out_h.key?(key)
+
+              { rule: rule, matched_value: out_h[key] }
+            end
+          end
+
+          def clear!
+            @mutex.synchronize { @rules.clear }
+          end
+
+          def stats
+            all = @mutex.synchronize { @rules.values.dup }
+
+            by_source = Hash.new(0)
+            by_target = Hash.new(0)
+            all.each do |r|
+              by_source[r[:source_extension]] += 1
+              by_target[r[:target_extension]] += 1
+            end
+
+            { total_rules: all.size,
+              by_source:   by_source.transform_values { |v| v },
+              by_target:   by_target.transform_values { |v| v } }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -54,6 +54,10 @@ module Legion
           REJECTION_COOLDOWN_HOURS = 24
           GOVERNANCE_STATUSES      = %i[pending approved rejected expired].freeze
 
+          # Health monitoring
+          HEALTH_LEVELS = { excellent: 0.8, good: 0.6, fair: 0.4, degraded: 0.2, critical: 0.0 }.freeze
+          DECAY_INVOCATION_THRESHOLD = 5
+
           # Risk assessment
           RISK_TIERS = %i[low medium high critical].freeze
           RISK_RECOMMENDATIONS = {

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Composer
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          # Category adjacency used for heuristic suggestions
+          CATEGORY_FLOW = [
+            %i[perception cognition],
+            %i[cognition memory],
+            %i[cognition introspection],
+            %i[memory cognition],
+            %i[introspection safety],
+            %i[motivation cognition],
+            %i[cognition communication],
+            %i[communication coordination]
+          ].freeze
+
+          def add_composition(source_extension:, output_key:, target_extension:, target_method:,
+                              transform: nil, **)
+            Helpers::CompositionMap.add_rule(
+              source_extension: source_extension,
+              output_key:       output_key,
+              target_extension: target_extension,
+              target_method:    target_method,
+              transform:        transform
+            )
+          end
+
+          def remove_composition(rule_id:, **)
+            result = Helpers::CompositionMap.remove_rule(rule_id: rule_id)
+            { success: result[:success] }
+          end
+
+          def evaluate_output(source_extension:, output:, **)
+            matches = Helpers::CompositionMap.match_output(
+              source_extension: source_extension,
+              output:           output
+            )
+
+            dispatches = matches.map do |match|
+              rule  = match[:rule]
+              value = match[:matched_value]
+              input = rule[:transform] ? rule[:transform].call(value) : value
+
+              { target_extension: rule[:target_extension],
+                target_method:    rule[:target_method],
+                input:            input }
+            end
+
+            { success: true, dispatches: dispatches, count: dispatches.size }
+          end
+
+          def composition_stats(**)
+            { success: true, **Helpers::CompositionMap.stats }
+          end
+
+          def suggest_compositions(extensions:, **)
+            exts = Array(extensions)
+
+            return suggest_with_llm(exts) if defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+
+            suggestions = heuristic_suggestions(exts)
+            { success: true, suggestions: suggestions, count: suggestions.size }
+          end
+
+          def list_compositions(**)
+            rules = Helpers::CompositionMap.all_rules
+            { success: true, rules: rules, count: rules.size }
+          end
+
+          private
+
+          def heuristic_suggestions(extensions)
+            ext_by_category = {}
+            extensions.each do |ext|
+              cat = (ext[:category] || :cognition).to_sym
+              (ext_by_category[cat] ||= []) << ext
+            end
+
+            suggestions = []
+            CATEGORY_FLOW.each do |src_cat, tgt_cat|
+              src_exts = ext_by_category[src_cat] || []
+              tgt_exts = ext_by_category[tgt_cat] || []
+
+              src_exts.each do |src|
+                tgt_exts.each do |tgt|
+                  suggestions << {
+                    source_extension: src[:name] || src[:extension_name],
+                    output_key:       :result,
+                    target_extension: tgt[:name] || tgt[:extension_name],
+                    target_method:    :process,
+                    rationale:        "#{src_cat} -> #{tgt_cat} flow"
+                  }
+                end
+              end
+            end
+
+            suggestions
+          end
+
+          def suggest_with_llm(extensions)
+            suggestions = heuristic_suggestions(extensions)
+            { success: true, suggestions: suggestions, count: suggestions.size }
+          rescue StandardError
+            { success: true, suggestions: [], count: 0 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module DreamIdeation
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          DREAM_NOVELTY_BONUS = 0.15
+
+          # Agenda item weight by how underrepresented the category is
+          MAX_AGENDA_WEIGHT = 1.0
+          MIN_AGENDA_WEIGHT = 0.1
+
+          def generate_dream_proposals(existing_extensions: nil, max_proposals: 2, **)
+            gap_result = Runners::Proposer.analyze_gaps(existing_extensions: existing_extensions)
+            return { success: false, error: :gap_analysis_failed } unless gap_result[:success]
+
+            recommendations = gap_result[:recommendations] || []
+            proposals       = []
+
+            recommendations.first(max_proposals).each do |rec|
+              name   = rec.is_a?(Hash) ? rec[:name] : rec.to_s
+              result = Runners::Proposer.propose_concept(
+                name:        "lex-dream-#{name.to_s.downcase.gsub(/[^a-z0-9]/, '-')}",
+                description: "Dream-originated proposal for #{name} cognitive capability",
+                enrich:      false
+              )
+              next unless result[:success]
+
+              proposal_id = result[:proposal][:id]
+              proposal    = Runners::Proposer.get_proposal_object(proposal_id)
+              proposal&.instance_variable_set(:@origin, :dream)
+
+              proposals << result[:proposal]
+            end
+
+            { success: true, proposals: proposals, count: proposals.size,
+              gaps_analyzed: recommendations.size }
+          end
+
+          def dream_agenda_items(existing_extensions: nil, **)
+            gap_result = Runners::Proposer.analyze_gaps(existing_extensions: existing_extensions)
+            return { success: false, error: :gap_analysis_failed } unless gap_result[:success]
+
+            target = Helpers::Constants::TARGET_DISTRIBUTION
+            models = gap_result[:models] || []
+
+            coverage_by_cat = build_coverage_by_category(models)
+
+            items = target.filter_map do |category, target_pct|
+              actual_pct = coverage_by_cat[category] || 0.0
+              gap        = (target_pct - actual_pct).clamp(0.0, 1.0)
+              next if gap <= 0.0
+
+              weight = ((gap / target_pct) * MAX_AGENDA_WEIGHT).clamp(MIN_AGENDA_WEIGHT, MAX_AGENDA_WEIGHT).round(3)
+
+              { type:    :architectural_gap,
+                content: { gap_name: category, model: :target_distribution, coverage: actual_pct },
+                weight:  weight }
+            end
+
+            { success: true, items: items, count: items.size }
+          end
+
+          def enrich_from_dream_context(proposal_id:, dream_context: {}, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            if dream_context && !dream_context.empty?
+              existing  = proposal.rationale.to_s
+              additions = dream_context.map { |k, v| "#{k}: #{v}" }.join('; ')
+              new_rationale = existing.empty? ? additions : "#{existing}. Dream context: #{additions}"
+              proposal.instance_variable_set(:@rationale, new_rationale)
+              { success: true, proposal_id: proposal_id, enriched: true }
+            else
+              { success: true, proposal_id: proposal_id, enriched: false }
+            end
+          end
+
+          private
+
+          def build_coverage_by_category(models)
+            coverage = {}
+            models.each do |model|
+              cat = infer_category_from_model(model[:model])
+              next unless cat
+
+              existing = coverage[cat] || 1.0
+              coverage[cat] = [existing, model_coverage_fraction(model)].min
+            end
+            coverage
+          end
+
+          def model_coverage_fraction(model)
+            total   = model[:total_required] || 1
+            missing = (model[:missing] || []).size
+            covered = total - missing
+            total.positive? ? (covered.to_f / total).round(3) : 0.0
+          end
+
+          def infer_category_from_model(model_name)
+            mapping = {
+              global_workspace: :cognition,
+              free_energy:      :introspection,
+              dual_process:     :cognition,
+              somatic_marker:   :motivation,
+              working_memory:   :memory
+            }
+            mapping[model_name&.to_sym]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Monitor
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          HEALTH_LEVELS = {
+            excellent: 0.8,
+            good:      0.6,
+            fair:      0.4,
+            degraded:  0.2,
+            critical:  0.0
+          }.freeze
+
+          def health_check(extension:, **)
+            name    = extension[:name] || extension[:extension_name]
+            fitness = Helpers::FitnessEvaluator.fitness(extension)
+            level   = classify_health(fitness)
+            alert   = %i[degraded critical].include?(level)
+
+            { success: true, extension_name: name, fitness: fitness,
+              health_level: level, alert: alert }
+          end
+
+          def usage_stats(extensions:, **)
+            stats = Array(extensions).map do |ext|
+              { extension_name:   ext[:name] || ext[:extension_name],
+                invocation_count: ext[:invocation_count] || 0,
+                error_rate:       ext[:error_rate] || 0.0,
+                avg_latency_ms:   ext[:avg_latency_ms] || 0 }
+            end
+
+            { success: true, stats: stats, count: stats.size }
+          end
+
+          def impact_score(extension:, extensions: nil, **)
+            name   = extension[:name] || extension[:extension_name]
+            impact = extension[:impact_score] || 0.5
+
+            percentile = if extensions && !Array(extensions).empty?
+                           all_impacts = Array(extensions).map { |e| e[:impact_score] || 0.5 }.sort
+                           rank = all_impacts.count { |i| i <= impact }
+                           (rank.to_f / all_impacts.size * 100).round(1)
+                         else
+                           50.0
+                         end
+
+            { success: true, extension_name: name, impact: impact, rank_percentile: percentile }
+          end
+
+          def decay_check(extensions:, **)
+            threshold = Helpers::Constants::DECAY_INVOCATION_THRESHOLD
+            decayed = Array(extensions).select do |ext|
+              count   = ext[:invocation_count] || 0
+              fitness = Helpers::FitnessEvaluator.fitness(ext)
+              count < threshold || fitness < Helpers::Constants::PRUNE_THRESHOLD
+            end
+
+            { success: true, decayed: decayed, count: decayed.size }
+          end
+
+          def auto_prune(extensions:, **)
+            pruned = Helpers::FitnessEvaluator.prune_candidates(Array(extensions))
+            { success: true, pruned: pruned, count: pruned.size }
+          end
+
+          def health_summary(extensions:, **)
+            exts = Array(extensions)
+
+            by_health_level = HEALTH_LEVELS.keys.to_h { |level| [level, 0] }
+            alerts          = []
+            prune_candidates = Helpers::FitnessEvaluator.prune_candidates(exts)
+
+            exts.each do |ext|
+              fitness = Helpers::FitnessEvaluator.fitness(ext)
+              level   = classify_health(fitness)
+              by_health_level[level] += 1
+              alerts << ext if %i[degraded critical].include?(level)
+            end
+
+            { success: true, total: exts.size, by_health_level: by_health_level,
+              alerts: alerts, prune_candidates: prune_candidates }
+          end
+
+          private
+
+          def classify_health(fitness)
+            HEALTH_LEVELS.each do |level, threshold|
+              return level if fitness >= threshold
+            end
+            :critical
+          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.7'
+      VERSION = '0.1.8'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -20,6 +20,10 @@ require 'legion/extensions/mind_growth/runners/integration_tester'
 require 'legion/extensions/mind_growth/runners/retrospective'
 require 'legion/extensions/mind_growth/runners/governance'
 require 'legion/extensions/mind_growth/runners/risk_assessor'
+require 'legion/extensions/mind_growth/helpers/composition_map'
+require 'legion/extensions/mind_growth/runners/monitor'
+require 'legion/extensions/mind_growth/runners/composer'
+require 'legion/extensions/mind_growth/runners/dream_ideation'
 require 'legion/extensions/mind_growth/client'
 
 module Legion