lex-mind-growth 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0855bf68cbc39002e5c08851edd6f3ce71afddb38f0633078a68d878fe954dec'
-  data.tar.gz: dc106552129f3d41f91711c51fca3b2a90a0198aede48d14b4d589c0b319fea0
+  metadata.gz: 87d35372e2ef409b603807723d816df60439d40bc8f4289d48799d31b731d232
+  data.tar.gz: fd49c0c8bb06f49374cbbb3afb497f45ee58193e71ff66b1ef1c622b94bbeaa6
 SHA512:
-  metadata.gz: 7d423da820af5d21f8b8f33f3c86850ae6cc6734d717386d31a862b800573694148626ade4587f5d2dbf10bafa14a61f0c973a2b1cefb1fe92817ef6c38527cd
-  data.tar.gz: 613aabc82f554a7de59965e8bb6a6543a72e346e74ea6618a6de65c15b4b40a2d2c4220230281dbf51e613aaa87d06b40738988627137244e9c7247229aef1be
+  metadata.gz: d3c07088c0173a6e5669af58bf3fbd315f2ef9098fa9e3f3f65228815159e6a061860c05aba14b75a0f0dcd9f01aea50f5a89ec9455a5796484037c6e1571328
+  data.tar.gz: 98b9b07557efbb5a3546a4018300ab984a0bfecc24ae93ab2534c35c90b991877d5564863460a75137525b262c996b7536ca14c6bbd20f77671225a8501ba402

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

@@ -35,6 +35,39 @@ module Legion
         def session_report(**)      = Runners::Retrospective.session_report(**)
         def trend_analysis(**)      = Runners::Retrospective.trend_analysis(**)
         def learning_extraction(**) = Runners::Retrospective.learning_extraction(**)
+
+        # Governance delegation
+        def submit_proposal(**)    = Runners::Governance.submit_proposal(**)
+        def vote_on_proposal(**)   = Runners::Governance.vote_on_proposal(**)
+        def tally_votes(**)        = Runners::Governance.tally_votes(**)
+        def approve_proposal(**)   = Runners::Governance.approve_proposal(**)
+        def reject_proposal(**)    = Runners::Governance.reject_proposal(**)
+        def governance_stats(**)   = Runners::Governance.governance_stats(**)
+
+        # 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

@@ -48,6 +48,24 @@ module Legion
 
           # Reference cognitive models
           COGNITIVE_MODELS = %i[global_workspace free_energy dual_process somatic_marker working_memory].freeze
+
+          # Governance
+          QUORUM                   = 3
+          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 = {
+            low:      :auto_approve,
+            medium:   :governance,
+            high:     :human_required,
+            critical: :blocked
+          }.freeze
         end
       end
     end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Governance
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          VOTE_VALUES = %i[approve reject].freeze
+
+          def submit_proposal(proposal_id:, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            return { success: false, error: :invalid_status, current_status: proposal.status } unless %i[proposed evaluating].include?(proposal.status)
+
+            proposal.transition!(:evaluating)
+            { success: true, proposal_id: proposal_id, status: :evaluating }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def vote_on_proposal(proposal_id:, vote:, agent_id: 'default', rationale: nil, **)
+            vote_sym = vote.to_sym
+            return { success: false, error: :invalid_vote } unless VOTE_VALUES.include?(vote_sym)
+
+            votes_mutex.synchronize do
+              votes_store[proposal_id] ||= []
+              votes_store[proposal_id] << { vote: vote_sym, agent_id: agent_id.to_s, rationale: rationale,
+                                            cast_at: Time.now.utc }
+            end
+
+            { success: true, proposal_id: proposal_id, vote: vote_sym, agent_id: agent_id.to_s }
+          end
+
+          def tally_votes(proposal_id:, **)
+            ballots = votes_mutex.synchronize { (votes_store[proposal_id] || []).dup }
+
+            approve_count = ballots.count { |b| b[:vote] == :approve }
+            reject_count  = ballots.count { |b| b[:vote] == :reject }
+            total         = ballots.size
+
+            verdict = if total < Helpers::Constants::QUORUM
+                        :pending
+                      elsif approve_count > reject_count
+                        :approved
+                      else
+                        :rejected
+                      end
+
+            { success: true, proposal_id: proposal_id, approve_count: approve_count,
+              reject_count: reject_count, total: total, verdict: verdict }
+          end
+
+          def approve_proposal(proposal_id:, _reason: nil, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            proposal.transition!(:approved)
+            { success: true, proposal_id: proposal_id, status: :approved }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def reject_proposal(proposal_id:, reason: nil, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            proposal.transition!(:rejected)
+            { success: true, proposal_id: proposal_id, status: :rejected, reason: reason }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def governance_stats(**)
+            all_votes = votes_mutex.synchronize { votes_store.dup }
+
+            total_votes = all_votes.values.sum(&:size)
+            proposals_with_votes = all_votes.size
+
+            vote_summary = all_votes.transform_values do |ballots|
+              {
+                approve: ballots.count { |b| b[:vote] == :approve },
+                reject:  ballots.count { |b| b[:vote] == :reject },
+                total:   ballots.size
+              }
+            end
+
+            proposal_stats = Runners::Proposer.proposal_stats
+            by_status = proposal_stats[:stats][:by_status]
+
+            governance_breakdown = Helpers::Constants::GOVERNANCE_STATUSES.to_h do |s|
+              [s, by_status[s] || 0]
+            end
+
+            {
+              success:              true,
+              total_votes:          total_votes,
+              proposals_with_votes: proposals_with_votes,
+              vote_summary:         vote_summary,
+              governance_breakdown: governance_breakdown
+            }
+          end
+
+          private
+
+          def votes_store
+            @votes_store ||= {}
+          end
+
+          def votes_mutex
+            @votes_mutex ||= Mutex.new
+          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