lex-mind-growth 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0855bf68cbc39002e5c08851edd6f3ce71afddb38f0633078a68d878fe954dec'
-  data.tar.gz: dc106552129f3d41f91711c51fca3b2a90a0198aede48d14b4d589c0b319fea0
+  metadata.gz: 2182f87f0f59f727c61f209083c225b1b31d9cbb5589af437618350433e8b692
+  data.tar.gz: 1ee0428c83686efdb168054b16d68af66443dfa60bd5f0bd8e2725f4d7d87ab4
 SHA512:
-  metadata.gz: 7d423da820af5d21f8b8f33f3c86850ae6cc6734d717386d31a862b800573694148626ade4587f5d2dbf10bafa14a61f0c973a2b1cefb1fe92817ef6c38527cd
-  data.tar.gz: 613aabc82f554a7de59965e8bb6a6543a72e346e74ea6618a6de65c15b4b40a2d2c4220230281dbf51e613aaa87d06b40738988627137244e9c7247229aef1be
+  metadata.gz: 1e7320c15ecd31d531bd961b03f20baa8c30a77946f98e58c25557ebcd1027b42b7c9af7c9ce8ae781089e25966a76d183209922ce8b2e7a780c141853cf6d96
+  data.tar.gz: b7abcbc0ea3109d64a4cc1cda9508ea0ee8ab777271e205abc1ae4903d1f2bf349b78053aa071fe5835790a790f4974be95800cf57ad2bfa8ab96182b358d312

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

@@ -35,6 +35,18 @@ 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(**)
       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/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.6'
+      VERSION = '0.1.7'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -18,6 +18,8 @@ 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

data/spec/legion/extensions/mind_growth/runners/governance_spec.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::Governance do
+  subject(:governance) { described_class }
+
+  let(:proposer) { Legion::Extensions::MindGrowth::Runners::Proposer }
+
+  before do
+    proposer.instance_variable_set(:@proposal_store, nil)
+    governance.instance_variable_set(:@votes_store, nil)
+    governance.instance_variable_set(:@votes_mutex, nil)
+  end
+
+  def create_proposal(name: 'lex-gov-test', category: :cognition, status: nil)
+    result = proposer.propose_concept(name: name, category: category, description: 'test proposal', enrich: false)
+    proposal = proposer.get_proposal_object(result[:proposal][:id])
+    proposal.transition!(status) if status && status != :proposed
+    proposal
+  end
+
+  # ─── submit_proposal ──────────────────────────────────────────────────────
+
+  describe '.submit_proposal' do
+    context 'with a valid proposed proposal' do
+      it 'returns success: true' do
+        proposal = create_proposal
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:success]).to be true
+      end
+
+      it 'returns the proposal_id' do
+        proposal = create_proposal
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:proposal_id]).to eq(proposal.id)
+      end
+
+      it 'returns status: :evaluating' do
+        proposal = create_proposal
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:status]).to eq(:evaluating)
+      end
+
+      it 'transitions the proposal to :evaluating' do
+        proposal = create_proposal
+        governance.submit_proposal(proposal_id: proposal.id)
+        expect(proposal.status).to eq(:evaluating)
+      end
+    end
+
+    context 'with an already-evaluating proposal' do
+      it 'returns success: true and keeps :evaluating status' do
+        proposal = create_proposal
+        governance.submit_proposal(proposal_id: proposal.id)
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:success]).to be true
+        expect(result[:status]).to eq(:evaluating)
+      end
+    end
+
+    context 'with a proposal in an invalid status' do
+      it 'returns success: false for :building status' do
+        proposal = create_proposal(status: :building)
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:success]).to be false
+      end
+
+      it 'returns :invalid_status error' do
+        proposal = create_proposal(status: :building)
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:error]).to eq(:invalid_status)
+      end
+
+      it 'includes current_status in the error response' do
+        proposal = create_proposal(status: :building)
+        result = governance.submit_proposal(proposal_id: proposal.id)
+        expect(result[:current_status]).to eq(:building)
+      end
+    end
+
+    context 'with a non-existent proposal_id' do
+      it 'returns success: false' do
+        result = governance.submit_proposal(proposal_id: 'no-such-id')
+        expect(result[:success]).to be false
+      end
+
+      it 'returns :not_found error' do
+        result = governance.submit_proposal(proposal_id: 'no-such-id')
+        expect(result[:error]).to eq(:not_found)
+      end
+    end
+
+    it 'ignores unknown keyword arguments' do
+      proposal = create_proposal
+      expect { governance.submit_proposal(proposal_id: proposal.id, extra: true) }.not_to raise_error
+    end
+  end
+
+  # ─── vote_on_proposal ─────────────────────────────────────────────────────
+
+  describe '.vote_on_proposal' do
+    let(:proposal) { create_proposal }
+
+    it 'returns success: true for :approve vote' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success: true for :reject vote' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the proposal_id' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve)
+      expect(result[:proposal_id]).to eq(proposal.id)
+    end
+
+    it 'returns the vote symbol' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve)
+      expect(result[:vote]).to eq(:approve)
+    end
+
+    it 'returns the agent_id' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: 'agent-1')
+      expect(result[:agent_id]).to eq('agent-1')
+    end
+
+    it 'uses "default" as agent_id when not provided' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve)
+      expect(result[:agent_id]).to eq('default')
+    end
+
+    it 'accepts string vote values and coerces to symbol' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: 'approve')
+      expect(result[:success]).to be true
+      expect(result[:vote]).to eq(:approve)
+    end
+
+    it 'returns success: false for invalid vote' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :maybe)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns :invalid_vote error for unknown vote' do
+      result = governance.vote_on_proposal(proposal_id: proposal.id, vote: :abstain)
+      expect(result[:error]).to eq(:invalid_vote)
+    end
+
+    it 'accumulates multiple votes for the same proposal' do
+      3.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "agent-#{i}") }
+      tally = governance.tally_votes(proposal_id: proposal.id)
+      expect(tally[:total]).to eq(3)
+    end
+
+    context 'thread safety' do
+      it 'records all votes when cast concurrently' do
+        threads = 10.times.map do |i|
+          Thread.new { governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "t#{i}") }
+        end
+        threads.each(&:join)
+        tally = governance.tally_votes(proposal_id: proposal.id)
+        expect(tally[:total]).to eq(10)
+      end
+
+      it 'correctly tallies mixed concurrent votes' do
+        threads = []
+        5.times { |i| threads << Thread.new { governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") } }
+        5.times { |i| threads << Thread.new { governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject,  agent_id: "r#{i}") } }
+        threads.each(&:join)
+        tally = governance.tally_votes(proposal_id: proposal.id)
+        expect(tally[:approve_count]).to eq(5)
+        expect(tally[:reject_count]).to eq(5)
+      end
+    end
+  end
+
+  # ─── tally_votes ──────────────────────────────────────────────────────────
+
+  describe '.tally_votes' do
+    let(:proposal) { create_proposal }
+
+    it 'returns success: true' do
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the proposal_id' do
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:proposal_id]).to eq(proposal.id)
+    end
+
+    it 'returns zero counts with no votes' do
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:approve_count]).to eq(0)
+      expect(result[:reject_count]).to eq(0)
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'returns :pending verdict when total < QUORUM' do
+      2.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") }
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:pending)
+    end
+
+    it 'returns :approved verdict when approve_count > reject_count and total >= QUORUM' do
+      3.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") }
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:approved)
+    end
+
+    it 'returns :rejected verdict when reject_count >= approve_count and total >= QUORUM' do
+      2.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject,  agent_id: "r#{i}") }
+      governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: 'a0')
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:rejected)
+    end
+
+    it 'returns :rejected on a tie when total >= QUORUM' do
+      3.times do |i|
+        governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}")
+        governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject,  agent_id: "r#{i}")
+      end
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:rejected)
+    end
+
+    it 'counts approve votes correctly' do
+      2.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") }
+      governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject, agent_id: 'r0')
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:approve_count]).to eq(2)
+      expect(result[:reject_count]).to eq(1)
+    end
+
+    it 'returns :pending for an unknown proposal_id with no votes' do
+      result = governance.tally_votes(proposal_id: 'nonexistent')
+      expect(result[:verdict]).to eq(:pending)
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'requires exactly QUORUM votes for non-pending verdict' do
+      quorum = Legion::Extensions::MindGrowth::Helpers::Constants::QUORUM
+      (quorum - 1).times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") }
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:pending)
+
+      governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: 'final')
+      result = governance.tally_votes(proposal_id: proposal.id)
+      expect(result[:verdict]).to eq(:approved)
+    end
+  end
+
+  # ─── approve_proposal ─────────────────────────────────────────────────────
+
+  describe '.approve_proposal' do
+    it 'returns success: true' do
+      proposal = create_proposal
+      result = governance.approve_proposal(proposal_id: proposal.id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns status: :approved' do
+      proposal = create_proposal
+      result = governance.approve_proposal(proposal_id: proposal.id)
+      expect(result[:status]).to eq(:approved)
+    end
+
+    it 'transitions the proposal to :approved' do
+      proposal = create_proposal
+      governance.approve_proposal(proposal_id: proposal.id)
+      expect(proposal.status).to eq(:approved)
+    end
+
+    it 'returns the proposal_id' do
+      proposal = create_proposal
+      result = governance.approve_proposal(proposal_id: proposal.id)
+      expect(result[:proposal_id]).to eq(proposal.id)
+    end
+
+    it 'returns success: false for non-existent proposal' do
+      result = governance.approve_proposal(proposal_id: 'missing')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'accepts an optional reason keyword' do
+      proposal = create_proposal
+      expect { governance.approve_proposal(proposal_id: proposal.id, reason: 'looks good') }.not_to raise_error
+    end
+  end
+
+  # ─── reject_proposal ──────────────────────────────────────────────────────
+
+  describe '.reject_proposal' do
+    it 'returns success: true' do
+      proposal = create_proposal
+      result = governance.reject_proposal(proposal_id: proposal.id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns status: :rejected' do
+      proposal = create_proposal
+      result = governance.reject_proposal(proposal_id: proposal.id)
+      expect(result[:status]).to eq(:rejected)
+    end
+
+    it 'transitions the proposal to :rejected' do
+      proposal = create_proposal
+      governance.reject_proposal(proposal_id: proposal.id)
+      expect(proposal.status).to eq(:rejected)
+    end
+
+    it 'returns the proposal_id' do
+      proposal = create_proposal
+      result = governance.reject_proposal(proposal_id: proposal.id)
+      expect(result[:proposal_id]).to eq(proposal.id)
+    end
+
+    it 'includes the reason in the response' do
+      proposal = create_proposal
+      result = governance.reject_proposal(proposal_id: proposal.id, reason: 'too risky')
+      expect(result[:reason]).to eq('too risky')
+    end
+
+    it 'returns nil reason when none provided' do
+      proposal = create_proposal
+      result = governance.reject_proposal(proposal_id: proposal.id)
+      expect(result[:reason]).to be_nil
+    end
+
+    it 'returns success: false for non-existent proposal' do
+      result = governance.reject_proposal(proposal_id: 'missing')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  # ─── governance_stats ─────────────────────────────────────────────────────
+
+  describe '.governance_stats' do
+    it 'returns success: true' do
+      result = governance.governance_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes total_votes key' do
+      result = governance.governance_stats
+      expect(result).to have_key(:total_votes)
+    end
+
+    it 'includes proposals_with_votes key' do
+      result = governance.governance_stats
+      expect(result).to have_key(:proposals_with_votes)
+    end
+
+    it 'includes vote_summary key' do
+      result = governance.governance_stats
+      expect(result).to have_key(:vote_summary)
+    end
+
+    it 'includes governance_breakdown key' do
+      result = governance.governance_stats
+      expect(result).to have_key(:governance_breakdown)
+    end
+
+    it 'reports zero total_votes when no votes cast' do
+      result = governance.governance_stats
+      expect(result[:total_votes]).to eq(0)
+    end
+
+    it 'reports zero proposals_with_votes when no votes cast' do
+      result = governance.governance_stats
+      expect(result[:proposals_with_votes]).to eq(0)
+    end
+
+    it 'governance_breakdown includes all GOVERNANCE_STATUSES' do
+      result = governance.governance_stats
+      Legion::Extensions::MindGrowth::Helpers::Constants::GOVERNANCE_STATUSES.each do |status|
+        expect(result[:governance_breakdown]).to have_key(status)
+      end
+    end
+
+    context 'after voting' do
+      let(:proposal) { create_proposal }
+
+      before do
+        3.times { |i| governance.vote_on_proposal(proposal_id: proposal.id, vote: :approve, agent_id: "a#{i}") }
+        governance.vote_on_proposal(proposal_id: proposal.id, vote: :reject, agent_id: 'r0')
+      end
+
+      it 'reflects total_votes correctly' do
+        result = governance.governance_stats
+        expect(result[:total_votes]).to eq(4)
+      end
+
+      it 'reflects proposals_with_votes correctly' do
+        result = governance.governance_stats
+        expect(result[:proposals_with_votes]).to eq(1)
+      end
+
+      it 'vote_summary for the proposal has correct approve/reject counts' do
+        result = governance.governance_stats
+        summary = result[:vote_summary][proposal.id]
+        expect(summary[:approve]).to eq(3)
+        expect(summary[:reject]).to eq(1)
+        expect(summary[:total]).to eq(4)
+      end
+    end
+
+    context 'with multiple proposals' do
+      it 'counts votes across proposals correctly' do
+        p1 = create_proposal(name: 'lex-g1')
+        p2 = create_proposal(name: 'lex-g2')
+        2.times { |i| governance.vote_on_proposal(proposal_id: p1.id, vote: :approve, agent_id: "a#{i}") }
+        3.times { |i| governance.vote_on_proposal(proposal_id: p2.id, vote: :reject,  agent_id: "r#{i}") }
+        result = governance.governance_stats
+        expect(result[:total_votes]).to eq(5)
+        expect(result[:proposals_with_votes]).to eq(2)
+      end
+    end
+  end
+
+  # ─── constant checks ──────────────────────────────────────────────────────
+
+  describe 'constants' do
+    it 'QUORUM is 3' do
+      expect(Legion::Extensions::MindGrowth::Helpers::Constants::QUORUM).to eq(3)
+    end
+
+    it 'REJECTION_COOLDOWN_HOURS is 24' do
+      expect(Legion::Extensions::MindGrowth::Helpers::Constants::REJECTION_COOLDOWN_HOURS).to eq(24)
+    end
+
+    it 'GOVERNANCE_STATUSES includes :pending, :approved, :rejected, :expired' do
+      statuses = Legion::Extensions::MindGrowth::Helpers::Constants::GOVERNANCE_STATUSES
+      expect(statuses).to include(:pending, :approved, :rejected, :expired)
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/runners/risk_assessor_spec.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::RiskAssessor do
+  subject(:risk_assessor) { described_class }
+
+  let(:proposer) { Legion::Extensions::MindGrowth::Runners::Proposer }
+
+  before { proposer.instance_variable_set(:@proposal_store, nil) }
+
+  def create_proposal(name: 'lex-risk-test', category: :cognition, helpers: [], runner_methods: [])
+    result = proposer.propose_concept(name: name, category: category, description: 'risk test', enrich: false)
+    proposal = proposer.get_proposal_object(result[:proposal][:id])
+    # Inject helpers and runner_methods via instance variables for test control
+    proposal.instance_variable_set(:@helpers, helpers)
+    proposal.instance_variable_set(:@runner_methods, runner_methods)
+    proposal
+  end
+
+  # ─── assess_risk ──────────────────────────────────────────────────────────
+
+  describe '.assess_risk' do
+    context 'with a basic cognition proposal' do
+      let(:proposal) { create_proposal }
+
+      it 'returns success: true' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:success]).to be true
+      end
+
+      it 'returns the proposal_id' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:proposal_id]).to eq(proposal.id)
+      end
+
+      it 'returns a risk_tier' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(Legion::Extensions::MindGrowth::Helpers::Constants::RISK_TIERS).to include(result[:risk_tier])
+      end
+
+      it 'returns a dimensions hash' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions]).to be_a(Hash)
+      end
+
+      it 'dimensions includes :complexity' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions]).to have_key(:complexity)
+      end
+
+      it 'dimensions includes :blast_radius' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions]).to have_key(:blast_radius)
+      end
+
+      it 'dimensions includes :reversibility' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions]).to have_key(:reversibility)
+      end
+
+      it 'dimensions includes :performance_impact' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions]).to have_key(:performance_impact)
+      end
+
+      it 'reversibility is always :high' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:reversibility]).to eq(:high)
+      end
+
+      it 'returns a recommendation' do
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(Legion::Extensions::MindGrowth::Helpers::Constants::RISK_RECOMMENDATIONS.values).to include(result[:recommendation])
+      end
+    end
+
+    context 'with a non-existent proposal_id' do
+      it 'returns success: false' do
+        result = risk_assessor.assess_risk(proposal_id: 'no-such-id')
+        expect(result[:success]).to be false
+      end
+
+      it 'returns :not_found error' do
+        result = risk_assessor.assess_risk(proposal_id: 'no-such-id')
+        expect(result[:error]).to eq(:not_found)
+      end
+    end
+
+    it 'ignores unknown keyword arguments' do
+      proposal = create_proposal
+      expect { risk_assessor.assess_risk(proposal_id: proposal.id, extra: true) }.not_to raise_error
+    end
+
+    # ── complexity dimension ──────────────────────────────────────────────
+
+    context 'complexity based on helpers + runner_methods count' do
+      it 'is :low when total < 4 (0 helpers, 0 runner_methods)' do
+        proposal = create_proposal(helpers: [], runner_methods: [])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:low)
+      end
+
+      it 'is :low when total is 3' do
+        proposal = create_proposal(helpers: [{ name: 'h1' }, { name: 'h2' }], runner_methods: [{ name: 'r1' }])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:low)
+      end
+
+      it 'is :medium when total is 4' do
+        helpers = Array.new(2) { |i| { name: "h#{i}" } }
+        runners = Array.new(2) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:medium)
+      end
+
+      it 'is :medium when total is 6' do
+        helpers = Array.new(3) { |i| { name: "h#{i}" } }
+        runners = Array.new(3) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:medium)
+      end
+
+      it 'is :high when total is 7' do
+        helpers = Array.new(4) { |i| { name: "h#{i}" } }
+        runners = Array.new(3) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:high)
+      end
+
+      it 'is :high when total > 7' do
+        helpers = Array.new(5) { |i| { name: "h#{i}" } }
+        runners = Array.new(5) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:complexity]).to eq(:high)
+      end
+    end
+
+    # ── blast_radius dimension ────────────────────────────────────────────
+
+    context 'blast_radius based on category' do
+      it 'is :high for :safety category' do
+        proposal = create_proposal(category: :safety)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:high)
+      end
+
+      it 'is :high for :coordination category' do
+        proposal = create_proposal(name: 'lex-coord', category: :coordination)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:high)
+      end
+
+      it 'is :medium for :cognition category' do
+        proposal = create_proposal(category: :cognition)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:medium)
+      end
+
+      it 'is :low for :communication category' do
+        proposal = create_proposal(name: 'lex-comm', category: :communication)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:low)
+      end
+
+      it 'is :low for :motivation category' do
+        proposal = create_proposal(name: 'lex-motiv', category: :motivation)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:low)
+      end
+
+      it 'is :low for :introspection category' do
+        proposal = create_proposal(name: 'lex-intro', category: :introspection)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:blast_radius]).to eq(:low)
+      end
+    end
+
+    # ── performance_impact dimension ──────────────────────────────────────
+
+    context 'performance_impact based on category' do
+      it 'is :medium for :perception category (hot path)' do
+        proposal = create_proposal(name: 'lex-perc', category: :perception)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:performance_impact]).to eq(:medium)
+      end
+
+      it 'is :medium for :memory category (hot path)' do
+        proposal = create_proposal(name: 'lex-mem', category: :memory)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:performance_impact]).to eq(:medium)
+      end
+
+      it 'is :low for :cognition category' do
+        proposal = create_proposal(category: :cognition)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:performance_impact]).to eq(:low)
+      end
+
+      it 'is :low for :safety category' do
+        proposal = create_proposal(category: :safety)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:dimensions][:performance_impact]).to eq(:low)
+      end
+    end
+
+    # ── risk_tier calculation ─────────────────────────────────────────────
+
+    context 'risk tier calculation' do
+      it 'is :low when all dimensions are low (communication, few helpers)' do
+        proposal = create_proposal(name: 'lex-low', category: :communication,
+                                   helpers: [], runner_methods: [])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:risk_tier]).to eq(:low)
+        expect(result[:recommendation]).to eq(:auto_approve)
+      end
+
+      it 'is :medium when any dimension is medium (cognition with low complexity)' do
+        proposal = create_proposal(category: :cognition, helpers: [], runner_methods: [])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        # cognition => blast_radius :medium
+        expect(result[:risk_tier]).to eq(:medium)
+        expect(result[:recommendation]).to eq(:governance)
+      end
+
+      it 'is :medium when perception category with low complexity' do
+        proposal = create_proposal(name: 'lex-perc2', category: :perception,
+                                   helpers: [], runner_methods: [])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        # perception => performance_impact :medium
+        expect(result[:risk_tier]).to eq(:medium)
+      end
+
+      it 'is :high when blast_radius is :high (safety category)' do
+        proposal = create_proposal(category: :safety)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:risk_tier]).to eq(:high)
+        expect(result[:recommendation]).to eq(:human_required)
+      end
+
+      it 'is :high when blast_radius is :high (coordination category)' do
+        proposal = create_proposal(name: 'lex-coord2', category: :coordination)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:risk_tier]).to eq(:high)
+      end
+
+      it 'is :high when complexity is :high (7+ helpers+runners)' do
+        helpers = Array.new(4) { |i| { name: "h#{i}" } }
+        runners = Array.new(4) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(name: 'lex-complex', category: :communication,
+                                   helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:risk_tier]).to eq(:high)
+      end
+
+      it 'is :high (not :medium) when both blast_radius and complexity are high' do
+        helpers = Array.new(4) { |i| { name: "h#{i}" } }
+        runners = Array.new(4) { |i| { name: "r#{i}" } }
+        proposal = create_proposal(name: 'lex-worst', category: :safety,
+                                   helpers: helpers, runner_methods: runners)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:risk_tier]).to eq(:high)
+      end
+    end
+
+    # ── recommendation mapping ────────────────────────────────────────────
+
+    context 'recommendation mapping' do
+      it 'maps :low tier to :auto_approve' do
+        proposal = create_proposal(name: 'lex-auto', category: :communication,
+                                   helpers: [], runner_methods: [])
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:recommendation]).to eq(:auto_approve)
+      end
+
+      it 'maps :medium tier to :governance' do
+        proposal = create_proposal(category: :cognition)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:recommendation]).to eq(:governance)
+      end
+
+      it 'maps :high tier to :human_required' do
+        proposal = create_proposal(category: :safety)
+        result = risk_assessor.assess_risk(proposal_id: proposal.id)
+        expect(result[:recommendation]).to eq(:human_required)
+      end
+    end
+  end
+
+  # ─── risk_summary ─────────────────────────────────────────────────────────
+
+  describe '.risk_summary' do
+    before { proposer.instance_variable_set(:@proposal_store, nil) }
+
+    it 'returns success: true' do
+      result = risk_assessor.risk_summary
+      expect(result[:success]).to be true
+    end
+
+    it 'includes total count' do
+      result = risk_assessor.risk_summary
+      expect(result).to have_key(:total)
+    end
+
+    it 'includes by_tier hash' do
+      result = risk_assessor.risk_summary
+      expect(result[:by_tier]).to be_a(Hash)
+    end
+
+    it 'by_tier includes all risk tiers' do
+      result = risk_assessor.risk_summary
+      Legion::Extensions::MindGrowth::Helpers::Constants::RISK_TIERS.each do |tier|
+        expect(result[:by_tier]).to have_key(tier)
+      end
+    end
+
+    it 'returns total 0 when no proposals exist' do
+      result = risk_assessor.risk_summary
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'all tier arrays are empty when no proposals' do
+      result = risk_assessor.risk_summary
+      result[:by_tier].each_value { |arr| expect(arr).to eq([]) }
+    end
+
+    context 'with proposals in the store' do
+      before do
+        create_proposal(name: 'lex-rs1', category: :communication, helpers: [], runner_methods: [])
+        create_proposal(name: 'lex-rs2', category: :safety, helpers: [], runner_methods: [])
+        create_proposal(name: 'lex-rs3', category: :cognition, helpers: [], runner_methods: [])
+      end
+
+      it 'counts total proposals assessed' do
+        result = risk_assessor.risk_summary
+        expect(result[:total]).to eq(3)
+      end
+
+      it 'places low-risk proposal in :low tier' do
+        result = risk_assessor.risk_summary
+        low_names = result[:by_tier][:low].map { |r| r[:proposal_id] }
+        proposal  = proposer.list_proposals[:proposals].find { |p| p[:name] == 'lex-rs1' }
+        expect(low_names).to include(proposal[:id])
+      end
+
+      it 'places high-risk proposal in :high tier' do
+        result = risk_assessor.risk_summary
+        expect(result[:by_tier][:high].size).to eq(1)
+      end
+
+      it 'places medium-risk proposal in :medium tier' do
+        result = risk_assessor.risk_summary
+        expect(result[:by_tier][:medium].size).to eq(1)
+      end
+    end
+
+    context 'with explicit proposals array' do
+      it 'accepts proposals as array of hashes with :id keys' do
+        proposal = create_proposal(name: 'lex-explicit', category: :communication)
+        result = risk_assessor.risk_summary(proposals: [{ id: proposal.id }])
+        expect(result[:total]).to eq(1)
+      end
+
+      it 'accepts proposals as array of plain id strings' do
+        proposal = create_proposal(name: 'lex-str', category: :communication)
+        result = risk_assessor.risk_summary(proposals: [proposal.id])
+        expect(result[:total]).to eq(1)
+      end
+
+      it 'skips unknown ids gracefully' do
+        result = risk_assessor.risk_summary(proposals: ['nonexistent-id'])
+        expect(result[:total]).to eq(0)
+      end
+    end
+  end
+
+  # ─── constant checks ──────────────────────────────────────────────────────
+
+  describe 'constants' do
+    it 'RISK_TIERS contains :low, :medium, :high, :critical' do
+      expect(Legion::Extensions::MindGrowth::Helpers::Constants::RISK_TIERS)
+        .to contain_exactly(:low, :medium, :high, :critical)
+    end
+
+    it 'RISK_RECOMMENDATIONS maps all tiers' do
+      recs = Legion::Extensions::MindGrowth::Helpers::Constants::RISK_RECOMMENDATIONS
+      expect(recs[:low]).to eq(:auto_approve)
+      expect(recs[:medium]).to eq(:governance)
+      expect(recs[:high]).to eq(:human_required)
+      expect(recs[:critical]).to eq(:blocked)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Esity
@@ -143,10 +143,12 @@ files:
 - lib/legion/extensions/mind_growth/helpers/proposal_store.rb
 - lib/legion/extensions/mind_growth/runners/analyzer.rb
 - lib/legion/extensions/mind_growth/runners/builder.rb
+- lib/legion/extensions/mind_growth/runners/governance.rb
 - lib/legion/extensions/mind_growth/runners/integration_tester.rb
 - lib/legion/extensions/mind_growth/runners/orchestrator.rb
 - lib/legion/extensions/mind_growth/runners/proposer.rb
 - lib/legion/extensions/mind_growth/runners/retrospective.rb
+- lib/legion/extensions/mind_growth/runners/risk_assessor.rb
 - lib/legion/extensions/mind_growth/runners/validator.rb
 - lib/legion/extensions/mind_growth/runners/wirer.rb
 - lib/legion/extensions/mind_growth/version.rb
@@ -160,10 +162,12 @@ files:
 - spec/legion/extensions/mind_growth/helpers/proposal_store_spec.rb
 - spec/legion/extensions/mind_growth/runners/analyzer_spec.rb
 - spec/legion/extensions/mind_growth/runners/builder_spec.rb
+- spec/legion/extensions/mind_growth/runners/governance_spec.rb
 - spec/legion/extensions/mind_growth/runners/integration_tester_spec.rb
 - spec/legion/extensions/mind_growth/runners/orchestrator_spec.rb
 - spec/legion/extensions/mind_growth/runners/proposer_spec.rb
 - spec/legion/extensions/mind_growth/runners/retrospective_spec.rb
+- spec/legion/extensions/mind_growth/runners/risk_assessor_spec.rb
 - spec/legion/extensions/mind_growth/runners/validator_spec.rb
 - spec/legion/extensions/mind_growth/runners/wirer_spec.rb
 - spec/spec_helper.rb