lex-agentic-social 0.1.0

data/lib/legion/extensions/agentic/social/moral_reasoning/helpers/llm_enhancer.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Helpers
+            module LlmEnhancer
+              SYSTEM_PROMPT = <<~PROMPT
+                You are the moral reasoning engine for an autonomous AI agent built on LegionIO.
+                You apply ethical frameworks to evaluate actions and resolve dilemmas.
+                Be rigorous, analytical, and fair. Consider multiple perspectives.
+                Output structured reasoning, not opinions. Be concise.
+              PROMPT
+
+              module_function
+
+              def available?
+                !!(defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?)
+              rescue StandardError
+                false
+              end
+
+              def evaluate_action(action:, description:, foundations:)
+                response = llm_ask(build_evaluate_action_prompt(action: action, description: description,
+                                                                foundations: foundations))
+                parse_evaluate_action_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[moral_reasoning:llm] evaluate_action failed: #{e.message}"
+                nil
+              end
+
+              def resolve_dilemma(dilemma_description:, options:, framework:)
+                response = llm_ask(build_resolve_dilemma_prompt(dilemma_description: dilemma_description,
+                                                                options: options, framework: framework))
+                parse_resolve_dilemma_response(response)
+              rescue StandardError => e
+                Legion::Logging.warn "[moral_reasoning:llm] resolve_dilemma failed: #{e.message}"
+                nil
+              end
+
+              def llm_ask(prompt)
+                chat = Legion::LLM.chat
+                chat.with_instructions(SYSTEM_PROMPT)
+                chat.ask(prompt)
+              end
+              private_class_method :llm_ask
+
+              def build_evaluate_action_prompt(action:, description:, foundations:)
+                foundation_lines = foundations.map { |name, strength| "  #{name}: #{strength.round(3)}" }.join("\n")
+                desc = description.to_s.empty? ? 'no description' : description
+                <<~PROMPT
+                  Evaluate this action using moral foundations theory.
+
+                  ACTION: #{action}
+                  DESCRIPTION: #{desc}
+
+                  Current foundation strengths:
+                  #{foundation_lines}
+
+                  For each foundation, estimate the moral impact of this action (-1.0 to 1.0).
+                  Negative = harmful to that foundation, Positive = reinforces that foundation.
+
+                  Format EXACTLY as:
+                  REASONING: <1-2 paragraph analysis>
+                  IMPACT: care=<float> | fairness=<float> | loyalty=<float> | authority=<float> | sanctity=<float> | liberty=<float>
+                PROMPT
+              end
+              private_class_method :build_evaluate_action_prompt
+
+              def parse_evaluate_action_response(response)
+                return nil unless response&.content
+
+                text            = response.content
+                reasoning_match = text.match(/REASONING:\s*(.+?)(?=\nIMPACT:|\z)/im)
+                impact_match    = text.match(/IMPACT:\s*(.+)/i)
+                return nil unless reasoning_match && impact_match
+
+                foundation_impacts = parse_impact_string(impact_match.captures.first.strip)
+                return nil if foundation_impacts.empty?
+
+                { reasoning: reasoning_match.captures.first.strip, foundation_impacts: foundation_impacts }
+              end
+              private_class_method :parse_evaluate_action_response
+
+              def parse_impact_string(impact_str)
+                impact_str.split('|').each_with_object({}) do |pair, hash|
+                  key, val = pair.strip.split('=')
+                  hash[key.strip.to_sym] = val.strip.to_f.clamp(-1.0, 1.0) if key && val
+                end
+              end
+              private_class_method :parse_impact_string
+
+              def build_resolve_dilemma_prompt(dilemma_description:, options:, framework:)
+                option_lines = options.map do |opt|
+                  foundations_str = opt.fetch(:foundations, []).join(', ')
+                  "- #{opt[:id] || opt[:action]}: #{opt[:description]} (foundations: #{foundations_str})"
+                end.join("\n")
+                <<~PROMPT
+                  Resolve this moral dilemma using the #{framework} ethical framework.
+
+                  DILEMMA: #{dilemma_description}
+
+                  OPTIONS:
+                  #{option_lines}
+
+                  Apply #{framework} reasoning to select the best option.
+
+                  Format EXACTLY as:
+                  CHOSEN: <option label>
+                  CONFIDENCE: <0.0-1.0>
+                  REASONING: <1-2 paragraph justification using the specified framework>
+                PROMPT
+              end
+              private_class_method :build_resolve_dilemma_prompt
+
+              def parse_resolve_dilemma_response(response)
+                return nil unless response&.content
+
+                text             = response.content
+                chosen_match     = text.match(/CHOSEN:\s*(.+)/i)
+                confidence_match = text.match(/CONFIDENCE:\s*([\d.]+)/i)
+                reasoning_match  = text.match(/REASONING:\s*(.+)/im)
+                return nil unless chosen_match && confidence_match && reasoning_match
+
+                {
+                  chosen_option: chosen_match.captures.first.strip,
+                  confidence:    confidence_match.captures.first.strip.to_f.clamp(0.0, 1.0),
+                  reasoning:     reasoning_match.captures.first.strip
+                }
+              end
+              private_class_method :parse_resolve_dilemma_response
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning/helpers/moral_engine.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Helpers
+            module FrameworkEvaluators
+              CARE_FOUNDATIONS     = %i[care fairness sanctity].freeze
+              DUTY_FOUNDATIONS     = %i[authority loyalty].freeze
+              JUSTICE_FOUNDATIONS  = %i[fairness liberty].freeze
+              RIGHTS_FOUNDATIONS   = %i[liberty fairness authority].freeze
+
+              private
+
+              def evaluate_by_utility(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).sum { |fid| @foundations[fid]&.weight.to_f }
+                end
+              end
+
+              def evaluate_by_duty(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).count { |fid| DUTY_FOUNDATIONS.include?(fid) }.to_f
+                end
+              end
+
+              def evaluate_by_virtue(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).count { |fid| CARE_FOUNDATIONS.include?(fid) }.to_f
+                end
+              end
+
+              def evaluate_by_care(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).count { |fid| fid == :care }.to_f
+                end
+              end
+
+              def evaluate_by_justice(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).count { |fid| JUSTICE_FOUNDATIONS.include?(fid) }.to_f
+                end
+              end
+
+              def evaluate_by_rights(dilemma)
+                rank_options(dilemma) do |option|
+                  option.fetch(:foundations, []).count { |fid| RIGHTS_FOUNDATIONS.include?(fid) }.to_f
+                end
+              end
+
+              def rank_options(dilemma)
+                scored = dilemma.options.map do |option|
+                  score = yield(option)
+                  { id: option[:id], description: option[:description], score: score }
+                end
+                scored.sort_by { |r| -r[:score] }
+              end
+            end
+
+            class MoralEngine
+              include Constants
+              include FrameworkEvaluators
+
+              KOHLBERG_STAGE_DESCRIPTIONS = {
+                obedience:        'Avoid punishment; obey authority unconditionally',
+                self_interest:    'Act for direct reward; reciprocal exchange',
+                conformity:       'Conform to social norms; be a good person',
+                law_and_order:    'Follow rules, laws, and authority to maintain social order',
+                social_contract:  'Uphold democratic principles; greatest good for greatest number',
+                universal_ethics: 'Follow self-chosen universal ethical principles'
+              }.freeze
+
+              FRAMEWORK_STRATEGIES = {
+                utilitarian:   :evaluate_by_utility,
+                deontological: :evaluate_by_duty,
+                virtue:        :evaluate_by_virtue,
+                care:          :evaluate_by_care,
+                justice:       :evaluate_by_justice,
+                rights:        :evaluate_by_rights
+              }.freeze
+
+              attr_reader :stage, :dilemmas, :principles, :history
+
+              def initialize
+                @foundations = MORAL_FOUNDATIONS.to_h { |f| [f, MoralFoundation.new(id: f)] }
+                @principles  = []
+                @dilemmas    = {}
+                @stage       = :social_contract
+                @history     = []
+              end
+
+              def evaluate_action(action:, affected_foundations:, domain: :general)
+                score = score_foundations(affected_foundations)
+                normalized = affected_foundations.empty? ? 0.0 : score / affected_foundations.size
+                add_history(type: :evaluation, action: action, domain: domain, score: normalized)
+                { action: action, domain: domain, score: normalized, foundations: affected_foundations }
+              end
+
+              def pose_dilemma(description:, options:, domain: :general, severity: 0.5)
+                return { success: false, reason: :max_dilemmas_reached } if @dilemmas.size >= MAX_DILEMMAS
+
+                id = generate_id('dilemma')
+                dilemma = Dilemma.new(id: id, description: description, options: options,
+                                      domain: domain, severity: severity)
+                @dilemmas[id] = dilemma
+                { success: true, dilemma: dilemma.to_h }
+              end
+
+              def resolve_dilemma(dilemma_id:, option_id:, reasoning:, framework:)
+                dilemma = @dilemmas[dilemma_id]
+                return { success: false, reason: :not_found } unless dilemma
+                return { success: false, reason: :already_resolved } if dilemma.resolved?
+
+                chosen = dilemma.options.find { |o| o[:id] == option_id }
+                return { success: false, reason: :invalid_option } unless chosen
+
+                dilemma.resolve(option_id: option_id, reasoning: reasoning, framework: framework)
+                reinforce_chosen_foundations(chosen)
+                weaken_unchosen_foundations(dilemma.options, option_id)
+                add_history(type: :resolution, dilemma_id: dilemma_id, option_id: option_id,
+                            framework: framework, severity: dilemma.severity)
+                { success: true, dilemma: dilemma.to_h }
+              end
+
+              def apply_framework(dilemma_id:, framework:)
+                dilemma = @dilemmas[dilemma_id]
+                return { success: false, reason: :not_found } unless dilemma
+                return { success: false, reason: :unknown_framework } unless ETHICAL_FRAMEWORKS.include?(framework)
+
+                strategy  = FRAMEWORK_STRATEGIES.fetch(framework)
+                rankings  = send(strategy, dilemma)
+                { success: true, dilemma_id: dilemma_id, framework: framework, rankings: rankings }
+              end
+
+              def add_principle(name:, description:, foundation:, weight: DEFAULT_WEIGHT)
+                return { success: false, reason: :max_principles_reached } if @principles.size >= MAX_PRINCIPLES
+                return { success: false, reason: :unknown_foundation } unless MORAL_FOUNDATIONS.include?(foundation)
+
+                principle = {
+                  id:          generate_id('principle'),
+                  name:        name,
+                  description: description,
+                  foundation:  foundation,
+                  weight:      weight.clamp(WEIGHT_FLOOR, WEIGHT_CEILING),
+                  created_at:  Time.now.utc
+                }
+                @principles << principle
+                { success: true, principle: principle }
+              end
+
+              def moral_development
+                resolved = resolved_dilemmas
+                return { advanced: false, stage: @stage, reason: :insufficient_resolutions } if resolved.size < 3
+
+                avg_severity = resolved.sum(&:severity) / resolved.size.to_f
+                complexity_met = avg_severity >= 0.4 && resolved.size >= 5
+                current_idx = KOHLBERG_STAGES.index(@stage)
+
+                if complexity_met && current_idx < KOHLBERG_STAGES.size - 1
+                  @stage = KOHLBERG_STAGES[current_idx + 1]
+                  { advanced: true, stage: @stage, previous_stage: KOHLBERG_STAGES[current_idx] }
+                else
+                  { advanced: false, stage: @stage, reason: :complexity_threshold_not_met }
+                end
+              end
+
+              def foundation_profile
+                @foundations.transform_values(&:to_h)
+              end
+
+              def stage_info
+                level = KOHLBERG_LEVELS.find { |_, stages| stages.include?(@stage) }&.first
+                { stage: @stage, level: level, description: KOHLBERG_STAGE_DESCRIPTIONS.fetch(@stage, 'Unknown') }
+              end
+
+              def unresolved_dilemmas
+                @dilemmas.values.reject(&:resolved?)
+              end
+
+              def resolved_dilemmas
+                @dilemmas.values.select(&:resolved?)
+              end
+
+              def decay_all
+                @foundations.each_value(&:decay)
+              end
+
+              def to_h
+                {
+                  stage:               @stage,
+                  total_dilemmas:      @dilemmas.size,
+                  resolved_dilemmas:   resolved_dilemmas.size,
+                  unresolved_dilemmas: unresolved_dilemmas.size,
+                  principles:          @principles.size,
+                  history_entries:     @history.size,
+                  foundation_profile:  foundation_profile
+                }
+              end
+
+              private
+
+              def score_foundations(affected_foundations)
+                affected_foundations.sum do |fid|
+                  foundation = @foundations.fetch(fid, nil)
+                  next 0.0 unless foundation
+
+                  foundation.weight * foundation.sensitivity
+                end
+              end
+
+              def reinforce_chosen_foundations(chosen_option)
+                chosen_option.fetch(:foundations, []).each do |fid|
+                  @foundations[fid]&.reinforce(amount: chosen_option.fetch(:severity, 1.0))
+                end
+              end
+
+              def weaken_unchosen_foundations(options, chosen_id)
+                options.reject { |o| o[:id] == chosen_id }.each do |option|
+                  option.fetch(:foundations, []).each { |fid| @foundations[fid]&.weaken(amount: 0.5) }
+                end
+              end
+
+              def add_history(entry)
+                @history << entry.merge(timestamp: Time.now.utc)
+                @history.shift if @history.size > MAX_HISTORY
+              end
+
+              def generate_id(prefix)
+                "#{prefix}_#{Time.now.utc.to_f}_#{rand(1000)}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning/helpers/moral_foundation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Helpers
+            class MoralFoundation
+              include Constants
+
+              attr_reader :id, :weight, :sensitivity
+
+              def initialize(id:, weight: DEFAULT_WEIGHT, sensitivity: DEFAULT_WEIGHT)
+                @id          = id
+                @weight      = weight.clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+                @sensitivity = sensitivity.clamp(0.0, 1.0)
+              end
+
+              def reinforce(amount: 1.0)
+                @weight = (@weight + (amount * REINFORCEMENT_RATE)).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+              end
+
+              def weaken(amount: 1.0)
+                @weight = (@weight - (amount * REINFORCEMENT_RATE)).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+              end
+
+              def decay
+                @weight = (@weight - DECAY_RATE).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+              end
+
+              def to_h
+                {
+                  id:          @id,
+                  weight:      @weight,
+                  sensitivity: @sensitivity
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning/runners/moral_reasoning.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Runners
+            module MoralReasoning
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def evaluate_moral_action(action:, affected_foundations:, domain: :general, description: nil, **)
+                Legion::Logging.debug "[moral_reasoning] evaluate_action: action=#{action} domain=#{domain}"
+
+                if Helpers::LlmEnhancer.available?
+                  current_foundations = engine.foundation_profile.transform_values { |f| f[:weight] }
+                  llm_result = Helpers::LlmEnhancer.evaluate_action(
+                    action:      action,
+                    description: description.to_s,
+                    foundations: current_foundations
+                  )
+                  if llm_result
+                    Legion::Logging.debug "[moral_reasoning] using LLM evaluation for action=#{action}"
+                    result = engine.evaluate_action(
+                      action:               action,
+                      affected_foundations: affected_foundations,
+                      domain:               domain
+                    )
+                    return { success: true, source: :llm, reasoning: llm_result[:reasoning],
+                             foundation_impacts: llm_result[:foundation_impacts] }.merge(result)
+                  end
+                end
+
+                result = engine.evaluate_action(action: action, affected_foundations: affected_foundations, domain: domain)
+                { success: true, source: :mechanical }.merge(result)
+              end
+
+              def pose_moral_dilemma(description:, options:, domain: :general, severity: 0.5, **)
+                Legion::Logging.info "[moral_reasoning] pose_dilemma: domain=#{domain} severity=#{severity}"
+                engine.pose_dilemma(description: description, options: options, domain: domain, severity: severity)
+              end
+
+              def resolve_moral_dilemma(dilemma_id:, option_id:, reasoning:, framework:, **)
+                Legion::Logging.info "[moral_reasoning] resolve_dilemma: id=#{dilemma_id} framework=#{framework}"
+
+                if Helpers::LlmEnhancer.available?
+                  dilemma = engine.dilemmas[dilemma_id]
+                  if dilemma && !dilemma.resolved?
+                    llm_result = Helpers::LlmEnhancer.resolve_dilemma(
+                      dilemma_description: dilemma.description,
+                      options:             dilemma.options,
+                      framework:           framework
+                    )
+                    if llm_result
+                      Legion::Logging.debug "[moral_reasoning] using LLM resolution for dilemma=#{dilemma_id}"
+                      result = engine.resolve_dilemma(
+                        dilemma_id: dilemma_id,
+                        option_id:  option_id,
+                        reasoning:  llm_result[:reasoning],
+                        framework:  framework
+                      )
+                      return result.merge(source: :llm, llm_chosen: llm_result[:chosen_option],
+                                          llm_confidence: llm_result[:confidence])
+                    end
+                  end
+                end
+
+                engine.resolve_dilemma(dilemma_id: dilemma_id, option_id: option_id,
+                                       reasoning: reasoning, framework: framework)
+              end
+
+              def apply_ethical_framework(dilemma_id:, framework:, **)
+                Legion::Logging.debug "[moral_reasoning] apply_framework: id=#{dilemma_id} framework=#{framework}"
+                engine.apply_framework(dilemma_id: dilemma_id, framework: framework)
+              end
+
+              def add_moral_principle(name:, description:, foundation:, weight: Helpers::Constants::DEFAULT_WEIGHT, **)
+                Legion::Logging.info "[moral_reasoning] add_principle: name=#{name} foundation=#{foundation}"
+                engine.add_principle(name: name, description: description, foundation: foundation, weight: weight)
+              end
+
+              def check_moral_development(**)
+                Legion::Logging.debug '[moral_reasoning] check_moral_development'
+                result = engine.moral_development
+                { success: true }.merge(result)
+              end
+
+              def moral_foundation_profile(**)
+                Legion::Logging.debug '[moral_reasoning] foundation_profile'
+                { success: true, foundations: engine.foundation_profile }
+              end
+
+              def moral_stage_info(**)
+                Legion::Logging.debug '[moral_reasoning] stage_info'
+                { success: true }.merge(engine.stage_info)
+              end
+
+              def update_moral_reasoning(**)
+                Legion::Logging.debug '[moral_reasoning] decay_all'
+                engine.decay_all
+                { success: true, foundations: engine.foundation_profile }
+              end
+
+              def moral_reasoning_stats(**)
+                Legion::Logging.debug '[moral_reasoning] stats'
+                { success: true }.merge(engine.to_h)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::MoralEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          VERSION = '0.1.1'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'moral_reasoning/version'
+require_relative 'moral_reasoning/helpers/constants'
+require_relative 'moral_reasoning/helpers/moral_foundation'
+require_relative 'moral_reasoning/helpers/dilemma'
+require_relative 'moral_reasoning/helpers/moral_engine'
+require_relative 'moral_reasoning/helpers/llm_enhancer'
+require_relative 'moral_reasoning/runners/moral_reasoning'
+require_relative 'moral_reasoning/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/perspective_shifting/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/perspective_shifting/helpers/constants'
+require 'legion/extensions/agentic/social/perspective_shifting/helpers/perspective'
+require 'legion/extensions/agentic/social/perspective_shifting/helpers/perspective_view'
+require 'legion/extensions/agentic/social/perspective_shifting/helpers/shifting_engine'
+require 'legion/extensions/agentic/social/perspective_shifting/runners/perspective_shifting'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module PerspectiveShifting
+          class Client
+            include Runners::PerspectiveShifting
+
+            def initialize(**)
+              @shifting_engine = Helpers::ShiftingEngine.new
+            end
+
+            private
+
+            attr_reader :shifting_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/perspective_shifting/helpers/constants.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module PerspectiveShifting
+          module Helpers
+            module Constants
+              MAX_PERSPECTIVES             = 50
+              MAX_SITUATIONS               = 200
+              MAX_VIEWS_PER_SITUATION      = 20
+              DEFAULT_EMPATHY              = 0.5
+              MIN_PERSPECTIVES_FOR_SYNTHESIS = 2
+
+              PERSPECTIVE_TYPES = %i[
+                stakeholder emotional temporal cultural ethical pragmatic creative adversarial
+              ].freeze
+
+              PRIORITY_TYPES = %i[
+                safety efficiency fairness innovation stability growth autonomy compliance
+              ].freeze
+
+              EMPATHY_LABELS = {
+                (0.8..)     => :deeply_empathic,
+                (0.6...0.8) => :empathic,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :limited,
+                (..0.2)     => :detached
+              }.freeze
+
+              COVERAGE_LABELS = {
+                (0.8..)     => :comprehensive,
+                (0.6...0.8) => :thorough,
+                (0.4...0.6) => :partial,
+                (0.2...0.4) => :narrow,
+                (..0.2)     => :blind
+              }.freeze
+
+              AGREEMENT_LABELS = {
+                (0.8..)     => :consensus,
+                (0.6...0.8) => :agreement,
+                (0.4...0.6) => :mixed,
+                (0.2...0.4) => :disagreement,
+                (..0.2)     => :conflict
+              }.freeze
+
+              module_function
+
+              def empathy_label(value)
+                EMPATHY_LABELS.find { |range, _| range.include?(value) }&.last || :detached
+              end
+
+              def coverage_label(value)
+                COVERAGE_LABELS.find { |range, _| range.include?(value) }&.last || :blind
+              end
+
+              def agreement_label(value)
+                AGREEMENT_LABELS.find { |range, _| range.include?(value) }&.last || :conflict
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end