lex-mind-growth 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8f21cd00a0fb432c27fd057addf7294b2d84425c7927d6298bab0c87496d868
-  data.tar.gz: c0a512a778e049b13d5442ab3f72bf513ce5104bc0be3632891eda965b1fa668
+  metadata.gz: 3fcaa84f5b0e455b0ac70019228ebe5bffdbd1c69228aafcad9bf92d7f91bb52
+  data.tar.gz: 4ea8b0c108d6bf0a957cd9709147e4cfaa3c78e0b297afc85e642331f9153e4a
 SHA512:
-  metadata.gz: f772d447b870acf41484209df88a82352e4b27b00a7f30335dfb0b5fee1e26c6cc7b06d6194aaf46d2d7506e55cb7e5d264aa9b005872db00c632f3caea1a4bf
-  data.tar.gz: d4aee3639b1cec1a35015c9a432cb7041715bd3f3ad0571534a9d441ce11e79481a6361e72295076fb06605cc2afd357805e385ff04bf28503302c7f003bcbd5
+  metadata.gz: 911dc8e13b4dfe4cb4ee0cd5dd7cd27fc2d93a529aca350cc4d02d4f3f27b9548ac8881945bb57d150ffa8cc8e169e8f62b3590e2bbab4188dbfc0046aa69eb3
+  data.tar.gz: d4f849194085b3b398dd41e3499b686c87b323ab4950a392eaca71133aeb943fcfe68557829a5cb6be92428bf781c90ab53d49cf877f26abe5b699562c25d07e

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module Legion
   module Extensions
     module MindGrowth
@@ -59,6 +61,27 @@ module Legion
             @built_at = Time.now.utc if new_status == :passing
           end
 
+          def self.from_h(hash)
+            h = hash.transform_keys(&:to_sym)
+            proposal = allocate
+            proposal.instance_variable_set(:@id,             h[:id])
+            proposal.instance_variable_set(:@name,           h[:name])
+            proposal.instance_variable_set(:@module_name,    h[:module_name])
+            proposal.instance_variable_set(:@category,       h[:category]&.to_sym)
+            proposal.instance_variable_set(:@description,    h[:description])
+            proposal.instance_variable_set(:@metaphor,       h[:metaphor])
+            proposal.instance_variable_set(:@helpers,        h[:helpers] || [])
+            proposal.instance_variable_set(:@runner_methods, h[:runner_methods] || [])
+            proposal.instance_variable_set(:@rationale,      h[:rationale])
+            proposal.instance_variable_set(:@scores,         (h[:scores] || {}).transform_keys(&:to_sym))
+            proposal.instance_variable_set(:@status,         h[:status]&.to_sym || :proposed)
+            proposal.instance_variable_set(:@origin,         h[:origin]&.to_sym || :proposer)
+            proposal.instance_variable_set(:@created_at,     h[:created_at] ? Time.parse(h[:created_at].to_s) : Time.now.utc)
+            proposal.instance_variable_set(:@evaluated_at,   h[:evaluated_at] ? Time.parse(h[:evaluated_at].to_s) : nil)
+            proposal.instance_variable_set(:@built_at,       h[:built_at] ? Time.parse(h[:built_at].to_s) : nil)
+            proposal
+          end
+
           def to_h
             FIELDS.to_h { |f| [f, send(f)] }
           end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        # Cache-backed persistence for proposals and governance votes.
+        # Best-effort: degrades to in-memory-only when cache is unavailable.
+        class ProposalPersistence
+          PROPOSAL_TTL     = 604_800 # 7 days
+          VOTES_KEY_SUFFIX = ':votes'
+          INDEX_KEY_SUFFIX = ':index'
+
+          def initialize(namespace: 'legion_mind_growth')
+            @namespace = namespace
+          end
+
+          def save_proposal(proposal_hash)
+            return false unless cache_available?
+
+            key = proposal_key(proposal_hash[:id])
+            Legion::Cache.set_sync(key, serialize(proposal_hash), ttl: PROPOSAL_TTL)
+            update_index(proposal_hash[:id], :add)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] save_proposal failed for #{proposal_hash[:id]}: #{e.message}"
+            false
+          end
+
+          def load_proposal(id)
+            return nil unless cache_available?
+
+            raw = Legion::Cache.get(proposal_key(id)) # rubocop:disable Legion/HelperMigration/DirectCache
+            return nil unless raw
+
+            deserialize(raw)
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_proposal failed for #{id}: #{e.message}"
+            nil
+          end
+
+          def delete_proposal(id)
+            return false unless cache_available?
+
+            Legion::Cache.delete_sync(proposal_key(id))
+            update_index(id, :remove)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] delete_proposal failed for #{id}: #{e.message}"
+            false
+          end
+
+          def load_all_proposals
+            return {} unless cache_available?
+
+            ids = load_index
+            return {} if ids.empty?
+
+            ids.each_with_object({}) do |id, result|
+              p = load_proposal(id)
+              result[id] = p if p
+            end
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_all_proposals failed: #{e.message}"
+            {}
+          end
+
+          def delete_all_proposals
+            return false unless cache_available?
+
+            ids = load_index
+            ids.each { |id| Legion::Cache.delete_sync(proposal_key(id)) }
+            Legion::Cache.delete_sync(index_key)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] delete_all_proposals failed: #{e.message}"
+            false
+          end
+
+          def save_votes(votes_hash)
+            return false unless cache_available?
+
+            Legion::Cache.set_sync(votes_key, serialize(votes_hash), ttl: PROPOSAL_TTL)
+            true
+          rescue StandardError => e
+            log.error "[proposal_persistence] save_votes failed: #{e.message}"
+            false
+          end
+
+          def load_votes
+            return {} unless cache_available?
+
+            raw = Legion::Cache.get(votes_key) # rubocop:disable Legion/HelperMigration/DirectCache
+            return {} unless raw
+
+            result = deserialize(raw)
+            result.is_a?(Hash) ? result : {}
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_votes failed: #{e.message}"
+            {}
+          end
+
+          private
+
+          def cache_available?
+            defined?(Legion::Cache) && Legion::Cache.connected? # rubocop:disable Legion/HelperMigration/DirectCache
+          end
+
+          def proposal_key(id) = "#{@namespace}:proposal:#{id}"
+          def votes_key        = "#{@namespace}#{VOTES_KEY_SUFFIX}"
+          def index_key        = "#{@namespace}#{INDEX_KEY_SUFFIX}"
+
+          def update_index(id, operation)
+            ids = load_index
+            case operation
+            when :add    then ids << id unless ids.include?(id)
+            when :remove then ids.delete(id)
+            end
+            Legion::Cache.set_sync(index_key, serialize(ids), ttl: PROPOSAL_TTL)
+          end
+
+          def load_index
+            raw = Legion::Cache.get(index_key) # rubocop:disable Legion/HelperMigration/DirectCache
+            return [] unless raw
+
+            result = deserialize(raw)
+            result.is_a?(Array) ? result : []
+          rescue StandardError => e
+            log.error "[proposal_persistence] load_index failed: #{e.message}"
+            []
+          end
+
+          def serialize(obj)
+            Legion::JSON.dump(obj) # rubocop:disable Legion/HelperMigration/DirectJson
+          end
+
+          def deserialize(raw)
+            return raw if raw.is_a?(Hash) || raw.is_a?(Array)
+
+            Legion::JSON.load(raw) # rubocop:disable Legion/HelperMigration/DirectJson
+          rescue StandardError => _e
+            nil
+          end
+
+          def log
+            Legion::Logging
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,15 +7,18 @@ module Legion
         class ProposalStore
           MAX_PROPOSALS = 500
 
-          def initialize
-            @proposals = {}
-            @mutex     = Mutex.new
+          def initialize(rehydrate: true)
+            @proposals   = {}
+            @mutex       = Mutex.new
+            @persistence = ProposalPersistence.new
+            rehydrate_from_cache if rehydrate
           end
 
           def store(proposal)
             @mutex.synchronize do
               evict_oldest if @proposals.size >= MAX_PROPOSALS
               @proposals[proposal.id] = proposal
+              @persistence.save_proposal(proposal.to_h)
             end
           end
 
@@ -23,6 +26,13 @@ module Legion
             @mutex.synchronize { @proposals[id] }
           end
 
+          def update(proposal)
+            @mutex.synchronize do
+              @proposals[proposal.id] = proposal
+              @persistence.save_proposal(proposal.to_h)
+            end
+          end
+
           def all
             @mutex.synchronize { @proposals.values.dup }
           end
@@ -58,11 +68,36 @@ module Legion
             @mutex.synchronize { @proposals.clear }
           end
 
+          def clear_persisted!
+            @mutex.synchronize do
+              @proposals.clear
+              @persistence.delete_all_proposals
+            end
+          end
+
           private
 
           def evict_oldest
             oldest = @proposals.values.min_by { |p| p.created_at.to_f }
-            @proposals.delete(oldest.id) if oldest
+            return unless oldest
+
+            @proposals.delete(oldest.id)
+            @persistence.delete_proposal(oldest.id)
+          end
+
+          def rehydrate_from_cache
+            cached = @persistence.load_all_proposals
+            cached.each do |id, hash|
+              proposal = ConceptProposal.from_h(hash)
+              @proposals[id] = proposal
+            end
+            log.info "[proposal_store] rehydrated #{cached.size} proposals from cache" unless cached.empty?
+          rescue StandardError => e
+            log.error "[proposal_store] rehydrate_from_cache failed: #{e.message}"
+          end
+
+          def log
+            Legion::Logging
           end
         end
       end

data/lib/legion/extensions/mind_growth/hooks/governance_listener.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Hooks
+        module GovernanceListener
+          module_function
+
+          def register
+            return unless defined?(Legion::Events)
+
+            Legion::Events.on('governance.quorum_reached') do |event|
+              next unless event[:verdict] == :approved
+
+              base_path = event[:base_path] || GovernanceListener.configured_base_path
+              GovernanceListener.log.info "[governance_listener] quorum approved for #{event[:proposal_id]}, triggering build"
+              Runners::Governance.governance_resolved(proposal_id: event[:proposal_id], base_path: base_path)
+            end
+          end
+
+          def configured_base_path
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:mind_growth, :base_path)
+          rescue StandardError => e
+            log.debug "[governance_listener] configured_base_path failed: #{e.message}"
+            nil
+          end
+
+          def log
+            Legion::Logging
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,7 @@ module Legion
 
             pipeline = Helpers::BuildPipeline.new(proposal)
             proposal.transition!(:building)
+            persist_proposal(proposal)
             base_path ||= ::Dir.pwd
 
             run_stage(pipeline, :scaffold,  -> { scaffold_stage(proposal, base_path) })
@@ -25,6 +26,7 @@ module Legion
             run_stage(pipeline, :register,  -> { register_stage(proposal) }) unless pipeline.failed?
 
             proposal.transition!(pipeline.complete? ? :passing : :build_failed)
+            persist_proposal(proposal)
             log.info "[mind_growth:builder] #{proposal.name}: #{pipeline.stage}"
             { success: pipeline.complete?, pipeline: pipeline.to_h, proposal: proposal.to_h }
           rescue ArgumentError => e
@@ -46,6 +48,12 @@ module Legion
             Runners::Proposer.get_proposal_object(proposal_id)
           end
 
+          def persist_proposal(proposal)
+            return unless defined?(Runners::Proposer) && Runners::Proposer.respond_to?(:persist_proposal)
+
+            Runners::Proposer.persist_proposal(proposal)
+          end
+
           def run_stage(pipeline, stage, callable)
             return if pipeline.stage != stage
 

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

@@ -19,6 +19,7 @@ module Legion
             return { success: false, error: :invalid_status, current_status: proposal.status } unless %i[proposed evaluating].include?(proposal.status)
 
             proposal.transition!(:evaluating)
+            Runners::Proposer.persist_proposal(proposal)
             { success: true, proposal_id: proposal_id, status: :evaluating }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -28,15 +29,54 @@ module Legion
             vote_sym = vote.to_sym
             return { success: false, error: :invalid_vote } unless VOTE_VALUES.include?(vote_sym)
 
-            votes_mutex.synchronize do
+            snapshot = 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 }
+              votes_store.transform_values(&:dup)
+            end
+
+            Helpers::ProposalPersistence.new.save_votes(snapshot)
+
+            tally = tally_votes(proposal_id: proposal_id)
+            if tally[:verdict] != :pending
+              log.info "[governance] quorum reached for #{proposal_id}: #{tally[:verdict]}"
+              if defined?(Legion::Events)
+                Legion::Events.emit('governance.quorum_reached',
+                                    proposal_id: proposal_id, verdict: tally[:verdict])
+              end
+              return { success: true, proposal_id: proposal_id, vote: vote_sym,
+                       agent_id: agent_id.to_s, verdict: tally[:verdict], quorum_reached: true }
             end
 
             { success: true, proposal_id: proposal_id, vote: vote_sym, agent_id: agent_id.to_s }
           end
 
+          def governance_resolved(proposal_id:, base_path: nil, **)
+            tally = tally_votes(proposal_id: proposal_id)
+            return { action: :tally_failed } unless tally[:success]
+
+            case tally[:verdict]
+            when :approved
+              log.info "[governance] build triggered for #{proposal_id}"
+              build_result = Runners::Builder.build_extension(proposal_id: proposal_id, base_path: base_path)
+              { action: :build_triggered, build: build_result, tally: tally }
+            when :rejected
+              log.info "[governance] proposal rejected: #{proposal_id}"
+              proposal = Runners::Proposer.get_proposal_object(proposal_id)
+              if proposal
+                proposal.transition!(:rejected)
+                Runners::Proposer.persist_proposal(proposal)
+              end
+              { action: :rejected, tally: tally }
+            else
+              { action: :pending, tally: tally }
+            end
+          rescue StandardError => e
+            log.error "[governance] governance_resolved failed for #{proposal_id}: #{e.message}"
+            { action: :error, error: e.message }
+          end
+
           def tally_votes(proposal_id:, **)
             ballots = votes_mutex.synchronize { (votes_store[proposal_id] || []).dup }
 
@@ -61,6 +101,7 @@ module Legion
             return { success: false, error: :not_found } unless proposal
 
             proposal.transition!(:approved)
+            Runners::Proposer.persist_proposal(proposal)
             { success: true, proposal_id: proposal_id, status: :approved }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -71,6 +112,7 @@ module Legion
             return { success: false, error: :not_found } unless proposal
 
             proposal.transition!(:rejected)
+            Runners::Proposer.persist_proposal(proposal)
             { success: true, proposal_id: proposal_id, status: :rejected, reason: reason }
           rescue ArgumentError => e
             { success: false, error: e.message }
@@ -109,7 +151,11 @@ module Legion
           private
 
           def votes_store
-            @votes_store ||= {}
+            @votes_store ||= begin
+              persistence = Helpers::ProposalPersistence.new
+              cached      = persistence.load_votes
+              cached.empty? ? {} : cached.transform_keys(&:to_s)
+            end
           end
 
           def votes_mutex

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

@@ -76,8 +76,104 @@ module Legion
               model_coverage: profile[:model_coverage]&.map { |m| { model: m[:model], coverage: m[:coverage] } } }
           end
 
+          def post_build_pipeline(proposal_id:, base_path: nil, **) # rubocop:disable Lint/UnusedMethodArgument
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, skipped: true, reason: 'proposal not found' } unless proposal
+            return { success: false, skipped: true, reason: "not in :passing state (is #{proposal.status})" } unless proposal.status == :passing
+
+            result = { proposal_id: proposal_id }
+
+            log.info "[orchestrator] wiring proposal #{proposal_id}"
+            wire_result = wire_proposal(proposal)
+            result[:wire] = wire_result
+
+            gaia_wire_skip = wire_result[:reason] == :gaia_not_available
+            wire_failed    = !gaia_wire_skip && wire_result[:success] == false
+
+            if wire_failed
+              log.warn "[orchestrator] wiring failed for #{proposal_id}: #{wire_result[:reason]}"
+              result[:activated] = false
+              result[:success]   = false
+              result[:reason]    = :wire_failed
+              return result
+            end
+
+            if gaia_wire_skip
+              log.info "[orchestrator] wiring skipped for #{proposal_id} (GAIA unavailable)"
+            else
+              proposal.transition!(:wired)
+              Runners::Proposer.persist_proposal(proposal)
+            end
+
+            log.info "[orchestrator] testing proposal #{proposal_id}"
+            test_result = test_proposal(proposal)
+            result[:integration_test] = test_result
+
+            if test_result[:reason] == :gaia_not_available
+              log.info "[orchestrator] integration test skipped for #{proposal_id} (GAIA unavailable)"
+              result[:success]   = false
+              result[:activated] = false
+              result[:reason]    = :gaia_not_available
+              return result
+            end
+
+            if test_result[:success] == false
+              proposal.transition!(:degraded)
+              Runners::Proposer.persist_proposal(proposal)
+              result[:activated] = false
+              result[:success]   = false
+              log.info "[orchestrator] proposal #{proposal_id} degraded after integration test"
+            else
+              proposal.transition!(:active)
+              Runners::Proposer.persist_proposal(proposal)
+              result[:activated] = true
+              result[:success]   = true
+              log.info "[orchestrator] proposal #{proposal_id} activated"
+            end
+
+            result
+          rescue StandardError => e
+            log.error "[orchestrator] post_build_pipeline failed for #{proposal_id}: #{e.message}"
+            { success: false, error: e.message }
+          end
+
           private
 
+          def wire_proposal(proposal)
+            phase = Helpers::PhaseAllocator.allocate_phase(
+              category:       proposal.category,
+              runner_methods: proposal.runner_methods
+            )
+            log.info "[orchestrator] wiring #{proposal.name} into tick phase #{phase[:phase]}"
+            Runners::Wirer.wire_extension(
+              extension_name: proposal.name,
+              ext_module:     proposal.module_name,
+              runner_module:  "#{proposal.module_name}::Runners",
+              fn:             proposal.runner_methods&.first&.dig(:name) || 'status',
+              phase:          phase[:phase]
+            )
+          rescue StandardError => e
+            log.error "[orchestrator] wire_proposal failed for #{proposal.name}: #{e.message}"
+            { success: false, reason: e.message }
+          end
+
+          def test_proposal(proposal)
+            log.info "[orchestrator] running integration test for #{proposal.name}"
+            phase = Helpers::PhaseAllocator.allocate_phase(
+              category:       proposal.category,
+              runner_methods: proposal.runner_methods
+            )
+            Runners::IntegrationTester.test_extension_in_tick(
+              ext_module:    proposal.module_name,
+              runner_module: "#{proposal.module_name}::Runners",
+              fn:            proposal.runner_methods&.first&.dig(:name) || 'status',
+              phase:         phase[:phase]
+            )
+          rescue StandardError => e
+            log.error "[orchestrator] test_proposal failed for #{proposal.name}: #{e.message}"
+            { success: false, reason: e.message }
+          end
+
           def propose_from_priorities(priorities, max)
             priorities.first(max).filter_map do |priority_name|
               name = "lex-#{priority_name.to_s.tr('_', '-')}"
@@ -126,6 +222,13 @@ module Legion
                                  succeeded: builds.count { |b| b[:success] },
                                  failed:    builds.count { |b| !b[:success] },
                                  held:      force ? 0 : held_count }
+              builds.each do |build|
+                next unless build[:success]
+
+                proposal_id = build[:proposal]&.dig(:id) || build[:proposal_id]
+                post_result = post_build_pipeline(proposal_id: proposal_id, base_path: base_path)
+                trace[:steps] << { step: :post_build, proposal_id: proposal_id, result: post_result }
+              end
               nil
             end
           end

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

@@ -61,6 +61,7 @@ module Legion
 
             eval_scores = scores || score_with_llm(proposal) || default_scores
             proposal.evaluate!(eval_scores)
+            proposal_store.update(proposal)
             log.info "[mind_growth:proposer] evaluated #{proposal.name}: #{proposal.status}"
             { success: true, proposal: proposal.to_h, approved: proposal.status == :approved,
               auto_approved: proposal.auto_approvable? }
@@ -81,6 +82,10 @@ module Legion
             proposal_store.get(id)
           end
 
+          def persist_proposal(proposal)
+            proposal_store.update(proposal)
+          end
+
           private
 
           def proposal_store

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.2.7'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -5,6 +5,7 @@ require 'securerandom'
 require 'legion/extensions/mind_growth/version'
 require 'legion/extensions/mind_growth/helpers/constants'
 require 'legion/extensions/mind_growth/helpers/concept_proposal'
+require 'legion/extensions/mind_growth/helpers/proposal_persistence'
 require 'legion/extensions/mind_growth/helpers/proposal_store'
 require 'legion/extensions/mind_growth/helpers/cognitive_models'
 require 'legion/extensions/mind_growth/helpers/build_pipeline'
@@ -19,6 +20,8 @@ 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/hooks/governance_listener'
+Legion::Extensions::MindGrowth::Hooks::GovernanceListener.register
 require 'legion/extensions/mind_growth/runners/risk_assessor'
 require 'legion/extensions/mind_growth/helpers/composition_map'
 require 'legion/extensions/mind_growth/runners/monitor'
@@ -39,6 +42,18 @@ module Legion
       def self.remote_invocable?
         false
       end
+
+      def self.mcp_tools?
+        false
+      end
+
+      def self.mcp_tools_deferred?
+        false
+      end
+
+      def self.transport_required?
+        false
+      end
     end
   end
 end

data/spec/legion/extensions/mind_growth/helpers/constants_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::Constants do
+  describe 'PROPOSAL_STATUSES' do
+    subject(:statuses) { described_class::PROPOSAL_STATUSES }
+
+    it 'is frozen' do
+      expect(statuses).to be_frozen
+    end
+
+    it 'contains only symbols' do
+      expect(statuses).to all(be_a(Symbol))
+    end
+
+    # Full lifecycle:
+    #   proposed → evaluating → approved → building → testing → passing → wired → active
+    #                          → rejected                      → build_failed
+    #                                                                       → degraded
+    #                                                                       → pruned
+    let(:full_lifecycle_states) do
+      %i[proposed evaluating approved rejected building testing passing wired active degraded pruned build_failed]
+    end
+
+    it 'includes every state in the full proposal lifecycle' do
+      full_lifecycle_states.each do |state|
+        expect(statuses).to include(state), "expected PROPOSAL_STATUSES to include :#{state}"
+      end
+    end
+
+    it 'includes the primary happy-path states in order' do
+      happy_path = %i[proposed evaluating approved building testing passing wired active]
+      expect(statuses).to include(*happy_path)
+    end
+
+    it 'includes the rejection terminal state' do
+      expect(statuses).to include(:rejected)
+    end
+
+    it 'includes the build_failed terminal state' do
+      expect(statuses).to include(:build_failed)
+    end
+
+    it 'includes degraded and pruned operational states' do
+      expect(statuses).to include(:degraded, :pruned)
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/helpers/proposal_persistence_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::ProposalPersistence do
+  subject(:persistence) { described_class.new(namespace: 'test_proposals') }
+
+  before do
+    stub_const('Legion::Cache', Class.new do
+      def self.connected? = true
+      def self.get(key) = (@store ||= {})[key]
+      def self.set_sync(key, value, **) = ((@store ||= {})[key] = value)
+      def self.delete_sync(key)      = (@store ||= {}).delete(key)
+      def self.flush                 = (@store = {})
+    end)
+    Legion::Cache.flush
+  end
+
+  describe '#save_proposal / #load_proposal' do
+    it 'round-trips a proposal hash' do
+      proposal_hash = { id: 'p-001', name: 'lex-test', module_name: 'Test',
+                        category: :cognition, description: 'test', status: :approved,
+                        scores: { novelty: 0.8 }, created_at: Time.now.utc.to_s }
+      persistence.save_proposal(proposal_hash)
+      loaded = persistence.load_proposal('p-001')
+      expect(loaded[:name]).to eq('lex-test')
+      # JSON round-trip preserves string values; from_h converts to symbols at rehydration
+      expect(loaded[:status].to_sym).to eq(:approved)
+    end
+
+    it 'returns nil for an unknown id' do
+      expect(persistence.load_proposal('no-such-id')).to be_nil
+    end
+
+    it 'adds the id to the index on save' do
+      persistence.save_proposal({ id: 'p-001', name: 'one' })
+      all = persistence.load_all_proposals
+      # IDs are stored as strings; key may be string or symbol depending on JSON parse
+      expect(all.transform_keys(&:to_s)).to have_key('p-001')
+    end
+  end
+
+  describe '#delete_proposal' do
+    it 'removes the proposal from cache' do
+      persistence.save_proposal({ id: 'p-del', name: 'delete-me' })
+      persistence.delete_proposal('p-del')
+      expect(persistence.load_proposal('p-del')).to be_nil
+    end
+
+    it 'removes the id from the index' do
+      persistence.save_proposal({ id: 'p-del', name: 'delete-me' })
+      persistence.delete_proposal('p-del')
+      all_str = persistence.load_all_proposals.transform_keys(&:to_s)
+      expect(all_str).not_to have_key('p-del')
+    end
+  end
+
+  describe '#save_votes / #load_votes' do
+    it 'round-trips governance votes' do
+      votes = { 'p-001' => [{ vote: :approve, agent_id: 'a1', cast_at: Time.now.utc.to_s }] }
+      persistence.save_votes(votes)
+      loaded = persistence.load_votes
+      # JSON round-trip: top-level keys become symbols, vote values are strings
+      ballot = (loaded[:'p-001'] || loaded['p-001']).first
+      expect(ballot[:vote].to_sym).to eq(:approve)
+    end
+
+    it 'returns empty hash when no votes are stored' do
+      expect(persistence.load_votes).to eq({})
+    end
+  end
+
+  describe '#load_all_proposals' do
+    it 'returns all persisted proposals' do
+      persistence.save_proposal({ id: 'p-001', name: 'one', status: :approved })
+      persistence.save_proposal({ id: 'p-002', name: 'two', status: :proposed })
+      all = persistence.load_all_proposals
+      expect(all.size).to eq(2)
+    end
+
+    it 'returns an empty hash when nothing is stored' do
+      expect(persistence.load_all_proposals).to eq({})
+    end
+
+    it 'does not include deleted proposals' do
+      persistence.save_proposal({ id: 'p-001', name: 'one' })
+      persistence.save_proposal({ id: 'p-002', name: 'two' })
+      persistence.delete_proposal('p-001')
+      all = persistence.load_all_proposals
+      expect(all.size).to eq(1)
+      expect(all.transform_keys(&:to_s)).to have_key('p-002')
+    end
+  end
+
+  describe 'when cache unavailable' do
+    before { allow(Legion::Cache).to receive(:connected?).and_return(false) }
+
+    it 'degrades gracefully on load_proposal' do
+      expect(persistence.load_proposal('p-001')).to be_nil
+    end
+
+    it 'degrades gracefully on save_proposal' do
+      expect(persistence.save_proposal({ id: 'x' })).to be false
+    end
+
+    it 'degrades gracefully on delete_proposal' do
+      expect(persistence.delete_proposal('x')).to be false
+    end
+
+    it 'degrades gracefully on load_votes' do
+      expect(persistence.load_votes).to eq({})
+    end
+
+    it 'degrades gracefully on save_votes' do
+      expect(persistence.save_votes({ 'p' => [] })).to be false
+    end
+
+    it 'degrades gracefully on load_all_proposals' do
+      expect(persistence.load_all_proposals).to eq({})
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/hooks/governance_callback_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Governance callback triggers build' do
+  let(:governance) { Legion::Extensions::MindGrowth::Runners::Governance }
+  let(:proposer) { Legion::Extensions::MindGrowth::Runners::Proposer }
+
+  before { proposer.instance_variable_set(:@proposal_store, nil) }
+
+  describe '.governance_resolved' do
+    it 'triggers build when quorum approves' do
+      proposal = proposer.propose_concept(name: 'lex-test-governance', category: :cognition,
+                                          description: 'test governance callback', enrich: false)
+      proposal_id = proposal[:proposal][:id]
+      proposer.evaluate_proposal(proposal_id: proposal_id,
+                                 scores:      { novelty: 0.7, fit: 0.7, cognitive_value: 0.7,
+                                           implementability: 0.7, composability: 0.7 })
+      governance.instance_variable_set(:@votes_store, {})
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'agent-1')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'agent-2')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'agent-3')
+
+      resolved = governance.governance_resolved(proposal_id: proposal_id)
+      expect(resolved[:action]).to eq(:build_triggered)
+    end
+
+    it 'does not trigger build when quorum rejects' do
+      proposal = proposer.propose_concept(name: 'lex-test-rejected', category: :cognition,
+                                          description: 'test rejected', enrich: false)
+      proposal_id = proposal[:proposal][:id]
+      proposer.evaluate_proposal(proposal_id: proposal_id,
+                                 scores:      { novelty: 0.7, fit: 0.7, cognitive_value: 0.7,
+                                           implementability: 0.7, composability: 0.7 })
+      governance.instance_variable_set(:@votes_store, {})
+      3.times { |i| governance.vote_on_proposal(proposal_id: proposal_id, vote: :reject, agent_id: "a#{i}") }
+      resolved = governance.governance_resolved(proposal_id: proposal_id)
+      expect(resolved[:action]).to eq(:rejected)
+    end
+
+    it 'returns pending when quorum not reached' do
+      governance.instance_variable_set(:@votes_store, {})
+      governance.vote_on_proposal(proposal_id: 'fake-id', vote: :approve, agent_id: 'agent-1')
+      resolved = governance.governance_resolved(proposal_id: 'fake-id')
+      expect(resolved[:action]).to eq(:pending)
+    end
+  end
+
+  describe 'event listener registration' do
+    it 'registers a listener for governance.quorum_reached' do
+      events_spy = Class.new do
+        attr_reader :registered
+
+        def initialize
+          @registered = []
+        end
+
+        def on(event, &block)
+          @registered << { event: event, block: block }
+        end
+
+        def emit(*)
+          nil
+        end
+      end.new
+      stub_const('Legion::Events', events_spy)
+      Legion::Extensions::MindGrowth::Hooks::GovernanceListener.register
+      expect(events_spy.registered.map { |r| r[:event] }).to include('governance.quorum_reached')
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/integration_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Self-Improvement Pipeline Integration' do
+  let(:orchestrator) { Legion::Extensions::MindGrowth::Runners::Orchestrator }
+  let(:proposer) { Legion::Extensions::MindGrowth::Runners::Proposer }
+  let(:governance) { Legion::Extensions::MindGrowth::Runners::Governance }
+
+  before do
+    proposer.instance_variable_set(:@proposal_store, nil)
+    governance.instance_variable_set(:@votes_store, nil)
+    governance.instance_variable_set(:@votes_mutex, nil)
+  end
+
+  describe 'auto-approve path (force: true bypasses governance)' do
+    it 'runs analyze → propose → evaluate → build' do
+      result = orchestrator.run_growth_cycle(
+        existing_extensions: [],
+        max_proposals:       1,
+        force:               true
+      )
+
+      expect(result[:success]).to be true
+      trace = result[:trace]
+
+      step_names = trace[:steps].map { |s| s[:step] }
+      expect(step_names).to include(:analyze)
+      expect(step_names).to include(:propose)
+      expect(step_names).to include(:evaluate)
+      expect(step_names).to include(:build)
+    end
+
+    it 'build step attempts at least one build when force: true' do
+      result = orchestrator.run_growth_cycle(
+        existing_extensions: [],
+        max_proposals:       1,
+        force:               true
+      )
+      build_step = result[:trace][:steps].find { |s| s[:step] == :build }
+      expect(build_step[:attempted]).to be > 0
+    end
+
+    it 'holds proposals for governance review when force is false (default scores 0.7)' do
+      result = orchestrator.run_growth_cycle(
+        existing_extensions: [],
+        max_proposals:       1,
+        force:               false
+      )
+
+      expect(result[:success]).to be true
+      build_step = result[:trace][:steps].find { |s| s[:step] == :build }
+      expect(build_step[:held]).to be > 0
+      expect(build_step[:attempted]).to eq(0)
+    end
+  end
+
+  describe 'governance path (scores 0.6-0.9)' do
+    it 'holds proposal, then resolves to build_triggered on approve quorum' do
+      prop = proposer.propose_concept(
+        name: 'lex-gov-test', category: :cognition,
+        description: 'governance path test', enrich: false
+      )
+      proposal_id = prop[:proposal][:id]
+
+      proposer.evaluate_proposal(
+        proposal_id: proposal_id,
+        scores:      { novelty: 0.7, fit: 0.7, cognitive_value: 0.7,
+                  implementability: 0.7, composability: 0.7 }
+      )
+
+      proposal = proposer.get_proposal_object(proposal_id)
+      expect(proposal.status).to eq(:approved)
+      expect(proposal.auto_approvable?).to be false
+
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'a1')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'a2')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :approve, agent_id: 'a3')
+
+      resolved = governance.governance_resolved(proposal_id: proposal_id)
+      expect(resolved[:action]).to eq(:build_triggered)
+    end
+  end
+
+  describe 'post-build pipeline' do
+    it 'transitions from passing through wire to activation' do
+      prop = proposer.propose_concept(
+        name: 'lex-postbuild-test', category: :safety,
+        description: 'post-build test', enrich: false
+      )
+      proposal_id = prop[:proposal][:id]
+
+      proposer.evaluate_proposal(proposal_id: proposal_id,
+                                 scores:      { novelty: 0.95, fit: 0.95, cognitive_value: 0.95,
+                                           implementability: 0.95, composability: 0.95 })
+
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      allow(Legion::Extensions::MindGrowth::Runners::Wirer)
+        .to receive(:wire_extension)
+        .and_return({ success: true, extension: proposal.name, phase: :safety })
+      allow(Legion::Extensions::MindGrowth::Runners::IntegrationTester)
+        .to receive(:test_extension_in_tick)
+        .and_return({ success: true, phase: :safety_integration })
+
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result).to have_key(:wire)
+      expect(result).to have_key(:integration_test)
+
+      proposal = proposer.get_proposal_object(proposal_id)
+      expect(proposal.status).to eq(:active)
+    end
+  end
+
+  describe 'rejection path' do
+    it 'rejects proposal when governance votes against' do
+      prop = proposer.propose_concept(
+        name: 'lex-reject-test', category: :cognition,
+        description: 'rejection test', enrich: false
+      )
+      proposal_id = prop[:proposal][:id]
+
+      proposer.evaluate_proposal(proposal_id: proposal_id,
+                                 scores:      { novelty: 0.7, fit: 0.7, cognitive_value: 0.7,
+                                           implementability: 0.7, composability: 0.7 })
+
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :reject, agent_id: 'a1')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :reject, agent_id: 'a2')
+      governance.vote_on_proposal(proposal_id: proposal_id, vote: :reject, agent_id: 'a3')
+
+      resolved = governance.governance_resolved(proposal_id: proposal_id)
+      expect(resolved[:action]).to eq(:rejected)
+
+      proposal = proposer.get_proposal_object(proposal_id)
+      expect(proposal.status).to eq(:rejected)
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Orchestrator full cycle with wire + test + activate' do
+  let(:orchestrator) { Legion::Extensions::MindGrowth::Runners::Orchestrator }
+  let(:proposer) { Legion::Extensions::MindGrowth::Runners::Proposer }
+
+  before { proposer.instance_variable_set(:@proposal_store, nil) }
+
+  describe '.post_build_pipeline' do
+    it 'calls wire_extension after successful build' do
+      prop_result = proposer.propose_concept(name: 'lex-test-wire', category: :cognition,
+                                             description: 'test wiring', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      proposer.evaluate_proposal(
+        proposal_id: proposal_id,
+        scores:      { novelty: 0.95, fit: 0.95, cognitive_value: 0.95,
+                       implementability: 0.95, composability: 0.95 }
+      )
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result).to have_key(:wire)
+      expect(result).to have_key(:integration_test)
+    end
+
+    it 'skips wire for non-passing proposals' do
+      prop_result = proposer.propose_concept(name: 'lex-test-skip', category: :cognition,
+                                             description: 'test skip', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result[:skipped]).to be true
+      expect(result[:reason]).to include('not in :passing')
+    end
+
+    it 'returns skipped: true for unknown proposal_id' do
+      result = orchestrator.post_build_pipeline(proposal_id: 'nonexistent-id')
+      expect(result[:skipped]).to be true
+      expect(result[:reason]).to include('proposal not found')
+    end
+
+    it 'includes proposal_id in the result' do
+      prop_result = proposer.propose_concept(name: 'lex-test-id', category: :cognition,
+                                             description: 'test id tracking', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result[:proposal_id]).to eq(proposal_id)
+    end
+
+    it 'transitions to :active when integration test succeeds' do
+      prop_result = proposer.propose_concept(name: 'lex-test-active', category: :cognition,
+                                             description: 'test activation', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      allow(Legion::Extensions::MindGrowth::Runners::Wirer)
+        .to receive(:wire_extension)
+        .and_return({ success: true, extension: proposal.name, phase: :working_memory })
+      allow(Legion::Extensions::MindGrowth::Runners::IntegrationTester)
+        .to receive(:test_extension_in_tick)
+        .and_return({ success: true, phase: :working_memory_integration })
+
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result[:activated]).to be true
+      expect(proposal.status).to eq(:active)
+    end
+
+    it 'transitions to :degraded when integration test fails' do
+      prop_result = proposer.propose_concept(name: 'lex-test-degraded', category: :cognition,
+                                             description: 'test degraded path', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      allow(Legion::Extensions::MindGrowth::Runners::Wirer)
+        .to receive(:wire_extension)
+        .and_return({ success: true, extension: proposal.name, phase: :working_memory })
+      allow(Legion::Extensions::MindGrowth::Runners::IntegrationTester)
+        .to receive(:test_extension_in_tick)
+        .and_return({ success: false, reason: :runner_not_found })
+
+      result = orchestrator.post_build_pipeline(proposal_id: proposal_id)
+      expect(result[:activated]).to be false
+      expect(proposal.status).to eq(:degraded)
+    end
+
+    it 'ignores unknown keyword arguments' do
+      prop_result = proposer.propose_concept(name: 'lex-test-kwargs', category: :cognition,
+                                             description: 'test kwargs', enrich: false)
+      proposal_id = prop_result[:proposal][:id]
+      proposal = proposer.get_proposal_object(proposal_id)
+      proposal.transition!(:building)
+      proposal.transition!(:passing)
+
+      expect { orchestrator.post_build_pipeline(proposal_id: proposal_id, unknown: :val) }.not_to raise_error
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
@@ -141,7 +141,9 @@ files:
 - lib/legion/extensions/mind_growth/helpers/constants.rb
 - lib/legion/extensions/mind_growth/helpers/fitness_evaluator.rb
 - lib/legion/extensions/mind_growth/helpers/phase_allocator.rb
+- lib/legion/extensions/mind_growth/helpers/proposal_persistence.rb
 - lib/legion/extensions/mind_growth/helpers/proposal_store.rb
+- lib/legion/extensions/mind_growth/hooks/governance_listener.rb
 - lib/legion/extensions/mind_growth/runners/analyzer.rb
 - lib/legion/extensions/mind_growth/runners/builder.rb
 - lib/legion/extensions/mind_growth/runners/competitive_evolver.rb
@@ -167,9 +169,13 @@ files:
 - spec/legion/extensions/mind_growth/helpers/cognitive_models_spec.rb
 - spec/legion/extensions/mind_growth/helpers/composition_map_spec.rb
 - spec/legion/extensions/mind_growth/helpers/concept_proposal_spec.rb
+- spec/legion/extensions/mind_growth/helpers/constants_spec.rb
 - spec/legion/extensions/mind_growth/helpers/fitness_evaluator_spec.rb
 - spec/legion/extensions/mind_growth/helpers/phase_allocator_spec.rb
+- spec/legion/extensions/mind_growth/helpers/proposal_persistence_spec.rb
 - spec/legion/extensions/mind_growth/helpers/proposal_store_spec.rb
+- spec/legion/extensions/mind_growth/hooks/governance_callback_spec.rb
+- spec/legion/extensions/mind_growth/integration_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/competitive_evolver_spec.rb
@@ -182,6 +188,7 @@ files:
 - spec/legion/extensions/mind_growth/runners/integration_tester_spec.rb
 - spec/legion/extensions/mind_growth/runners/monitor_spec.rb
 - spec/legion/extensions/mind_growth/runners/orchestrator_spec.rb
+- spec/legion/extensions/mind_growth/runners/post_build_pipeline_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