lex-mind-growth 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2182f87f0f59f727c61f209083c225b1b31d9cbb5589af437618350433e8b692
-  data.tar.gz: 1ee0428c83686efdb168054b16d68af66443dfa60bd5f0bd8e2725f4d7d87ab4
+  metadata.gz: 647d99aa35555ba0ff36f584ad78d0c2104a9c09e83d72fbee7b897d097c7380
+  data.tar.gz: b7803d7ea950fb03154b695b5631f8a2e523adfad0df4963f8a22bf98e952f67
 SHA512:
-  metadata.gz: 1e7320c15ecd31d531bd961b03f20baa8c30a77946f98e58c25557ebcd1027b42b7c9af7c9ce8ae781089e25966a76d183209922ce8b2e7a780c141853cf6d96
-  data.tar.gz: b7abcbc0ea3109d64a4cc1cda9508ea0ee8ab777271e205abc1ae4903d1f2bf349b78053aa071fe5835790a790f4974be95800cf57ad2bfa8ab96182b358d312
+  metadata.gz: d2874a80b17163ad6b0d9f92f6ce221b22e4bbecf317c779315279f5a7c4426154f342892c7765cf0d7e29f55941e9561d28a1d2d92cee5d7298151d5d47fc4c
+  data.tar.gz: 01c677bf65ca0c841f5740a7d1f89a41d160e1bb8bcd39f43ad247b4676a11d2c55bb67d4eaad7ed32c73e8838e1e1064839d0e4e461897b5a8af4c8c36945ca

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

@@ -47,6 +47,43 @@ module Legion
         # RiskAssessor delegation
         def assess_risk(**)   = Runners::RiskAssessor.assess_risk(**)
         def risk_summary(**)  = Runners::RiskAssessor.risk_summary(**)
+
+        # Monitor delegation
+        def health_check(**)    = Runners::Monitor.health_check(**)
+        def usage_stats(**)     = Runners::Monitor.usage_stats(**)
+        def impact_score(**)    = Runners::Monitor.impact_score(**)
+        def decay_check(**)     = Runners::Monitor.decay_check(**)
+        def auto_prune(**)      = Runners::Monitor.auto_prune(**)
+        def health_summary(**)  = Runners::Monitor.health_summary(**)
+
+        # Composer delegation
+        def add_composition(**)      = Runners::Composer.add_composition(**)
+        def remove_composition(**)   = Runners::Composer.remove_composition(**)
+        def evaluate_output(**)      = Runners::Composer.evaluate_output(**)
+        def composition_stats(**)    = Runners::Composer.composition_stats(**)
+        def suggest_compositions(**) = Runners::Composer.suggest_compositions(**)
+        def list_compositions(**)    = Runners::Composer.list_compositions(**)
+
+        # DreamIdeation delegation
+        def generate_dream_proposals(**) = Runners::DreamIdeation.generate_dream_proposals(**)
+        def dream_agenda_items(**)       = Runners::DreamIdeation.dream_agenda_items(**)
+        def enrich_from_dream_context(**) = Runners::DreamIdeation.enrich_from_dream_context(**)
+
+        # Evolver delegation
+        def select_for_improvement(**) = Runners::Evolver.select_for_improvement(**)
+        def propose_improvement(**)    = Runners::Evolver.propose_improvement(**)
+        def replace_extension(**)      = Runners::Evolver.replace_extension(**)
+        def merge_extensions(**)       = Runners::Evolver.merge_extensions(**)
+        def evolution_summary(**)      = Runners::Evolver.evolution_summary(**)
+
+        # Dashboard delegation
+        def extension_timeline(**)     = Runners::Dashboard.extension_timeline(**)
+        def category_distribution(**) = Runners::Dashboard.category_distribution(**)
+        def build_metrics(**)          = Runners::Dashboard.build_metrics(**)
+        def top_extensions(**)         = Runners::Dashboard.top_extensions(**)
+        def bottom_extensions(**)      = Runners::Dashboard.bottom_extensions(**)
+        def recent_proposals(**)       = Runners::Dashboard.recent_proposals(**)
+        def full_dashboard(**)         = Runners::Dashboard.full_dashboard(**)
       end
     end
   end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module CompositionMap
+          module_function
+
+          @rules = {}
+          @mutex = Mutex.new
+
+          def add_rule(source_extension:, output_key:, target_extension:, target_method:, transform: nil, **)
+            rule_id = SecureRandom.uuid
+            rule = {
+              id:               rule_id,
+              source_extension: source_extension.to_s,
+              output_key:       output_key.to_sym,
+              target_extension: target_extension.to_s,
+              target_method:    target_method.to_sym,
+              transform:        transform
+            }
+            @mutex.synchronize { @rules[rule_id] = rule }
+            { success: true, rule_id: rule_id }
+          end
+
+          def remove_rule(rule_id:, **)
+            removed = @mutex.synchronize { @rules.delete(rule_id) }
+            { success: !removed.nil?, rule_id: rule_id }
+          end
+
+          def rules_for(source_extension:, **)
+            src = source_extension.to_s
+            @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src } }
+          end
+
+          def all_rules
+            @mutex.synchronize { @rules.values.dup }
+          end
+
+          def match_output(source_extension:, output:, **)
+            src   = source_extension.to_s
+            out_h = output.is_a?(Hash) ? output : {}
+            rules = @mutex.synchronize { @rules.values.select { |r| r[:source_extension] == src } }
+
+            rules.filter_map do |rule|
+              key = rule[:output_key]
+              next unless out_h.key?(key)
+
+              { rule: rule, matched_value: out_h[key] }
+            end
+          end
+
+          def clear!
+            @mutex.synchronize { @rules.clear }
+          end
+
+          def stats
+            all = @mutex.synchronize { @rules.values.dup }
+
+            by_source = Hash.new(0)
+            by_target = Hash.new(0)
+            all.each do |r|
+              by_source[r[:source_extension]] += 1
+              by_target[r[:target_extension]] += 1
+            end
+
+            { total_rules: all.size,
+              by_source:   by_source.transform_values { |v| v },
+              by_target:   by_target.transform_values { |v| v } }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -54,6 +54,10 @@ module Legion
           REJECTION_COOLDOWN_HOURS = 24
           GOVERNANCE_STATUSES      = %i[pending approved rejected expired].freeze
 
+          # Health monitoring
+          HEALTH_LEVELS = { excellent: 0.8, good: 0.6, fair: 0.4, degraded: 0.2, critical: 0.0 }.freeze
+          DECAY_INVOCATION_THRESHOLD = 5
+
           # Risk assessment
           RISK_TIERS = %i[low medium high critical].freeze
           RISK_RECOMMENDATIONS = {

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Composer
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          # Category adjacency used for heuristic suggestions
+          CATEGORY_FLOW = [
+            %i[perception cognition],
+            %i[cognition memory],
+            %i[cognition introspection],
+            %i[memory cognition],
+            %i[introspection safety],
+            %i[motivation cognition],
+            %i[cognition communication],
+            %i[communication coordination]
+          ].freeze
+
+          def add_composition(source_extension:, output_key:, target_extension:, target_method:,
+                              transform: nil, **)
+            Helpers::CompositionMap.add_rule(
+              source_extension: source_extension,
+              output_key:       output_key,
+              target_extension: target_extension,
+              target_method:    target_method,
+              transform:        transform
+            )
+          end
+
+          def remove_composition(rule_id:, **)
+            result = Helpers::CompositionMap.remove_rule(rule_id: rule_id)
+            { success: result[:success] }
+          end
+
+          def evaluate_output(source_extension:, output:, **)
+            matches = Helpers::CompositionMap.match_output(
+              source_extension: source_extension,
+              output:           output
+            )
+
+            dispatches = matches.map do |match|
+              rule  = match[:rule]
+              value = match[:matched_value]
+              input = rule[:transform] ? rule[:transform].call(value) : value
+
+              { target_extension: rule[:target_extension],
+                target_method:    rule[:target_method],
+                input:            input }
+            end
+
+            { success: true, dispatches: dispatches, count: dispatches.size }
+          end
+
+          def composition_stats(**)
+            { success: true, **Helpers::CompositionMap.stats }
+          end
+
+          def suggest_compositions(extensions:, **)
+            exts = Array(extensions)
+
+            return suggest_with_llm(exts) if defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+
+            suggestions = heuristic_suggestions(exts)
+            { success: true, suggestions: suggestions, count: suggestions.size }
+          end
+
+          def list_compositions(**)
+            rules = Helpers::CompositionMap.all_rules
+            { success: true, rules: rules, count: rules.size }
+          end
+
+          private
+
+          def heuristic_suggestions(extensions)
+            ext_by_category = {}
+            extensions.each do |ext|
+              cat = (ext[:category] || :cognition).to_sym
+              (ext_by_category[cat] ||= []) << ext
+            end
+
+            suggestions = []
+            CATEGORY_FLOW.each do |src_cat, tgt_cat|
+              src_exts = ext_by_category[src_cat] || []
+              tgt_exts = ext_by_category[tgt_cat] || []
+
+              src_exts.each do |src|
+                tgt_exts.each do |tgt|
+                  suggestions << {
+                    source_extension: src[:name] || src[:extension_name],
+                    output_key:       :result,
+                    target_extension: tgt[:name] || tgt[:extension_name],
+                    target_method:    :process,
+                    rationale:        "#{src_cat} -> #{tgt_cat} flow"
+                  }
+                end
+              end
+            end
+
+            suggestions
+          end
+
+          def suggest_with_llm(extensions)
+            suggestions = heuristic_suggestions(extensions)
+            { success: true, suggestions: suggestions, count: suggestions.size }
+          rescue StandardError
+            { success: true, suggestions: [], count: 0 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Dashboard
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          module_function
+
+          def extension_timeline(extensions:, days: 30, **)
+            count = Array(extensions).size
+            today = Time.now.utc.strftime('%Y-%m-%d')
+            series = [{ date: today, count: count }]
+
+            { success: true, series: series, range_days: days }
+          end
+
+          def category_distribution(extensions:, **)
+            exts = Array(extensions)
+            dist = Helpers::Constants::CATEGORIES.to_h { |c| [c, 0] }
+
+            exts.each do |ext|
+              cat = (ext[:category] || :cognition).to_sym
+              dist[cat] = (dist[cat] || 0) + 1
+            end
+
+            { success: true, distribution: dist, total: exts.size }
+          end
+
+          def build_metrics(**)
+            stats = Runners::Proposer.proposal_stats[:stats]
+            by_status = stats[:by_status] || {}
+            total     = stats[:total] || 0
+
+            approved = by_status[:approved].to_i
+            rejected = by_status[:rejected].to_i
+            built    = (by_status[:passing].to_i + by_status[:wired].to_i + by_status[:active].to_i)
+            failed   = by_status[:build_failed].to_i
+
+            attempted    = built + failed
+            success_rate = attempted.positive? ? (built.to_f / attempted).round(3) : 0.0
+
+            evaluated = approved + rejected
+            approval_rate = evaluated.positive? ? (approved.to_f / evaluated).round(3) : 0.0
+
+            { success:         true,
+              total_proposals: total,
+              approved:        approved,
+              rejected:        rejected,
+              built:           built,
+              failed:          failed,
+              success_rate:    success_rate,
+              approval_rate:   approval_rate }
+          end
+
+          def top_extensions(extensions:, limit: 10, **)
+            exts = Array(extensions)
+            ranked = Helpers::FitnessEvaluator.rank(exts)
+            top = ranked.first(limit).map do |e|
+              { name:             e[:name] || e[:extension_name],
+                invocation_count: e[:invocation_count] || 0,
+                fitness:          e[:fitness] }
+            end
+
+            { success: true, top: top, limit: limit }
+          end
+
+          def bottom_extensions(extensions:, limit: 10, **)
+            exts = Array(extensions)
+            ranked = Helpers::FitnessEvaluator.rank(exts)
+            bottom = ranked.last(limit).reverse.map do |e|
+              { name:             e[:name] || e[:extension_name],
+                invocation_count: e[:invocation_count] || 0,
+                fitness:          e[:fitness] }
+            end
+
+            { success: true, bottom: bottom, limit: limit }
+          end
+
+          def recent_proposals(limit: 10, **)
+            result = Runners::Proposer.list_proposals(limit: limit)
+            { success: true, proposals: result[:proposals], count: result[:count] }
+          end
+
+          def full_dashboard(extensions:, **)
+            exts = Array(extensions)
+
+            { success:               true,
+              category_distribution: category_distribution(extensions: exts)[:distribution],
+              build_metrics:         build_metrics,
+              top_extensions:        top_extensions(extensions: exts)[:top],
+              bottom_extensions:     bottom_extensions(extensions: exts)[:bottom],
+              recent_proposals:      recent_proposals[:proposals],
+              health_summary:        Runners::Monitor.health_summary(extensions: exts),
+              timestamp:             Time.now.utc.iso8601 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module DreamIdeation
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          DREAM_NOVELTY_BONUS = 0.15
+
+          # Agenda item weight by how underrepresented the category is
+          MAX_AGENDA_WEIGHT = 1.0
+          MIN_AGENDA_WEIGHT = 0.1
+
+          def generate_dream_proposals(existing_extensions: nil, max_proposals: 2, **)
+            gap_result = Runners::Proposer.analyze_gaps(existing_extensions: existing_extensions)
+            return { success: false, error: :gap_analysis_failed } unless gap_result[:success]
+
+            recommendations = gap_result[:recommendations] || []
+            proposals       = []
+
+            recommendations.first(max_proposals).each do |rec|
+              name   = rec.is_a?(Hash) ? rec[:name] : rec.to_s
+              result = Runners::Proposer.propose_concept(
+                name:        "lex-dream-#{name.to_s.downcase.gsub(/[^a-z0-9]/, '-')}",
+                description: "Dream-originated proposal for #{name} cognitive capability",
+                enrich:      false
+              )
+              next unless result[:success]
+
+              proposal_id = result[:proposal][:id]
+              proposal    = Runners::Proposer.get_proposal_object(proposal_id)
+              proposal&.instance_variable_set(:@origin, :dream)
+
+              proposals << result[:proposal]
+            end
+
+            { success: true, proposals: proposals, count: proposals.size,
+              gaps_analyzed: recommendations.size }
+          end
+
+          def dream_agenda_items(existing_extensions: nil, **)
+            gap_result = Runners::Proposer.analyze_gaps(existing_extensions: existing_extensions)
+            return { success: false, error: :gap_analysis_failed } unless gap_result[:success]
+
+            target = Helpers::Constants::TARGET_DISTRIBUTION
+            models = gap_result[:models] || []
+
+            coverage_by_cat = build_coverage_by_category(models)
+
+            items = target.filter_map do |category, target_pct|
+              actual_pct = coverage_by_cat[category] || 0.0
+              gap        = (target_pct - actual_pct).clamp(0.0, 1.0)
+              next if gap <= 0.0
+
+              weight = ((gap / target_pct) * MAX_AGENDA_WEIGHT).clamp(MIN_AGENDA_WEIGHT, MAX_AGENDA_WEIGHT).round(3)
+
+              { type:    :architectural_gap,
+                content: { gap_name: category, model: :target_distribution, coverage: actual_pct },
+                weight:  weight }
+            end
+
+            { success: true, items: items, count: items.size }
+          end
+
+          def enrich_from_dream_context(proposal_id:, dream_context: {}, **)
+            proposal = Runners::Proposer.get_proposal_object(proposal_id)
+            return { success: false, error: :not_found } unless proposal
+
+            if dream_context && !dream_context.empty?
+              existing  = proposal.rationale.to_s
+              additions = dream_context.map { |k, v| "#{k}: #{v}" }.join('; ')
+              new_rationale = existing.empty? ? additions : "#{existing}. Dream context: #{additions}"
+              proposal.instance_variable_set(:@rationale, new_rationale)
+              { success: true, proposal_id: proposal_id, enriched: true }
+            else
+              { success: true, proposal_id: proposal_id, enriched: false }
+            end
+          end
+
+          private
+
+          def build_coverage_by_category(models)
+            coverage = {}
+            models.each do |model|
+              cat = infer_category_from_model(model[:model])
+              next unless cat
+
+              existing = coverage[cat] || 1.0
+              coverage[cat] = [existing, model_coverage_fraction(model)].min
+            end
+            coverage
+          end
+
+          def model_coverage_fraction(model)
+            total   = model[:total_required] || 1
+            missing = (model[:missing] || []).size
+            covered = total - missing
+            total.positive? ? (covered.to_f / total).round(3) : 0.0
+          end
+
+          def infer_category_from_model(model_name)
+            mapping = {
+              global_workspace: :cognition,
+              free_energy:      :introspection,
+              dual_process:     :cognition,
+              somatic_marker:   :motivation,
+              working_memory:   :memory
+            }
+            mapping[model_name&.to_sym]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Evolver
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          BOTTOM_PERCENTILE = 0.05
+          SPECIATION_DRIFT_THRESHOLD = 0.5
+
+          def select_for_improvement(extensions:, count: 3, **)
+            exts = Array(extensions)
+            return { success: true, candidates: [], count: 0, total_evaluated: 0 } if exts.empty?
+
+            eligible = exts.reject { |e| %i[building testing].include?((e[:status] || :active).to_sym) }
+            ranked   = Helpers::FitnessEvaluator.rank(eligible)
+            bottom_n = ranked.last(count)
+
+            { success: true, candidates: bottom_n, count: bottom_n.size, total_evaluated: eligible.size }
+          end
+
+          def propose_improvement(extension:, **)
+            name     = extension[:name] || extension[:extension_name]
+            fitness  = Helpers::FitnessEvaluator.fitness(extension)
+
+            weaknesses = identify_weaknesses(extension)
+            suggestions = generate_suggestions(weaknesses)
+
+            if defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+              suggestions = llm_suggestions(name, fitness, weaknesses) || suggestions
+            end
+
+            { success: true, extension_name: name, fitness: fitness,
+              weaknesses: weaknesses, suggestions: suggestions }
+          end
+
+          def replace_extension(old_name:, new_proposal_id:, **)
+            status_store[old_name] = :pruned
+            replacement_map[old_name] = new_proposal_id
+
+            { success: true, replaced: old_name, replacement_proposal_id: new_proposal_id }
+          end
+
+          def merge_extensions(extension_a:, extension_b:, merged_name: nil, **)
+            name_a = extension_a[:name] || extension_a[:extension_name]
+            name_b = extension_b[:name] || extension_b[:extension_name]
+            cat_a  = (extension_a[:category] || :cognition).to_sym
+            merged = merged_name || "lex-merged-#{name_a.to_s.sub(/\Alex-/, '')}-#{name_b.to_s.sub(/\Alex-/, '')}"
+            desc   = "Merged extension combining capabilities of #{name_a} and #{name_b}"
+
+            proposal = Runners::Proposer.propose_concept(
+              name:        merged,
+              category:    cat_a,
+              description: desc,
+              enrich:      false
+            )
+
+            { success: true, merged_proposal: proposal, sources: [name_a, name_b] }
+          end
+
+          def evolution_summary(extensions:, **)
+            exts = Array(extensions)
+
+            improvement_candidates = select_for_improvement(extensions: exts, count: 5)[:candidates]
+
+            prune_candidates = Helpers::FitnessEvaluator.prune_candidates(exts).map do |e|
+              e[:name] || e[:extension_name]
+            end
+
+            speciation_candidates = exts.filter_map do |e|
+              e[:name] || e[:extension_name] if (e[:drift_score] || 0.0) >= SPECIATION_DRIFT_THRESHOLD
+            end
+
+            fitnesses = exts.map { |e| Helpers::FitnessEvaluator.fitness(e) }
+
+            distribution = if fitnesses.empty?
+                             { min: 0.0, max: 0.0, mean: 0.0, median: 0.0 }
+                           else
+                             sorted = fitnesses.sort
+                             mid    = sorted.size / 2
+                             median = sorted.size.odd? ? sorted[mid] : ((sorted[mid - 1] + sorted[mid]) / 2.0).round(3)
+                             { min:    sorted.first.round(3),
+                               max:    sorted.last.round(3),
+                               mean:   (fitnesses.sum / fitnesses.size.to_f).round(3),
+                               median: median }
+                           end
+
+            { success:                true,
+              improvement_candidates: improvement_candidates,
+              prune_candidates:       prune_candidates,
+              speciation_candidates:  speciation_candidates,
+              fitness_distribution:   distribution }
+          end
+
+          SUGGESTION_MAP = {
+            low_invocations: 'improve wiring or broaden phase coverage',
+            high_error_rate: 'add error handling and input validation',
+            high_latency:    'optimize hot paths or add caching',
+            low_impact:      'enrich output or add downstream connections'
+          }.freeze
+
+          private
+
+          def identify_weaknesses(extension)
+            weaknesses = []
+            count = extension[:invocation_count] || 0
+            error = extension[:error_rate]       || 0.0
+            lat   = extension[:avg_latency_ms]   || 0
+            imp   = extension[:impact_score]     || 0.5
+
+            weaknesses << :low_invocations if count < Helpers::Constants::DECAY_INVOCATION_THRESHOLD
+            weaknesses << :high_error_rate if error > 0.2
+            weaknesses << :high_latency    if lat > 1000
+            weaknesses << :low_impact      if imp < 0.3
+            weaknesses
+          end
+
+          def generate_suggestions(weaknesses)
+            suggestions = weaknesses.filter_map { |w| SUGGESTION_MAP[w] }
+            suggestions.empty? ? ['review overall design for incremental improvements'] : suggestions
+          end
+
+          def llm_suggestions(name, fitness, weaknesses)
+            response = Legion::LLM.chat(
+              caller: { extension: 'lex-mind-growth', operation: 'evolver', phase: 'suggest' }
+            ).ask(improvement_prompt(name, fitness, weaknesses))
+            parse_llm_suggestions(response.content)
+          rescue StandardError
+            nil
+          end
+
+          def improvement_prompt(name, fitness, weaknesses)
+            <<~PROMPT
+              The LegionIO cognitive extension "#{name}" has a fitness score of #{fitness.round(3)}.
+              Identified weaknesses: #{weaknesses.join(', ')}.
+
+              Provide 2-4 concrete improvement suggestions as a JSON array of strings.
+              Example: ["suggestion one", "suggestion two"]
+              Return ONLY the JSON array, no markdown fencing.
+            PROMPT
+          end
+
+          def parse_llm_suggestions(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
+            nil
+          end
+
+          def status_store
+            @status_store ||= {}
+          end
+
+          def replacement_map
+            @replacement_map ||= {}
+          end
+        end
+      end
+    end
+  end
+end