lex-mind-growth 0.2.7 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8f21cd00a0fb432c27fd057addf7294b2d84425c7927d6298bab0c87496d868
-  data.tar.gz: c0a512a778e049b13d5442ab3f72bf513ce5104bc0be3632891eda965b1fa668
+  metadata.gz: d9b428be29ef5df316acb3e4b9d6a01b826168046e1133e50c293e1ecc1a1186
+  data.tar.gz: 7a38b04f5d93dea41f294cb0011a9f74511cd24bfe9687af792edc1940dcfd03
 SHA512:
-  metadata.gz: f772d447b870acf41484209df88a82352e4b27b00a7f30335dfb0b5fee1e26c6cc7b06d6194aaf46d2d7506e55cb7e5d264aa9b005872db00c632f3caea1a4bf
-  data.tar.gz: d4aee3639b1cec1a35015c9a432cb7041715bd3f3ad0571534a9d441ce11e79481a6361e72295076fb06605cc2afd357805e385ff04bf28503302c7f003bcbd5
+  metadata.gz: 33078449b48cf7cae04ceabd91690ae4900f47bc89275aab55005a2f1cb28242e5ef0780ef6321166b09e7b89a79b34b34afbd2d293243807a64c366c5303323
+  data.tar.gz: 6d77136475fc7cde737949355135e60fa90891559f29f02ee71aa522e80d5be82cbbda09e41b16fc4293070eae6c9b0466acd564e1441700c326112905035ef6

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
 
@@ -246,11 +254,15 @@ module Legion
 
           def legacy_implement_file(file_path, proposal)
             stub_content = ::File.read(file_path)
+            prompt = file_implementation_prompt(stub_content, proposal)
 
-            chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning }) # rubocop:disable Legion/HelperMigration/DirectLlm
-            chat.with_instructions(implementation_instructions)
-            response = chat.ask(file_implementation_prompt(stub_content, proposal))
-            code = extract_ruby_code(response.content)
+            response = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+              message: prompt,
+              caller:  { extension: 'lex-mind-growth', operation: 'build' },
+              intent:  { capability: :reasoning }
+            )
+            content = implementation_content(response, prompt)
+            code = extract_ruby_code(content)
 
             ::File.write(file_path, code)
             { success: true, path: file_path }
@@ -298,7 +310,26 @@ module Legion
             parts.join("\n")
           end
 
+          def implementation_content(response, prompt)
+            return response.strip if response.is_a?(String)
+            return response.content if response.respond_to?(:content)
+
+            if response.respond_to?(:ask)
+              response.with_instructions(implementation_instructions) if response.respond_to?(:with_instructions)
+              asked = response.ask(prompt)
+              return implementation_content(asked, prompt)
+            end
+
+            return nil unless response.is_a?(Hash)
+
+            response[:content] || response['content'] ||
+              response.dig(:message, :content) || response.dig('message', 'content') ||
+              response[:response] || response['response']
+          end
+
           def extract_ruby_code(content)
+            return '' unless content
+
             code = if content.match?(/```ruby\s*\n/)
                      content.match(/```ruby\s*\n(.*?)```/m)&.captures&.first || content
                    elsif content.match?(/```\s*\n/)

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

@@ -129,18 +129,35 @@ module Legion
           def llm_suggestions(name, fitness, weaknesses)
             # rubocop:disable Legion/HelperMigration/DirectLlm
             response = Legion::LLM.chat(
-              caller: {
+              message: improvement_prompt(name, fitness, weaknesses),
+              caller:  {
                 extension: 'lex-mind-growth',
                 operation: 'evolver',
                 phase:     'suggest'
               }
-            ).ask(improvement_prompt(name, fitness, weaknesses))
+            )
             # rubocop:enable Legion/HelperMigration/DirectLlm
-            parse_llm_suggestions(response.content)
+            parse_llm_suggestions(llm_content(response, improvement_prompt(name, fitness, weaknesses)))
           rescue StandardError => _e
             nil
           end
 
+          def llm_content(response, prompt)
+            return response.strip if response.is_a?(String)
+            return response.content if response.respond_to?(:content)
+
+            if response.respond_to?(:ask)
+              asked = response.ask(prompt)
+              return llm_content(asked, prompt)
+            end
+
+            return nil unless response.is_a?(Hash)
+
+            response[:content] || response['content'] ||
+              response.dig(:message, :content) || response.dig('message', 'content') ||
+              response[:response] || response['response']
+          end
+
           def improvement_prompt(name, fitness, weaknesses)
             <<~PROMPT
               The LegionIO cognitive extension "#{name}" has a fitness score of #{fitness.round(3)}.
@@ -153,12 +170,14 @@ module Legion
           end
 
           def parse_llm_suggestions(content)
+            return nil unless content
+
             cleaned = content.gsub(/```(?:json)?\s*\n?/, '').strip
             data = ::JSON.parse(cleaned)
             return nil unless data.is_a?(Array)
 
             data.map(&:to_s).reject(&:empty?)
-          rescue ::JSON::ParserError => _e
+          rescue ::JSON::ParserError, NoMethodError => _e
             nil
           end
 

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