superinstance-equipment-consensus-engine 1.0.0

data/lib/equipment/consensus_engine/consensus_engine.rb

@@ -0,0 +1,451 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+require_relative 'weight_calculator'
+require_relative 'tripartite_deliberation'
+require_relative 'conflict_resolution'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # ConsensusEngine - Main equipment class for multi-agent deliberation
+      #
+      # Coordinates the tripartite deliberation process across Pathos (intent/emotion),
+      # Logos (logic/reason), and Ethos (truth/ethics) perspectives to build consensus.
+      #
+      # @example
+      #   engine = SuperInstance::Equipment::ConsensusEngine::ConsensusEngine.new(
+      #     max_rounds: 5,
+      #     confidence_threshold: 0.7,
+      #     domain: :balanced,
+      #     enable_audit: true
+      #   )
+      #
+      #   result = engine.deliberate(
+      #     proposition: 'Should we implement feature X?',
+      #     context: 'Given our current resources and timeline...'
+      #   )
+      class ConsensusEngine
+        # Creates a new ConsensusEngine instance
+        # @param config [Hash] Configuration options for the engine
+        def initialize(config = {})
+          @config = {
+            max_rounds: config[:max_rounds] || 5,
+            confidence_threshold: config[:confidence_threshold] || 0.7,
+            include_dissent: config.fetch(:include_dissent, true),
+            domain: config[:domain] || :balanced,
+            custom_weights: config[:custom_weights],
+            enable_audit: config.fetch(:enable_audit, true),
+            timeout: config[:timeout] || 30000
+          }
+
+          @deliberation = TripartiteDeliberation.new
+          @weight_calculator = WeightCalculator.new(@config[:custom_weights])
+          @conflict_resolution = ConflictResolution.new
+          @audit_trail = []
+          @audit_id_counter = 0
+
+          add_audit_entry(:deliberation_start, 'ConsensusEngine initialized', { config: @config })
+        end
+
+        # Conducts a deliberation on a proposition to reach consensus
+        # @param input [Hash] The deliberation input containing proposition and context
+        # @return [Hash] The consensus result
+        def deliberate(input)
+          start_time = Time.now.to_f * 1000
+          domain = input[:domain_override] || @config[:domain]
+
+          add_audit_entry(
+            :deliberation_start,
+            "Starting deliberation on: #{input[:proposition]}",
+            { domain: domain, context: input[:context] }
+          )
+
+          rounds = []
+          resolved_conflicts = []
+          consensus_reached = false
+          final_opinions = []
+
+          begin
+            # Conduct deliberation rounds
+            round_num = 1
+            while round_num <= @config[:max_rounds] && !consensus_reached
+              round = conduct_round(round_num, input, domain, final_opinions)
+              rounds << round
+
+              # Check for conflicts
+              conflicts = detect_conflicts(round[:opinions])
+              if conflicts.any?
+                add_audit_entry(
+                  :conflict_detected,
+                  "Detected #{conflicts.length} conflicts in round #{round_num}",
+                  { conflicts: conflicts.map { |c| { type: c[:type], perspectives: c[:perspectives] } } }
+                )
+
+                conflicts.each do |conflict|
+                  resolution = @conflict_resolution.resolve(conflict, round[:opinions])
+                  resolved_conflicts << resolution
+
+                  add_audit_entry(
+                    :conflict_resolved,
+                    "Resolved conflict: #{conflict[:type]}",
+                    { strategy: resolution[:strategy], outcome: resolution[:outcome] }
+                  )
+                end
+              end
+
+              # Check for consensus
+              consensus_reached = evaluate_consensus(round[:opinions])
+
+              if consensus_reached
+                add_audit_entry(
+                  :consensus_reached,
+                  "Consensus reached in round #{round_num}",
+                  { consensus_score: round[:interim_score] }
+                )
+              end
+
+              final_opinions = round[:opinions]
+              round_num += 1
+            end
+
+            # Calculate final confidence and verdict
+            verdict = synthesize_verdict(final_opinions, consensus_reached)
+            confidence = calculate_overall_confidence(final_opinions, consensus_reached)
+            dissenting_opinions = @config[:include_dissent] ?
+              final_opinions.select { |op| op[:confidence] < @config[:confidence_threshold] } :
+              nil
+
+            duration_ms = (Time.now.to_f * 1000 - start_time).to_i
+
+            add_audit_entry(:deliberation_complete, 'Deliberation completed', {
+              consensus_reached: consensus_reached,
+              verdict: verdict,
+              confidence: confidence,
+              duration_ms: duration_ms
+            })
+
+            {
+              consensus: consensus_reached,
+              verdict: verdict,
+              confidence: confidence,
+              perspectives: final_opinions,
+              rounds: rounds,
+              resolved_conflicts: resolved_conflicts,
+              dissenting_opinions: dissenting_opinions,
+              audit_trail: @audit_trail.dup,
+              metadata: {
+                duration_ms: duration_ms,
+                rounds_completed: rounds.length,
+                forced_consensus: !consensus_reached && rounds.length >= @config[:max_rounds],
+                domain: domain,
+                weight_profile: @weight_calculator.get_profile(domain),
+                conflicts_resolved: resolved_conflicts.length
+              }
+            }
+          rescue StandardError => e
+            error_message = e.message
+            add_audit_entry(:error, "Deliberation failed: #{error_message}", { error: error_message })
+            raise
+          end
+        end
+
+        # Clears the audit trail
+        def clear_audit_trail
+          @audit_trail.clear
+          @audit_id_counter = 0
+        end
+
+        # Gets the current audit trail
+        # @return [Array<Hash>] Audit trail entries
+        def get_audit_trail
+          @audit_trail.dup
+        end
+
+        # Updates the weight profile for a specific domain
+        # @param domain [Symbol] The domain to update
+        # @param weights [Hash] The weights to apply
+        def update_domain_weights(domain, weights)
+          @weight_calculator.set_profile(domain, weights)
+        end
+
+        # Gets the current configuration
+        # @return [Hash] Configuration
+        def get_config
+          @config.dup
+        end
+
+        private
+
+        # Conducts a single round of deliberation
+        def conduct_round(round_number, input, domain, previous_opinions)
+          weight_profile = @weight_calculator.get_profile(domain)
+          opinions = []
+          cross_examinations = []
+
+          # Gather opinions from each perspective
+          perspectives = PerspectiveType::ALL.to_a
+
+          perspectives.each do |perspective_type|
+            weight = get_perspective_weight(perspective_type, weight_profile)
+            analysis = @deliberation.analyze(
+              perspective_type,
+              input[:proposition],
+              input[:context],
+              previous_opinions
+            )
+
+            opinions << {
+              perspective: perspective_type,
+              verdict: analysis[:verdict],
+              confidence: analysis[:confidence],
+              arguments: analysis[:arguments],
+              concerns: analysis[:concerns],
+              weight: weight,
+              timestamp: Time.now
+            }
+          end
+
+          # Conduct cross-examinations between perspectives
+          perspectives.each_with_index do |challenger, i|
+            perspectives.drop(i + 1).each do |responder|
+              cross_exam = conduct_cross_examination(challenger, responder, opinions)
+              cross_examinations << cross_exam
+            end
+          end
+
+          # Apply cross-examination impacts to opinions
+          apply_cross_examination_impacts(opinions, cross_examinations)
+
+          interim_score = calculate_interim_score(opinions)
+          consensus_reached = evaluate_consensus(opinions)
+
+          {
+            round_number: round_number,
+            opinions: opinions,
+            cross_examinations: cross_examinations,
+            consensus_reached: consensus_reached,
+            interim_score: interim_score,
+            timestamp: Time.now
+          }
+        end
+
+        # Conducts cross-examination between two perspectives
+        def conduct_cross_examination(challenger, responder, opinions)
+          challenger_opinion = opinions.find { |op| op[:perspective] == challenger }
+          responder_opinion = opinions.find { |op| op[:perspective] == responder }
+
+          if !challenger_opinion || !responder_opinion
+            raise "Missing opinion for cross-examination: #{challenger} vs #{responder}"
+          end
+
+          challenge = generate_challenge(challenger, responder_opinion)
+          response = generate_response(responder, challenge)
+          satisfactory = evaluate_response(challenge, response, challenger)
+          impact = satisfactory ? 0 : -0.1
+
+          {
+            challenger: challenger,
+            responder: responder,
+            challenge: challenge,
+            response: response,
+            satisfactory: satisfactory,
+            impact: impact
+          }
+        end
+
+        # Generates a challenge from one perspective to another
+        def generate_challenge(challenger, target_opinion)
+          challenge_templates = {
+            pathos: [
+              'Does this decision truly serve the emotional needs of those affected?',
+              'Have we considered how this will make people feel?',
+              'Is there sufficient passion and commitment behind this choice?'
+            ],
+            logos: [
+              'What is the logical basis for this conclusion?',
+              'Are there any logical fallacies in the reasoning?',
+              'How does this conclusion follow from the premises?'
+            ],
+            ethos: [
+              'Is this decision ethically justifiable?',
+              'Does this align with our moral principles?',
+              'What are the broader ethical implications?'
+            ]
+          }
+
+          templates = challenge_templates[challenger] || []
+          templates[rand(templates.length)] || ''
+        end
+
+        # Generates a response to a challenge
+        def generate_response(responder, challenge)
+          response_templates = {
+            pathos: [
+              'The emotional impact has been carefully considered through empathy analysis.',
+              'We\'ve accounted for how stakeholders will emotionally respond to this.',
+              'The passion driving this decision is grounded in genuine care for outcomes.'
+            ],
+            logos: [
+              'The logical chain of reasoning has been validated through systematic analysis.',
+              'Each premise has been examined for consistency and soundness.',
+              'The conclusion follows deductively from well-established facts.'
+            ],
+            ethos: [
+              'This decision was evaluated against our core ethical framework.',
+              'Moral principles have been applied consistently throughout the analysis.',
+              'The ethical implications align with widely accepted standards of conduct.'
+            ]
+          }
+
+          templates = response_templates[responder] || []
+          templates[rand(templates.length)] || ''
+        end
+
+        # Evaluates whether a response is satisfactory
+        def evaluate_response(_challenge, response, _challenger)
+          # Simplified evaluation - in practice this would be more sophisticated
+          response.length > 20 && response.include?('considered')
+        end
+
+        # Applies cross-examination impacts to opinions
+        def apply_cross_examination_impacts(opinions, cross_examinations)
+          cross_examinations.each do |cross_exam|
+            responder_opinion = opinions.find { |op| op[:perspective] == cross_exam[:responder] }
+            if responder_opinion
+              responder_opinion[:confidence] = [
+                [responder_opinion[:confidence] + cross_exam[:impact], 0].max, 1
+              ].min
+            end
+          end
+        end
+
+        # Gets the weight for a specific perspective from a weight profile
+        def get_perspective_weight(perspective, profile)
+          case perspective
+          when :pathos
+            profile[:pathos_weight]
+          when :logos
+            profile[:logos_weight]
+          when :ethos
+            profile[:ethos_weight]
+          else
+            1.0 / 3.0
+          end
+        end
+
+        # Detects conflicts between perspective opinions
+        def detect_conflicts(opinions)
+          conflicts = []
+
+          # Check for high-confidence disagreements
+          high_confidence_opinions = opinions.select { |op| op[:confidence] >= @config[:confidence_threshold] }
+
+          if high_confidence_opinions.length >= 2
+            # Check if verdicts are contradictory
+            verdicts = high_confidence_opinions.map { |op| op[:verdict].downcase }
+            has_positive = verdicts.any? { |v| VerdictIndicators::POSITIVE.any? { |p| v.include?(p) } }
+            has_negative = verdicts.any? { |v| VerdictIndicators::NEGATIVE.any? { |n| v.include?(n) } }
+
+            if has_positive && has_negative
+              conflicts << {
+                type: :fundamental_disagreement,
+                perspectives: high_confidence_opinions.map { |op| op[:perspective] },
+                severity: :high,
+                description: 'Perspectives have fundamentally opposing views on the proposition',
+                context: {
+                  conflicting_verdicts: high_confidence_opinions.map do |op|
+                    { perspective: op[:perspective], verdict: op[:verdict] }
+                  end
+                }
+              }
+            end
+          end
+
+          # Check for low confidence across all perspectives
+          if opinions.all? { |op| op[:confidence] < @config[:confidence_threshold] }
+            conflicts << {
+              type: :uncertainty,
+              perspectives: opinions.map { |op| op[:perspective] },
+              severity: :medium,
+              description: 'All perspectives have low confidence in their assessments',
+              context: {
+                confidence_levels: opinions.map do |op|
+                  { perspective: op[:perspective], confidence: op[:confidence] }
+                end
+              }
+            }
+          end
+
+          conflicts
+        end
+
+        # Evaluates whether consensus has been reached
+        def evaluate_consensus(opinions)
+          # All opinions must meet confidence threshold
+          all_confident = opinions.all? { |op| op[:confidence] >= @config[:confidence_threshold] }
+
+          # Opinions should be aligned (simplified check)
+          verdicts = opinions.map { |op| op[:verdict].downcase }
+          is_aligned = are_verdicts_aligned(verdicts)
+
+          all_confident && is_aligned
+        end
+
+        # Checks if verdicts are aligned (not contradictory)
+        def are_verdicts_aligned(verdicts)
+          has_positive = verdicts.any? { |v| VerdictIndicators::POSITIVE.any? { |p| v.include?(p) } }
+          has_negative = verdicts.any? { |v| VerdictIndicators::NEGATIVE.any? { |n| v.include?(n) } }
+
+          !(has_positive && has_negative)
+        end
+
+        # Calculates interim consensus score
+        def calculate_interim_score(opinions)
+          total_weight = opinions.sum { |op| op[:weight] }
+          weighted_confidence = opinions.sum { |op| op[:confidence] * op[:weight] }
+          total_weight > 0 ? weighted_confidence / total_weight : 0
+        end
+
+        # Synthesizes a final verdict from all perspectives
+        def synthesize_verdict(opinions, consensus_reached)
+          if consensus_reached
+            # All perspectives agree - use the most confident opinion as template
+            sorted_opinions = opinions.sort_by { |op| -op[:confidence] }
+            return sorted_opinions[0]&.dig(:verdict) || 'Consensus reached'
+          end
+
+          # No consensus - synthesize a balanced view
+          parts = opinions.map do |opinion|
+            "[#{opinion[:perspective]}]: #{opinion[:verdict]} (#{(opinion[:confidence] * 100).round(0)}% confidence)"
+          end
+
+          "No single consensus reached. Perspectives differ:\n#{parts.join("\n")}"
+        end
+
+        # Calculates overall confidence in the result
+        def calculate_overall_confidence(opinions, consensus_reached)
+          total_weight = opinions.sum { |op| op[:weight] }
+          weighted_confidence = opinions.sum { |op| op[:confidence] * op[:weight] }
+          base_confidence = total_weight > 0 ? weighted_confidence / total_weight : 0
+
+          # Boost confidence if consensus was reached
+          consensus_reached ? [base_confidence * 1.1, 1.0].min : base_confidence * 0.9
+        end
+
+        # Adds an entry to the audit trail
+        def add_audit_entry(action, description, data = nil)
+          return unless @config[:enable_audit]
+
+          @audit_trail << {
+            id: "audit-#{@audit_id_counter += 1}",
+            timestamp: Time.now,
+            action: action,
+            description: description,
+            data: data
+          }
+        end
+      end
+    end
+  end
+end