lex-mind-growth 0.1.0

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::ProposalStore do
+  subject(:store) { described_class.new }
+
+  let(:proposal) do
+    Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+      name:        'lex-focus',
+      module_name: 'Focus',
+      category:    :cognition,
+      description: 'Focus management'
+    )
+  end
+
+  let(:approved_proposal) do
+    p = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+      name:        'lex-approved',
+      module_name: 'Approved',
+      category:    :memory,
+      description: 'Memory management'
+    )
+    scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.75] }
+    p.evaluate!(scores)
+    p
+  end
+
+  describe '#store and #get' do
+    it 'stores and retrieves a proposal by id' do
+      store.store(proposal)
+      expect(store.get(proposal.id)).to eq(proposal)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.get('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#all' do
+    it 'returns all proposals' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      expect(store.all.size).to eq(2)
+    end
+
+    it 'returns empty array for empty store' do
+      expect(store.all).to eq([])
+    end
+
+    it 'returns a copy (not the internal array)' do
+      store.store(proposal)
+      all = store.all
+      all.clear
+      expect(store.all.size).to eq(1)
+    end
+  end
+
+  describe '#by_status' do
+    it 'returns proposals matching the status' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      proposed = store.by_status(:proposed)
+      expect(proposed.map(&:id)).to include(proposal.id)
+      expect(proposed.map(&:id)).not_to include(approved_proposal.id)
+    end
+
+    it 'returns empty array when no matches' do
+      expect(store.by_status(:building)).to eq([])
+    end
+
+    it 'accepts string status and converts to symbol' do
+      store.store(proposal)
+      expect(store.by_status('proposed')).to include(proposal)
+    end
+  end
+
+  describe '#by_category' do
+    it 'returns proposals matching the category' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      cognition = store.by_category(:cognition)
+      expect(cognition.map(&:id)).to include(proposal.id)
+    end
+
+    it 'accepts string category' do
+      store.store(proposal)
+      expect(store.by_category('cognition')).to include(proposal)
+    end
+  end
+
+  describe '#approved' do
+    it 'returns only approved proposals' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      expect(store.approved.map(&:id)).to eq([approved_proposal.id])
+    end
+  end
+
+  describe '#build_queue' do
+    it 'returns approved proposals sorted by average score descending' do
+      p1 = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+        name: 'lex-low', module_name: 'Low', category: :memory, description: 'low'
+      )
+      p2 = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+        name: 'lex-high', module_name: 'High', category: :cognition, description: 'high'
+      )
+      low_scores  = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.65] }
+      high_scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.85] }
+      p1.evaluate!(low_scores)
+      p2.evaluate!(high_scores)
+      store.store(p1)
+      store.store(p2)
+      queue = store.build_queue
+      expect(queue.first.id).to eq(p2.id)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns proposals sorted by created_at descending' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      recent = store.recent(limit: 5)
+      expect(recent.size).to eq(2)
+    end
+
+    it 'limits results' do
+      5.times do |i|
+        p = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+          name: "lex-#{i}", module_name: "P#{i}", category: :cognition, description: "desc #{i}"
+        )
+        store.store(p)
+      end
+      expect(store.recent(limit: 3).size).to eq(3)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns total count' do
+      store.store(proposal)
+      expect(store.stats[:total]).to eq(1)
+    end
+
+    it 'returns by_status breakdown' do
+      store.store(proposal)
+      store.store(approved_proposal)
+      stats = store.stats
+      expect(stats[:by_status][:proposed]).to eq(1)
+      expect(stats[:by_status][:approved]).to eq(1)
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all proposals' do
+      store.store(proposal)
+      store.clear
+      expect(store.stats[:total]).to eq(0)
+    end
+  end
+
+  describe 'MAX_PROPOSALS eviction' do
+    it 'evicts the oldest proposal when at capacity' do
+      stub_const("#{described_class}::MAX_PROPOSALS", 3)
+      small_store = described_class.new
+      proposals = 4.times.map do |i|
+        Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+          name: "lex-evict-#{i}", module_name: "E#{i}", category: :cognition, description: "evict #{i}"
+        )
+      end
+      proposals.each { |p| small_store.store(p) }
+      expect(small_store.stats[:total]).to eq(3)
+      expect(small_store.get(proposals[0].id)).to be_nil
+      expect(small_store.get(proposals[3].id)).not_to be_nil
+    end
+
+    it 'keeps the most recent proposals' do
+      stub_const("#{described_class}::MAX_PROPOSALS", 2)
+      small_store = described_class.new
+      3.times do |i|
+        p = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+          name: "lex-keep-#{i}", module_name: "K#{i}", category: :cognition, description: "keep #{i}"
+        )
+        small_store.store(p)
+      end
+      names = small_store.all.map(&:name)
+      expect(names).to include('lex-keep-1', 'lex-keep-2')
+      expect(names).not_to include('lex-keep-0')
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent stores without error' do
+      threads = 10.times.map do |i|
+        Thread.new do
+          p = Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+            name: "lex-thread-#{i}", module_name: "T#{i}", category: :cognition, description: "thread #{i}"
+          )
+          store.store(p)
+        end
+      end
+      threads.each(&:join)
+      expect(store.stats[:total]).to eq(10)
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::Analyzer do
+  subject(:analyzer) { described_class }
+
+  describe '.cognitive_profile' do
+    it 'returns success: true' do
+      result = analyzer.cognitive_profile
+      expect(result[:success]).to be true
+    end
+
+    it 'returns total_extensions count' do
+      result = analyzer.cognitive_profile(existing_extensions: %i[attention memory])
+      expect(result[:total_extensions]).to eq(2)
+    end
+
+    it 'returns model_coverage array' do
+      result = analyzer.cognitive_profile(existing_extensions: [])
+      expect(result[:model_coverage]).to be_an(Array)
+      expect(result[:model_coverage].size).to eq(5)
+    end
+
+    it 'returns overall_coverage as a float' do
+      result = analyzer.cognitive_profile(existing_extensions: [])
+      expect(result[:overall_coverage]).to be_a(Float)
+      expect(result[:overall_coverage]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns higher overall coverage with more extensions' do
+      empty_result = analyzer.cognitive_profile(existing_extensions: [])
+      full_required = Legion::Extensions::MindGrowth::Helpers::CognitiveModels::MODELS.values.flat_map { |m| m[:required] }.uniq
+      full_result = analyzer.cognitive_profile(existing_extensions: full_required)
+      expect(full_result[:overall_coverage]).to be > empty_result[:overall_coverage]
+    end
+
+    it 'uses empty list when no extensions provided and metacognition constants absent' do
+      result = analyzer.cognitive_profile
+      expect(result[:total_extensions]).to eq(0)
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect { analyzer.cognitive_profile(unknown: :value) }.not_to raise_error
+    end
+  end
+
+  describe '.identify_weak_links' do
+    let(:healthy) { { invocation_count: 500, impact_score: 0.9, health_score: 1.0, error_rate: 0.0, avg_latency_ms: 50 } }
+    let(:weak)    { { invocation_count: 0, impact_score: 0.1, health_score: 0.2, error_rate: 0.9, avg_latency_ms: 3000 } }
+
+    it 'returns success: true' do
+      result = analyzer.identify_weak_links(extensions: [])
+      expect(result[:success]).to be true
+    end
+
+    it 'identifies weak links below IMPROVEMENT_THRESHOLD' do
+      result = analyzer.identify_weak_links(extensions: [healthy, weak])
+      # The healthy extension should not appear as a weak link
+      weak_fitnesses = result[:weak_links].map { |e| e[:fitness] }
+      weak_fitnesses.each do |f|
+        expect(f).to be < Legion::Extensions::MindGrowth::Helpers::Constants::IMPROVEMENT_THRESHOLD
+      end
+    end
+
+    it 'returns ranked weak links' do
+      result = analyzer.identify_weak_links(extensions: [weak])
+      expect(result[:weak_links]).to be_an(Array)
+    end
+
+    it 'returns count of weak links' do
+      result = analyzer.identify_weak_links(extensions: [healthy, weak])
+      expect(result[:count]).to be_a(Integer)
+    end
+
+    it 'defaults to empty extensions array' do
+      result = analyzer.identify_weak_links
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '.recommend_priorities' do
+    it 'returns success: true' do
+      result = analyzer.recommend_priorities(existing_extensions: [])
+      expect(result[:success]).to be true
+    end
+
+    it 'returns priorities array' do
+      result = analyzer.recommend_priorities(existing_extensions: [])
+      expect(result[:priorities]).to be_an(Array)
+    end
+
+    it 'limits priorities to 10' do
+      result = analyzer.recommend_priorities(existing_extensions: [])
+      expect(result[:priorities].size).to be <= 10
+    end
+
+    it 'includes rationale' do
+      result = analyzer.recommend_priorities(existing_extensions: [])
+      expect(result[:rationale]).to be_a(String)
+      expect(result[:rationale]).not_to be_empty
+    end
+
+    it 'returns fewer priorities when extensions cover more requirements' do
+      all_required = Legion::Extensions::MindGrowth::Helpers::CognitiveModels::MODELS.values.flat_map { |m| m[:required] }.uniq
+      result = analyzer.recommend_priorities(existing_extensions: all_required)
+      expect(result[:priorities]).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'securerandom'
+
+RSpec.describe Legion::Extensions::MindGrowth::Runners::Builder do
+  subject(:builder) { described_class }
+
+  # Reset proposer store before each example
+  before { Legion::Extensions::MindGrowth::Runners::Proposer.instance_variable_set(:@proposal_store, nil) }
+
+  let(:proposal_id) do
+    result = Legion::Extensions::MindGrowth::Runners::Proposer.propose_concept(
+      name: 'lex-buildable', category: :cognition, description: 'a buildable proposal', enrich: false
+    )
+    result[:proposal][:id]
+  end
+
+  describe '.build_extension' do
+    it 'returns not_found for unknown proposal_id' do
+      result = builder.build_extension(proposal_id: 'nonexistent')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'returns success when proposal exists' do
+      result = builder.build_extension(proposal_id: proposal_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns pipeline hash' do
+      result = builder.build_extension(proposal_id: proposal_id)
+      expect(result[:pipeline]).to be_a(Hash)
+      expect(result[:pipeline][:stage]).to eq(:complete)
+    end
+
+    it 'returns proposal hash' do
+      result = builder.build_extension(proposal_id: proposal_id)
+      expect(result[:proposal]).to be_a(Hash)
+    end
+
+    it 'transitions proposal to :passing on success' do
+      builder.build_extension(proposal_id: proposal_id)
+      list = Legion::Extensions::MindGrowth::Runners::Proposer.list_proposals
+      p = list[:proposals].find { |pr| pr[:id] == proposal_id }
+      expect(p[:status]).to eq(:passing)
+    end
+
+    it 'accepts optional base_path parameter' do
+      result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+      expect(result[:success]).to be true
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect { builder.build_extension(proposal_id: proposal_id, unknown: :value) }.not_to raise_error
+    end
+  end
+
+  describe '.build_status' do
+    it 'returns not_found for unknown proposal_id' do
+      result = builder.build_status(proposal_id: 'nonexistent')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'returns status for existing proposal' do
+      result = builder.build_status(proposal_id: proposal_id)
+      expect(result[:success]).to be true
+      expect(result[:name]).to eq('lex-buildable')
+    end
+
+    it 'returns current status symbol' do
+      result = builder.build_status(proposal_id: proposal_id)
+      expect(result[:status]).to be_a(Symbol)
+    end
+  end
+
+  describe 'stage stubs (no dependencies loaded)' do
+    it 'progresses through all pipeline stages without error' do
+      result = builder.build_extension(proposal_id: proposal_id)
+      pipeline = result[:pipeline]
+      expect(pipeline[:errors]).to be_empty
+      expect(pipeline[:stage]).to eq(:complete)
+    end
+  end
+
+  describe 'wired stages' do
+    describe 'scaffold_stage with codegen' do
+      before do
+        stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)
+        stub_const('Legion::Extensions::Codegen::Runners::Validate', Module.new)
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: true, path: '/tmp/lex-buildable', files_created: 12, name: 'lex-buildable' })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: true, missing: [], present: %w[Gemfile] })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_gemspec)
+          .and_return({ valid: true, issues: [] })
+      end
+
+      it 'delegates scaffold to codegen' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Codegen::Runners::Generate).to have_received(:scaffold_extension)
+          .with(hash_including(name: 'buildable', module_name: anything, base_path: '/tmp'))
+      end
+
+      it 'passes proposal fields to codegen' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Codegen::Runners::Generate).to have_received(:scaffold_extension)
+          .with(hash_including(description: 'a buildable proposal', category: :cognition))
+      end
+
+      it 'strips lex- prefix from name before passing to codegen' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Codegen::Runners::Generate).to have_received(:scaffold_extension)
+          .with(hash_including(name: 'buildable'))
+      end
+
+      it 'pipeline completes when codegen succeeds' do
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:pipeline][:stage]).to eq(:complete)
+      end
+
+      it 'pipeline fails when scaffold fails' do
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: false, error: 'disk full' })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:success]).to be false
+        expect(result[:pipeline][:errors]).not_to be_empty
+      end
+    end
+
+    describe 'test_stage with exec' do
+      before do
+        stub_const('Legion::Extensions::Exec::Runners::Bundler', Module.new)
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:install)
+          .and_return({ success: true, stdout: '', stderr: '', exit_code: 0 })
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:exec_rspec)
+          .and_return({ success: true, parsed: { examples: 10, failures: 0, pending: 0, passed: 10 } })
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:exec_rubocop)
+          .and_return({ success: true, parsed: { files: 5, offenses: 0, clean: true } })
+      end
+
+      it 'runs install, rspec, and rubocop' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Exec::Runners::Bundler).to have_received(:install)
+        expect(Legion::Extensions::Exec::Runners::Bundler).to have_received(:exec_rspec)
+        expect(Legion::Extensions::Exec::Runners::Bundler).to have_received(:exec_rubocop)
+      end
+
+      it 'pipeline fails when rspec has failures' do
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:exec_rspec)
+          .and_return({ success: true, parsed: { examples: 10, failures: 2, pending: 0, passed: 8 } })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:success]).to be false
+      end
+
+      it 'pipeline fails when bundle install fails' do
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:install)
+          .and_return({ success: false, stderr: 'gem not found', exit_code: 1 })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:success]).to be false
+      end
+
+      it 'does not run rspec if install fails' do
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:install)
+          .and_return({ success: false, stderr: 'error', exit_code: 1 })
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Exec::Runners::Bundler).not_to have_received(:exec_rspec)
+      end
+    end
+
+    describe 'validate_stage with codegen validators' do
+      before do
+        stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)
+        stub_const('Legion::Extensions::Codegen::Runners::Validate', Module.new)
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: true, path: '/tmp/lex-buildable', files_created: 12 })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: true, missing: [], present: %w[Gemfile .rubocop.yml] })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_gemspec)
+          .and_return({ valid: true, issues: [] })
+      end
+
+      it 'calls structure and gemspec validators' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Codegen::Runners::Validate).to have_received(:validate_structure)
+        expect(Legion::Extensions::Codegen::Runners::Validate).to have_received(:validate_gemspec)
+      end
+
+      it 'fails when structure is invalid' do
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: false, missing: ['Gemfile'], present: [] })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:success]).to be false
+      end
+    end
+
+    describe 'register_stage with metacognition registry' do
+      before do
+        stub_const('Legion::Extensions::Metacognition::Runners::Registry', Module.new)
+        allow(Legion::Extensions::Metacognition::Runners::Registry).to receive(:register_extension)
+          .and_return({ success: true, name: 'lex-buildable', category: 'cognition' })
+      end
+
+      it 'registers the extension' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Metacognition::Runners::Registry).to have_received(:register_extension)
+          .with(hash_including(name: 'lex-buildable', category: 'cognition'))
+      end
+
+      it 'passes module_name and description' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(Legion::Extensions::Metacognition::Runners::Registry).to have_received(:register_extension)
+          .with(hash_including(module_name: anything, description: 'a buildable proposal'))
+      end
+    end
+
+    describe 'implement_stage with legion-llm' do
+      let(:mock_chat) { double('RubyLLM::Chat') }
+      let(:mock_response) { double('RubyLLM::Message', content: "# frozen_string_literal: true\n\n{ success: true }\n") }
+      let(:ext_dir) { File.join(Dir.tmpdir, "lex-mind-growth-llm-test-#{SecureRandom.hex(4)}") }
+
+      before do
+        llm_mod = Module.new do
+          def self.started? = true
+          def self.chat(**) = nil
+        end
+        stub_const('Legion::LLM', llm_mod)
+        allow(Legion::LLM).to receive(:chat).and_return(mock_chat)
+        allow(mock_chat).to receive(:with_instructions).and_return(mock_chat)
+        allow(mock_chat).to receive(:ask).and_return(mock_response)
+
+        # Create a minimal scaffolded extension directory
+        runner_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners')
+        helper_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'helpers')
+        FileUtils.mkdir_p(runner_dir)
+        FileUtils.mkdir_p(helper_dir)
+        File.write(File.join(runner_dir, 'example.rb'), "# frozen_string_literal: true\n\n{ success: true }\n")
+        File.write(File.join(helper_dir, 'store.rb'), "# frozen_string_literal: true\n\nclass Store; end\n")
+      end
+
+      after { FileUtils.rm_rf(ext_dir) }
+
+      it 'calls LLM for each target file' do
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(mock_chat).to have_received(:ask).twice
+      end
+
+      it 'passes system instructions to chat' do
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(mock_chat).to have_received(:with_instructions)
+          .with(a_string_including('Ruby code generator')).at_least(:once)
+      end
+
+      it 'includes proposal description in prompt' do
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(mock_chat).to have_received(:ask)
+          .with(a_string_including('a buildable proposal')).at_least(:once)
+      end
+
+      it 'writes LLM output back to files' do
+        allow(mock_response).to receive(:content).and_return("# frozen_string_literal: true\n\n# implemented\n")
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        runner_path = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners', 'example.rb')
+        expect(File.read(runner_path)).to include('# implemented')
+      end
+
+      it 'extracts code from markdown fences' do
+        fenced = "Here's the code:\n```ruby\n# frozen_string_literal: true\n\nreal_code\n```\n"
+        allow(mock_response).to receive(:content).and_return(fenced)
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        runner_path = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners', 'example.rb')
+        content = File.read(runner_path)
+        expect(content).to include('real_code')
+        expect(content).not_to include('```')
+      end
+
+      it 'skips version.rb and client.rb' do
+        version_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable')
+        File.write(File.join(version_dir, 'version.rb'), "VERSION = '0.1.0'\n")
+        File.write(File.join(version_dir, 'client.rb'), "class Client; end\n")
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        # Only runner/example.rb and helper/store.rb should be targets (2 calls)
+        expect(mock_chat).to have_received(:ask).twice
+      end
+
+      it 'handles LLM errors gracefully' do
+        allow(mock_chat).to receive(:ask).and_raise(StandardError, 'LLM timeout')
+        result = builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(result[:pipeline][:errors]).not_to be_empty
+      end
+
+      it 'includes metaphor in prompt when present' do
+        metaphor_id = Legion::Extensions::MindGrowth::Runners::Proposer.propose_concept(
+          name: 'lex-metaphoric', category: :cognition, description: 'test metaphor', enrich: false
+        )[:proposal][:id]
+        proposal_obj = Legion::Extensions::MindGrowth::Runners::Proposer.get_proposal_object(metaphor_id)
+        proposal_obj.instance_variable_set(:@metaphor, 'like a garden')
+
+        runner_dir = File.join(ext_dir, 'lex-metaphoric', 'lib', 'legion', 'extensions', 'metaphoric', 'runners')
+        FileUtils.mkdir_p(runner_dir)
+        File.write(File.join(runner_dir, 'grow.rb'), "# stub\n")
+
+        builder.build_extension(proposal_id: metaphor_id, base_path: ext_dir)
+        expect(mock_chat).to have_received(:ask).with(a_string_including('like a garden'))
+      end
+    end
+
+    describe 'full wired pipeline' do
+      before do
+        stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)
+        stub_const('Legion::Extensions::Codegen::Runners::Validate', Module.new)
+        stub_const('Legion::Extensions::Exec::Runners::Bundler', Module.new)
+        stub_const('Legion::Extensions::Metacognition::Runners::Registry', Module.new)
+
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: true, path: '/tmp/lex-buildable', files_created: 12 })
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:install)
+          .and_return({ success: true })
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:exec_rspec)
+          .and_return({ success: true, parsed: { examples: 5, failures: 0, pending: 0, passed: 5 } })
+        allow(Legion::Extensions::Exec::Runners::Bundler).to receive(:exec_rubocop)
+          .and_return({ success: true, parsed: { files: 3, offenses: 0, clean: true } })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: true, missing: [], present: %w[Gemfile] })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_gemspec)
+          .and_return({ valid: true, issues: [] })
+        allow(Legion::Extensions::Metacognition::Runners::Registry).to receive(:register_extension)
+          .and_return({ success: true, name: 'lex-buildable' })
+      end
+
+      it 'completes all stages successfully' do
+        result = builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        expect(result[:success]).to be true
+        expect(result[:pipeline][:stage]).to eq(:complete)
+        expect(result[:pipeline][:errors]).to be_empty
+      end
+
+      it 'transitions proposal to :passing' do
+        builder.build_extension(proposal_id: proposal_id, base_path: '/tmp')
+        proposal = Legion::Extensions::MindGrowth::Runners::Proposer.get_proposal_object(proposal_id)
+        expect(proposal.status).to eq(:passing)
+      end
+    end
+  end
+end