lex-mind-growth 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3749e6e3fd39af6abe591e437da33b0c159db29b6e3463bd96dfb46f17b65d47
-  data.tar.gz: c702f090f36a6279fcded74bc19fccfa16cf8149d549d2603d0d38ed8b706432
+  metadata.gz: 2182f87f0f59f727c61f209083c225b1b31d9cbb5589af437618350433e8b692
+  data.tar.gz: 1ee0428c83686efdb168054b16d68af66443dfa60bd5f0bd8e2725f4d7d87ab4
 SHA512:
-  metadata.gz: 5a70ad32a8ca26d122eae4d6e176d3d680f8943c08fa9c74379e3e03bbc99f1f7663b1b0abf6ecb5ef3d06f997107fd2c3d04d48ab32306f458a78419f92e39d
-  data.tar.gz: 9861dfcd32bad6bcb08b398be0a1a1fc3e3f564e2cb8d17a58cb30cdd43218d1ce1600c7d2f0af559f38c0ce5868f639e14fb59f8dc00fd6ac13b551770cb197
+  metadata.gz: 1e7320c15ecd31d531bd961b03f20baa8c30a77946f98e58c25557ebcd1027b42b7c9af7c9ce8ae781089e25966a76d183209922ce8b2e7a780c141853cf6d96
+  data.tar.gz: b7abcbc0ea3109d64a4cc1cda9508ea0ee8ab777271e205abc1ae4903d1f2bf349b78053aa071fe5835790a790f4974be95800cf57ad2bfa8ab96182b358d312

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

@@ -30,6 +30,23 @@ 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(**)
+
+        # 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(**)
       end
     end
   end

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

@@ -48,6 +48,20 @@ 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
+
+          # 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/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/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/risk_assessor.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module RiskAssessor
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          HIGH_BLAST_CATEGORIES   = %i[safety coordination].freeze
+          MEDIUM_BLAST_CATEGORIES = %i[cognition].freeze
+          HOT_PATH_CATEGORIES     = %i[perception memory].freeze
+
+          def assess_risk(proposal_id:, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            dimensions = evaluate_dimensions(proposal)
+            tier       = calculate_tier(dimensions)
+            recommendation = Helpers::Constants::RISK_RECOMMENDATIONS[tier]
+
+            { success: true, proposal_id: proposal_id, risk_tier: tier,
+              dimensions: dimensions, recommendation: recommendation }
+          end
+
+          def risk_summary(proposals: nil, **)
+            ids = if proposals
+                    Array(proposals).map { |p| p.is_a?(Hash) ? p[:id] : p.to_s }
+                  else
+                    Runners::Proposer.list_proposals(limit: 100)[:proposals].map { |p| p[:id] }
+                  end
+
+            results = ids.filter_map do |id|
+              result = assess_risk(proposal_id: id)
+              next unless result[:success]
+
+              result
+            end
+
+            grouped = Helpers::Constants::RISK_TIERS.to_h { |tier| [tier, []] }
+            results.each { |r| grouped[r[:risk_tier]] << r }
+
+            { success: true, total: results.size, by_tier: grouped }
+          end
+
+          private
+
+          def evaluate_dimensions(proposal)
+            helper_count  = Array(proposal.helpers).size
+            category      = proposal.category.to_sym
+
+            {
+              complexity:         complexity_level(helper_count, Array(proposal.runner_methods).size),
+              blast_radius:       blast_radius_level(category),
+              reversibility:      :high,
+              performance_impact: performance_impact_level(category)
+            }
+          end
+
+          def complexity_level(helper_count, runner_count)
+            total = helper_count + runner_count
+            if total >= 7
+              :high
+            elsif total >= 4
+              :medium
+            else
+              :low
+            end
+          end
+
+          def blast_radius_level(category)
+            if HIGH_BLAST_CATEGORIES.include?(category)
+              :high
+            elsif MEDIUM_BLAST_CATEGORIES.include?(category)
+              :medium
+            else
+              :low
+            end
+          end
+
+          def performance_impact_level(category)
+            HOT_PATH_CATEGORIES.include?(category) ? :medium : :low
+          end
+
+          def calculate_tier(dimensions)
+            # Reversibility is a positive attribute (high = easily reversed) — exclude from risk calc
+            risk_values = dimensions.except(:reversibility).values
+
+            if risk_values.include?(:critical)
+              :critical
+            elsif risk_values.include?(:high)
+              :high
+            elsif risk_values.include?(:medium)
+              :medium
+            else
+              :low
+            end
+          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.5'
+      VERSION = '0.1.7'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -17,6 +17,9 @@ 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/runners/governance'
+require 'legion/extensions/mind_growth/runners/risk_assessor'
 require 'legion/extensions/mind_growth/client'
 
 module Legion