superinstance-equipment-consensus-engine 1.0.0

data/lib/equipment/consensus_engine/conflict_resolution.rb

@@ -0,0 +1,507 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # ConflictResolution - Resolve disagreements between perspectives
+      #
+      # Implements strategies for detecting and resolving conflicts when
+      # Pathos, Logos, and Ethos perspectives disagree on a proposition.
+      class ConflictResolution
+        # Default resolution configuration
+        DEFAULT_CONFIG = {
+          max_attempts: 3,
+          min_confidence: 0.6,
+          allow_escalation: true
+        }.freeze
+
+        # Creates a new ConflictResolution instance
+        # @param config [Hash] Optional configuration overrides
+        def initialize(config = {})
+          @config = DEFAULT_CONFIG.merge(config)
+          @resolution_history = []
+        end
+
+        # Resolves a conflict between perspectives
+        # @param conflict [Hash] The conflict to resolve
+        # @param opinions [Array<Hash>] Current perspective opinions
+        # @return [Hash] The resolution result
+        def resolve(conflict, opinions)
+          # Select appropriate resolution strategy based on conflict type
+          strategy = select_strategy(conflict, opinions)
+
+          # Apply the selected strategy
+          result = apply_strategy(strategy, conflict, opinions)
+
+          # If resolution failed, try alternative strategies
+          attempts = 1
+          while !result[:resolved] && attempts < @config[:max_attempts]
+            alternative_strategy = select_alternative_strategy(strategy, conflict, result)
+            result = apply_strategy(alternative_strategy, conflict, opinions)
+            attempts += 1
+          end
+
+          # Record the resolution attempt
+          @resolution_history << {
+            conflict: conflict,
+            result: result,
+            timestamp: Time.now
+          }
+
+          result
+        end
+
+        # Gets the resolution history
+        # @return [Array<Hash>] Resolution history
+        def get_history
+          @resolution_history.dup
+        end
+
+        # Clears the resolution history
+        def clear_history
+          @resolution_history.clear
+        end
+
+        # Gets statistics about resolutions
+        # @return [Hash] Resolution statistics
+        def get_stats
+          total = @resolution_history.length
+          successful = @resolution_history.count { |r| r[:result][:resolved] }
+
+          strategy_usage = Hash.new(0)
+          total_confidence = 0.0
+
+          @resolution_history.each do |entry|
+            strategy_usage[entry[:result][:strategy]] += 1
+            total_confidence += entry[:result][:confidence]
+          end
+
+          {
+            total_resolutions: total,
+            successful_resolutions: successful,
+            strategy_usage: strategy_usage,
+            average_confidence: total > 0 ? total_confidence / total : 0
+          }
+        end
+
+        private
+
+        # Selects the best resolution strategy for a conflict
+        def select_strategy(conflict, opinions)
+          # Strategy selection based on conflict type
+          strategy_map = {
+            fundamental_disagreement: %i[compromise reframing escalation],
+            uncertainty: %i[deliberation_extension suspension],
+            partial_disagreement: %i[weighted_voting conditional_approval],
+            weight_imbalance: %i[perspective_dominance reframing],
+            cross_perspective_tension: %i[compromise deliberation_extension],
+            context_inconsistency: %i[reframing deliberation_extension]
+          }
+
+          strategies = strategy_map[conflict[:type]] || %i[weighted_voting]
+
+          # Consider severity
+          if conflict[:severity] == :critical && @config[:allow_escalation]
+            return :escalation
+          end
+
+          if conflict[:severity] == :high
+            # Use more deliberative strategies for high severity
+            deliberative_strategy = strategies.find do |s|
+              s == :compromise || s == :deliberation_extension
+            end
+            return deliberative_strategy if deliberative_strategy
+          end
+
+          # Use first available strategy
+          strategies[0] || :weighted_voting
+        end
+
+        # Selects an alternative strategy when primary fails
+        def select_alternative_strategy(failed_strategy, conflict, previous_result)
+          preferred_strategies = %i[
+            weighted_voting compromise conditional_approval
+            deliberation_extension reframing escalation
+          ]
+
+          current_index = preferred_strategies.index(failed_strategy)
+          next_index = current_index + 1
+
+          if next_index < preferred_strategies.length
+            return preferred_strategies[next_index]
+          end
+
+          # If we've tried all preferred strategies, use escalation as last resort
+          return :escalation if @config[:allow_escalation]
+
+          :suspension
+        end
+
+        # Applies a specific resolution strategy
+        def apply_strategy(strategy, conflict, opinions)
+          case strategy
+          when :weighted_voting
+            apply_weighted_voting(conflict, opinions)
+          when :deliberation_extension
+            apply_deliberation_extension(conflict, opinions)
+          when :reframing
+            apply_reframing(conflict, opinions)
+          when :escalation
+            apply_escalation(conflict, opinions)
+          when :compromise
+            apply_compromise(conflict, opinions)
+          when :conditional_approval
+            apply_conditional_approval(conflict, opinions)
+          when :suspension
+            apply_suspension(conflict, opinions)
+          when :perspective_dominance
+            apply_perspective_dominance(conflict, opinions)
+          else
+            create_unresolved_result(strategy, conflict)
+          end
+        end
+
+        # Applies weighted voting strategy
+        def apply_weighted_voting(conflict, opinions)
+          # Calculate weighted scores
+          positive_score = 0.0
+          negative_score = 0.0
+
+          opinions.each do |opinion|
+            verdict = opinion[:verdict].downcase
+            is_positive = VerdictIndicators::POSITIVE.any? { |p| verdict.include?(p) }
+            is_negative = VerdictIndicators::NEGATIVE.any? { |n| verdict.include?(n) }
+
+            if is_positive
+              positive_score += opinion[:weight] * opinion[:confidence]
+            elsif is_negative
+              negative_score += opinion[:weight] * opinion[:confidence]
+            end
+          end
+
+          total_score = positive_score + negative_score
+          verdict = positive_score > negative_score ? 'Proceed with the proposition' : 'Decline the proposition'
+          confidence = total_score > 0 ? (positive_score - negative_score).abs / total_score : 0.5
+
+          accepted = opinions.select do |op|
+            verdict_lower = op[:verdict].downcase
+            is_positive = VerdictIndicators::POSITIVE.any? { |p| verdict_lower.include?(p) }
+            (positive_score > negative_score) == is_positive
+          end.map { |op| op[:perspective] }
+
+          rejected = opinions.select do |op|
+            verdict_lower = op[:verdict].downcase
+            is_positive = VerdictIndicators::POSITIVE.any? { |p| verdict_lower.include?(p) }
+            (positive_score > negative_score) != is_positive
+          end.map { |op| op[:perspective] }
+
+          {
+            resolved: confidence >= @config[:min_confidence],
+            strategy: :weighted_voting,
+            outcome: "Weighted voting resulted in #{positive_score > negative_score ? 'approval' : 'rejection'} with #{(confidence * 100).round(1)}% confidence",
+            verdict: verdict,
+            confidence: confidence,
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: accepted,
+            rejected_by: rejected
+          }
+        end
+
+        # Applies deliberation extension strategy
+        def apply_deliberation_extension(conflict, opinions)
+          focus_areas = identify_focus_areas(conflict, opinions)
+
+          {
+            resolved: false,
+            strategy: :deliberation_extension,
+            outcome: 'Additional deliberation rounds required',
+            confidence: 0,
+            conditions: [
+              "Conduct additional deliberation focusing on: #{focus_areas.join(', ')}",
+              'Re-evaluate after gathering more information'
+            ],
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: [],
+            rejected_by: []
+          }
+        end
+
+        # Applies reframing strategy
+        def apply_reframing(conflict, opinions)
+          # Generate reframed propositions
+          reframed_options = generate_reframed_options(opinions)
+
+          {
+            resolved: false,
+            strategy: :reframing,
+            outcome: 'Proposition should be reframed to address conflicting perspectives',
+            confidence: 0,
+            conditions: reframed_options.each_with_index.map { |option, i| "Alternative #{i + 1}: #{option}" },
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: [],
+            rejected_by: []
+          }
+        end
+
+        # Applies escalation strategy
+        def apply_escalation(conflict, opinions)
+          summary = summarize_conflict(conflict, opinions)
+
+          {
+            resolved: false,
+            strategy: :escalation,
+            outcome: 'Decision requires escalation to higher authority',
+            confidence: 0,
+            conditions: [
+              'Present all perspectives to decision-making authority',
+              "Conflict summary: #{summary}",
+              'Await authoritative decision'
+            ],
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: [],
+            rejected_by: opinions.map { |op| op[:perspective] }
+          }
+        end
+
+        # Applies compromise strategy
+        def apply_compromise(conflict, opinions)
+          mediation = mediate_between_perspectives(opinions)
+
+          {
+            resolved: mediation[:success],
+            strategy: :compromise,
+            outcome: mediation[:success] ? 'Compromise reached between perspectives' : 'Unable to reach compromise',
+            verdict: mediation[:position],
+            confidence: mediation[:confidence],
+            conditions: mediation[:compromises].map { |c| "#{c[:perspective]}: #{c[:concession]}" },
+            remaining_concerns: mediation[:needs_further_deliberation] ? ['Further deliberation may refine the compromise'] : [],
+            accepted_by: mediation[:compromises].map { |c| c[:perspective] },
+            rejected_by: []
+          }
+        end
+
+        # Applies conditional approval strategy
+        def apply_conditional_approval(conflict, opinions)
+          conditions = generate_conditions(opinions)
+          accepting_perspectives = opinions.filter { |op| op[:confidence] >= 0.5 }
+
+          {
+            resolved: conditions.any?,
+            strategy: :conditional_approval,
+            outcome: 'Conditional approval granted subject to requirements',
+            verdict: 'Conditionally approved',
+            confidence: 0.65,
+            conditions: conditions,
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: accepting_perspectives.map { |op| op[:perspective] },
+            rejected_by: opinions.filter { |op| op[:confidence] < 0.5 }.map { |op| op[:perspective] }
+          }
+        end
+
+        # Applies suspension strategy
+        def apply_suspension(conflict, opinions)
+          requirements = identify_information_requirements(conflict, opinions)
+
+          {
+            resolved: false,
+            strategy: :suspension,
+            outcome: 'Decision suspended pending additional information',
+            confidence: 0,
+            conditions: requirements,
+            remaining_concerns: extract_remaining_concerns(opinions),
+            accepted_by: [],
+            rejected_by: []
+          }
+        end
+
+        # Applies perspective dominance strategy
+        def apply_perspective_dominance(conflict, opinions)
+          # Find the perspective with highest weighted confidence
+          weighted_opinions = opinions.map do |op|
+            op.merge(weighted_confidence: op[:confidence] * op[:weight])
+          end
+
+          weighted_opinions.sort! { |a, b| b[:weighted_confidence] <=> a[:weighted_confidence] }
+          dominant_opinion = weighted_opinions[0]
+
+          {
+            resolved: true,
+            strategy: :perspective_dominance,
+            outcome: "Decision based on dominant #{dominant_opinion[:perspective]} perspective",
+            verdict: dominant_opinion[:verdict],
+            confidence: dominant_opinion[:confidence],
+            conditions: [
+              "Note: Decision primarily driven by #{dominant_opinion[:perspective]} considerations",
+              'Other perspectives had lower weighted confidence'
+            ],
+            remaining_concerns: opinions
+              .reject { |op| op[:perspective] == dominant_opinion[:perspective] }
+              .flat_map { |op| op[:concerns] },
+            accepted_by: [dominant_opinion[:perspective]],
+            rejected_by: opinions
+              .reject { |op| op[:perspective] == dominant_opinion[:perspective] }
+              .map { |op| op[:perspective] }
+          }
+        end
+
+        # Creates an unresolved result
+        def create_unresolved_result(strategy, conflict)
+          {
+            resolved: false,
+            strategy: strategy,
+            outcome: 'Unable to resolve conflict with available strategies',
+            confidence: 0,
+            remaining_concerns: [conflict[:description]],
+            accepted_by: [],
+            rejected_by: conflict[:perspectives]
+          }
+        end
+
+        # Identifies focus areas for extended deliberation
+        def identify_focus_areas(conflict, opinions)
+          areas = []
+
+          opinions.each do |opinion|
+            if opinion[:concerns]&.any?
+              areas.concat(opinion[:concerns].slice(0, 2))
+            end
+          end
+
+          areas.uniq.slice(0, 5)
+        end
+
+        # Generates reframed proposition options
+        def generate_reframed_options(opinions)
+          options = []
+
+          logos_op = opinions.find { |op| op[:perspective] == :logos }
+          pathos_op = opinions.find { |op| op[:perspective] == :pathos }
+          ethos_op = opinions.find { |op| op[:perspective] == :ethos }
+
+          if logos_op && pathos_op
+            options << "Consider a modified approach that addresses #{logos_op[:arguments][0] || 'logical concerns'} while being mindful of #{pathos_op[:arguments][0] || 'emotional impact'}"
+          end
+
+          if ethos_op
+            options << "Ensure the proposition aligns with #{ethos_op[:arguments][0] || 'ethical principles'} before proceeding"
+          end
+
+          options
+        end
+
+        # Summarizes a conflict for escalation
+        def summarize_conflict(conflict, opinions)
+          perspective_views = opinions.map do |op|
+            "#{op[:perspective]}: #{op[:verdict][0..50]}..."
+          end.join('; ')
+
+          "#{conflict[:type]} (#{conflict[:severity]}): #{conflict[:description]}. Perspectives: #{perspective_views}"
+        end
+
+        # Mediates between perspectives to find compromise
+        def mediate_between_perspectives(opinions)
+          compromises = []
+
+          # Find common ground
+          common_arguments = find_common_arguments(opinions)
+
+          # Generate compromise positions for each perspective
+          opinions.each do |opinion|
+            concession = generate_concession(opinion, common_arguments)
+            compromises << {
+              perspective: opinion[:perspective],
+              concession: concession
+            }
+          end
+
+          # Calculate confidence based on compromise alignment
+          avg_confidence = opinions.sum { |op| op[:confidence] }.to_f / opinions.length
+
+          {
+            success: compromises.length == opinions.length,
+            position: "Compromise position: #{common_arguments.join(' and ')}",
+            confidence: avg_confidence * 0.8,
+            compromises: compromises,
+            needs_further_deliberation: avg_confidence < @config[:min_confidence]
+          }
+        end
+
+        # Finds common arguments across perspectives
+        def find_common_arguments(opinions)
+          all_arguments = opinions.flat_map { |op| op[:arguments] || [] }
+
+          unique_arguments = []
+          all_arguments.each do |arg|
+            is_similar = unique_arguments.any? { |existing| are_arguments_similar(existing, arg) }
+            unless is_similar
+              unique_arguments << arg
+            end
+          end
+
+          unique_arguments.slice(0, 3)
+        end
+
+        # Checks if two arguments are semantically similar
+        def are_arguments_similar(arg1, arg2)
+          words1 = arg1.downcase.split(/\s+/)
+          words2 = arg2.downcase.split(/\s+/)
+          common_words = words1 & words2
+          common_words.length >= 3
+        end
+
+        # Generates a concession for a perspective
+        def generate_concession(opinion, common_arguments)
+          if opinion[:concerns]&.any?
+            "Willing to proceed if #{opinion[:concerns][0].downcase} is addressed"
+          else
+            "Accepting common ground on #{common_arguments[0] || 'shared interests'}"
+          end
+        end
+
+        # Generates conditions for conditional approval
+        def generate_conditions(opinions)
+          conditions = []
+
+          opinions.each do |opinion|
+            if opinion[:concerns]&.any?
+              conditions << "#{opinion[:perspective]}: Address #{opinion[:concerns][0].downcase}"
+            end
+          end
+
+          conditions.slice(0, 5)
+        end
+
+        # Identifies information requirements for suspension
+        def identify_information_requirements(conflict, opinions)
+          requirements = []
+
+          case conflict[:type]
+          when :fundamental_disagreement
+            requirements << 'Gather additional evidence to resolve fundamental disagreements'
+          when :uncertainty
+            requirements << 'Obtain more information to reduce uncertainty'
+          when :context_inconsistency
+            requirements << 'Clarify contextual factors causing interpretation differences'
+          else
+            requirements << 'Conduct further analysis before proceeding'
+          end
+
+          opinions.each do |opinion|
+            if opinion[:confidence] < 0.5
+              requirements << "Address #{opinion[:perspective]} perspective's low confidence"
+            end
+          end
+
+          requirements
+        end
+
+        # Extracts remaining concerns from opinions
+        def extract_remaining_concerns(opinions)
+          opinions.flat_map { |op| op[:concerns] || [] }.slice(0, 5)
+        end
+      end
+    end
+  end
+end