superinstance-equipment-consensus-engine 1.0.0

data/lib/equipment/consensus_engine/types.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # Types module containing shared type constants and enums
+
+      # Types of tripartite perspectives
+      module PerspectiveType
+        PATHOS = :pathos
+        LOGOS = :logos
+        ETHOS = :ethos
+
+        ALL = Set[:pathos, :logos, :ethos].freeze
+
+        def self.valid?(value)
+          ALL.include?(value)
+        end
+      end
+
+      # Alias for TripartitePerspective
+      TripartitePerspective = PerspectiveType
+
+      # Types of domains that affect perspective weighting
+      module DomainType
+        FACTUAL = :factual
+        EMOTIONAL = :emotional
+        SENSITIVE = :sensitive
+        CREATIVE = :creative
+        BALANCED = :balanced
+        TECHNICAL = :technical
+        SOCIAL = :social
+        BUSINESS = :business
+        PERSONAL = :personal
+        MARITIME = :maritime
+
+        ALL = Set[
+          :factual, :emotional, :sensitive, :creative, :balanced,
+          :technical, :social, :business, :personal, :maritime
+        ].freeze
+
+        def self.valid?(value)
+          ALL.include?(value)
+        end
+      end
+
+      # Types of conflicts that can occur between perspectives
+      module ConflictType
+        FUNDAMENTAL_DISAGREEMENT = :fundamental_disagreement
+        UNCERTAINTY = :uncertainty
+        PARTIAL_DISAGREEMENT = :partial_disagreement
+        WEIGHT_IMBALANCE = :weight_imbalance
+        CROSS_PERSPECTIVE_TENSION = :cross_perspective_tension
+        CONTEXT_INCONSISTENCY = :context_inconsistency
+
+        ALL = Set[
+          :fundamental_disagreement, :uncertainty, :partial_disagreement,
+          :weight_imbalance, :cross_perspective_tension, :context_inconsistency
+        ].freeze
+      end
+
+      # Severity levels for conflicts
+      module ConflictSeverity
+        LOW = :low
+        MEDIUM = :medium
+        HIGH = :high
+        CRITICAL = :critical
+
+        ALL = Set[:low, :medium, :high, :critical].freeze
+      end
+
+      # Strategies for resolving conflicts
+      module ResolutionStrategy
+        WEIGHTED_VOTING = :weighted_voting
+        DELIBERATION_EXTENSION = :deliberation_extension
+        REFRAMING = :reframing
+        ESCALATION = :escalation
+        COMPROMISE = :compromise
+        CONDITIONAL_APPROVAL = :conditional_approval
+        SUSPENSION = :suspension
+        PERSPECTIVE_DOMINANCE = :perspective_dominance
+
+        ALL = Set[
+          :weighted_voting, :deliberation_extension, :reframing,
+          :escalation, :compromise, :conditional_approval,
+          :suspension, :perspective_dominance
+        ].freeze
+      end
+
+      # Deliberation mode affects how perspectives interact
+      module DeliberationMode
+        COLLABORATIVE = :collaborative
+        ADVERSARIAL = :adversarial
+        INQUISITIVE = :inquisitive
+        SYNTHESIZING = :synthesizing
+
+        ALL = Set[:collaborative, :adversarial, :inquisitive, :synthesizing].freeze
+      end
+
+      # Audit entry action types
+      module AuditAction
+        DELIBERATION_START = :deliberation_start
+        ROUND_COMPLETE = :round_complete
+        CONFLICT_DETECTED = :conflict_detected
+        CONFLICT_RESOLVED = :conflict_resolved
+        CONSENSUS_REACHED = :consensus_reached
+        TIMEOUT = :timeout
+        ERROR = :error
+        DELIBERATION_COMPLETE = :deliberation_complete
+
+        ALL = Set[
+          :deliberation_start, :round_complete, :conflict_detected,
+          :conflict_resolved, :consensus_reached, :timeout,
+          :error, :deliberation_complete
+        ].freeze
+      end
+
+      # Logial structure types for logos perspective
+      module LogicalStructure
+        DEDUCTIVE = :deductive
+        INDUCTIVE = :inductive
+        ABDUCTIVE = :abductive
+        ANALOGICAL = :analogical
+
+        ALL = Set[:deductive, :inductive, :abductive, :analogical].freeze
+      end
+
+      # Ethical framework types for ethos perspective
+      module EthicalFramework
+        UTILITARIAN = :utilitarian
+        DEONTOLOGICAL = :deontological
+        VIRTUE_ETHICS = :virtue_ethics
+        CARE_ETHICS = :care_ethics
+
+        ALL = Set[:utilitarian, :deontological, :virtue_ethics, :care_ethics].freeze
+      end
+
+      # Cross-examination evaluation types
+      module CrossExaminationEvaluation
+        SATISFACTORY = :satisfactory
+        UNSATISFACTORY = :unsatisfactory
+        NEEDS_CLARIFICATION = :needs_clarification
+
+        ALL = Set[:satisfactory, :unsatisfactory, :needs_clarification].freeze
+      end
+
+      # Keyword sets for verdict analysis
+      module VerdictIndicators
+        POSITIVE = Set[
+          'yes', 'agree', 'support', 'affirm', 'positive', 'true', 'proceed'
+        ].freeze
+
+        NEGATIVE = Set[
+          'no', 'disagree', 'oppose', 'reject', 'negative', 'false', 'decline'
+        ].freeze
+      end
+
+      # Keyword sets for domain detection
+      module DomainKeywords
+        FACTUAL = {
+          'data' => 2, 'research' => 2, 'study' => 1, 'analysis' => 1,
+          'evidence' => 2, 'scientific' => 2, 'measurement' => 1,
+          'statistic' => 2, 'empirical' => 2, 'hypothesis' => 1,
+          'experiment' => 1, 'result' => 1, 'fact' => 1
+        }.freeze
+
+        EMOTIONAL = {
+          'feel' => 2, 'emotion' => 2, 'relationship' => 1, 'care' => 1,
+          'love' => 2, 'passion' => 2, 'heart' => 2, 'empathy' => 2,
+          'connection' => 1, 'support' => 1, 'understand' => 1,
+          'personal' => 1, 'family' => 1, 'friend' => 1
+        }.freeze
+
+        SENSITIVE = {
+          'ethics' => 2, 'moral' => 2, 'right' => 1, 'wrong' => 1,
+          'justice' => 2, 'fair' => 1, 'equality' => 2, 'rights' => 2,
+          'dignity' => 2, 'vulnerable' => 2, 'discrimination' => 2,
+          'privacy' => 1, 'consent' => 2, 'harm' => 2
+        }.freeze
+
+        CREATIVE = {
+          'creative' => 2, 'innovative' => 2, 'design' => 1, 'art' => 2,
+          'imagine' => 1, 'explore' => 1, 'novel' => 1, 'original' => 2,
+          'express' => 1, 'aesthetic' => 2, 'beauty' => 1, 'inspire' => 1,
+          'vision' => 1, 'transform' => 1
+        }.freeze
+
+        TECHNICAL = {
+          'technical' => 2, 'engineering' => 2, 'system' => 1,
+          'implement' => 1, 'architecture' => 2, 'code' => 1,
+          'algorithm' => 2, 'optimize' => 1, 'performance' => 1,
+          'infrastructure' => 2, 'specification' => 1, 'integration' => 1,
+          'deploy' => 1, 'scalability' => 1
+        }.freeze
+
+        SOCIAL = {
+          'community' => 2, 'society' => 2, 'public' => 1, 'social' => 2,
+          'people' => 1, 'collective' => 2, 'together' => 1, 'group' => 1,
+          'shared' => 1, 'common' => 1, 'collaborative' => 1,
+          'participate' => 1, 'democratic' => 2, 'citizens' => 2
+        }.freeze
+
+        BUSINESS = {
+          'business' => 2, 'profit' => 2, 'market' => 1, 'revenue' => 2,
+          'customer' => 1, 'strategy' => 1, 'competitive' => 1,
+          'investment' => 1, 'roi' => 2, 'stakeholder' => 1, 'growth' => 1,
+          'enterprise' => 1, 'commercial' => 2, 'industry' => 1
+        }.freeze
+
+        PERSONAL = {
+          'personal' => 2, 'individual' => 1, 'self' => 2, 'my' => 1,
+          'myself' => 2, 'life' => 1, 'choice' => 1, 'decision' => 1,
+          'goal' => 1, 'future' => 1, 'happiness' => 2, 'fulfillment' => 2,
+          'wellbeing' => 1, 'career' => 1
+        }.freeze
+
+        MARITIME = {
+          'vessel' => 2, 'crew' => 2, 'safety' => 2, 'captain' => 2,
+          'fleet' => 1, 'navigation' => 2, 'weather' => 1, 'sea' => 1,
+          'port' => 1, 'harbor' => 1, 'maritime' => 2, 'fishing' => 1,
+          'catch' => 1, 'tide' => 1, 'anchor' => 1, 'deck' => 1,
+          'haul' => 1, 'sortie' => 2, 'bearing' => 1, 'course' => 1
+        }.freeze
+      end
+    end
+  end
+end

data/lib/equipment/consensus_engine/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      VERSION = '1.0.0'
+    end
+  end
+end

data/lib/equipment/consensus_engine/weight_calculator.rb

@@ -0,0 +1,438 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # WeightCalculator - Domain-specific weight calculation for perspectives
+      #
+      # Calculates appropriate weights for Pathos, Logos, and Ethos perspectives
+      # based on the domain of the deliberation.
+      #
+      # @example
+      #   calculator = SuperInstance::Equipment::ConsensusEngine::WeightCalculator.new
+      #
+      #   # Get weights for a factual domain
+      #   factual_profile = calculator.get_profile(:factual)
+      #   puts factual_profile[:logos_weight]  # 0.60
+      #
+      #   # Calculate adjusted weights based on content
+      #   adjusted = calculator.calculate_adjusted_weights(
+      #     :sensitive,
+      #     'This decision affects vulnerable populations...'
+      #   )
+      class WeightCalculator
+        # Domain characteristics for analysis
+        DOMAIN_CHARACTERISTICS = {
+          factual: {
+            emotional_importance: 0.2,
+            logical_importance: 0.8,
+            ethical_importance: 0.4,
+            uncertainty_level: 0.3,
+            stakeholder_complexity: 0.3
+          },
+          emotional: {
+            emotional_importance: 0.8,
+            logical_importance: 0.3,
+            ethical_importance: 0.5,
+            uncertainty_level: 0.5,
+            stakeholder_complexity: 0.7
+          },
+          sensitive: {
+            emotional_importance: 0.6,
+            logical_importance: 0.4,
+            ethical_importance: 0.9,
+            uncertainty_level: 0.4,
+            stakeholder_complexity: 0.8
+          },
+          creative: {
+            emotional_importance: 0.7,
+            logical_importance: 0.5,
+            ethical_importance: 0.4,
+            uncertainty_level: 0.6,
+            stakeholder_complexity: 0.4
+          },
+          balanced: {
+            emotional_importance: 0.5,
+            logical_importance: 0.5,
+            ethical_importance: 0.5,
+            uncertainty_level: 0.5,
+            stakeholder_complexity: 0.5
+          },
+          technical: {
+            emotional_importance: 0.1,
+            logical_importance: 0.9,
+            ethical_importance: 0.3,
+            uncertainty_level: 0.2,
+            stakeholder_complexity: 0.2
+          },
+          social: {
+            emotional_importance: 0.7,
+            logical_importance: 0.4,
+            ethical_importance: 0.6,
+            uncertainty_level: 0.5,
+            stakeholder_complexity: 0.9
+          },
+          business: {
+            emotional_importance: 0.4,
+            logical_importance: 0.7,
+            ethical_importance: 0.5,
+            uncertainty_level: 0.4,
+            stakeholder_complexity: 0.6
+          },
+          maritime: {
+            emotional_importance: 0.3,
+            logical_importance: 0.8,
+            ethical_importance: 0.6,
+            uncertainty_level: 0.5,
+            stakeholder_complexity: 0.4
+          },
+          personal: {
+            emotional_importance: 0.8,
+            logical_importance: 0.4,
+            ethical_importance: 0.4,
+            uncertainty_level: 0.6,
+            stakeholder_complexity: 0.3
+          }
+        }.freeze
+
+        # Creates a new WeightCalculator instance
+        # @param custom_weights [Hash] Optional custom weight overrides to apply to all profiles
+        def initialize(custom_weights = {})
+          @profiles = build_default_profiles
+          @custom_overrides = custom_weights
+        end
+
+        # Gets the weight profile for a specific domain
+        # @param domain [Symbol] The domain to get weights for
+        # @return [Hash] The weight profile for the domain
+        def get_profile(domain)
+          base_profile = @profiles[domain]
+          raise ArgumentError, "Unknown domain: #{domain}" unless base_profile
+
+          # Apply custom overrides
+          base_profile.merge(@custom_overrides).merge(domain: domain)
+        end
+
+        # Sets a custom weight profile for a domain
+        # @param domain [Symbol] The domain to set
+        # @param weights [Hash] The weights to apply
+        def set_profile(domain, weights)
+          current = @profiles[domain]
+          raise ArgumentError, "Unknown domain: #{domain}" unless current
+
+          # Normalize weights to sum to 1
+          raw_pathos = weights[:pathos_weight] || current[:pathos_weight]
+          raw_logos = weights[:logos_weight] || current[:logos_weight]
+          raw_ethos = weights[:ethos_weight] || current[:ethos_weight]
+          total = raw_pathos + raw_logos + raw_ethos
+
+          @profiles[domain] = {
+            pathos_weight: raw_pathos / total,
+            logos_weight: raw_logos / total,
+            ethos_weight: raw_ethos / total,
+            domain: domain,
+            description: weights[:description] || current[:description],
+            adjustment_rules: current[:adjustment_rules]
+          }
+        end
+
+        # Calculates adjusted weights based on content analysis
+        # @param domain [Symbol] The base domain
+        # @param content [String] The content to analyze
+        # @param base_weights [Hash, nil] Optional base weights to start from
+        # @return [Hash] Adjusted weight profile
+        def calculate_adjusted_weights(domain, content, base_weights = nil)
+          base_profile = base_weights || get_profile(domain)
+          rules = base_profile[:adjustment_rules] || []
+
+          # Sort rules by priority
+          sorted_rules = rules.sort_by { |r| -r[:priority] }
+
+          pathos_weight = base_profile[:pathos_weight]
+          logos_weight = base_profile[:logos_weight]
+          ethos_weight = base_profile[:ethos_weight]
+
+          # Apply matching rules
+          sorted_rules.each do |rule|
+            if matches_condition(content, rule[:condition])
+              case rule[:perspective]
+              when :pathos
+                pathos_weight += rule[:adjustment]
+              when :logos
+                logos_weight += rule[:adjustment]
+              when :ethos
+                ethos_weight += rule[:adjustment]
+              end
+            end
+          end
+
+          # Normalize to sum to 1
+          total = pathos_weight + logos_weight + ethos_weight
+
+          {
+            pathos_weight: pathos_weight / total,
+            logos_weight: logos_weight / total,
+            ethos_weight: ethos_weight / total,
+            domain: domain,
+            description: "Adjusted profile for #{domain} domain based on content analysis",
+            adjustment_rules: rules
+          }
+        end
+
+        # Detects the most appropriate domain from content
+        # @param content [String] The content to analyze
+        # @return [Symbol] The detected domain
+        def detect_domain(content)
+          lower_content = content.downcase
+          scores = []
+
+          # Check for each domain type
+          scores << { domain: :factual, score: score_domain(lower_content, DomainKeywords::FACTUAL) }
+          scores << { domain: :emotional, score: score_domain(lower_content, DomainKeywords::EMOTIONAL) }
+          scores << { domain: :sensitive, score: score_domain(lower_content, DomainKeywords::SENSITIVE) }
+          scores << { domain: :creative, score: score_domain(lower_content, DomainKeywords::CREATIVE) }
+          scores << { domain: :technical, score: score_domain(lower_content, DomainKeywords::TECHNICAL) }
+          scores << { domain: :social, score: score_domain(lower_content, DomainKeywords::SOCIAL) }
+          scores << { domain: :business, score: score_domain(lower_content, DomainKeywords::BUSINESS) }
+          scores << { domain: :personal, score: score_domain(lower_content, DomainKeywords::PERSONAL) }
+          scores << { domain: :maritime, score: score_domain(lower_content, DomainKeywords::MARITIME) }
+
+          # Find highest score
+          scores.sort! { |a, b| b[:score] <=> a[:score] }
+
+          # If no strong signal, return balanced
+          return :balanced if scores[0][:score] < 3
+
+          scores[0][:domain]
+        end
+
+        # Gets domain characteristics
+        # @param domain [Symbol] The domain to get characteristics for
+        # @return [Hash] The domain characteristics
+        def get_domain_characteristics(domain)
+          DOMAIN_CHARACTERISTICS[domain].dup
+        end
+
+        # Lists all available domains
+        # @return [Array<Symbol>] Array of available domains
+        def list_domains
+          %i[factual emotional sensitive creative balanced technical social business personal maritime]
+        end
+
+        # Creates a custom weight profile by blending multiple domains
+        # @param domains [Array<Hash>] Domains to blend with weights [{ domain: :factual, weight: 0.5 }]
+        # @return [Hash] Blended weight profile
+        def blend_domains(domains)
+          if domains.empty?
+            return get_profile(:balanced)
+          end
+
+          # Normalize input weights
+          total_input_weight = domains.sum { |d| d[:weight] }
+          normalized_domains = domains.map do |d|
+            { domain: d[:domain], weight: d[:weight] / total_input_weight }
+          end
+
+          # Blend the weights
+          pathos_weight = 0.0
+          logos_weight = 0.0
+          ethos_weight = 0.0
+          all_rules = []
+
+          normalized_domains.each do |item|
+            profile = get_profile(item[:domain])
+            pathos_weight += profile[:pathos_weight] * item[:weight]
+            logos_weight += profile[:logos_weight] * item[:weight]
+            ethos_weight += profile[:ethos_weight] * item[:weight]
+            all_rules.concat(profile[:adjustment_rules] || [])
+          end
+
+          # Normalize to sum to 1
+          total = pathos_weight + logos_weight + ethos_weight
+
+          {
+            pathos_weight: pathos_weight / total,
+            logos_weight: logos_weight / total,
+            ethos_weight: ethos_weight / total,
+            domain: :balanced,
+            description: "Blended profile from: #{domains.map { |d| d[:domain] }.join(', ')}",
+            adjustment_rules: all_rules
+          }
+        end
+
+        # Validates a weight profile
+        # @param profile [Hash] Profile to validate
+        # @return [Hash] Validation result { valid: Boolean, errors: Array<String> }
+        def validate_profile(profile)
+          errors = []
+
+          if profile[:pathos_weight]
+            if profile[:pathos_weight] < 0 || profile[:pathos_weight] > 1
+              errors << 'pathos_weight must be between 0 and 1'
+            end
+          end
+
+          if profile[:logos_weight]
+            if profile[:logos_weight] < 0 || profile[:logos_weight] > 1
+              errors << 'logos_weight must be between 0 and 1'
+            end
+          end
+
+          if profile[:ethos_weight]
+            if profile[:ethos_weight] < 0 || profile[:ethos_weight] > 1
+              errors << 'ethos_weight must be between 0 and 1'
+            end
+          end
+
+          if profile[:pathos_weight] && profile[:logos_weight] && profile[:ethos_weight]
+            sum = profile[:pathos_weight] + profile[:logos_weight] + profile[:ethos_weight]
+            if (sum - 1.0).abs > 0.001
+              errors << "Weights must sum to 1, got #{sum.round(3)}"
+            end
+          end
+
+          { valid: errors.empty?, errors: errors }
+        end
+
+        private
+
+        def build_default_profiles
+          {
+            factual: {
+              pathos_weight: 0.15,
+              logos_weight: 0.60,
+              ethos_weight: 0.25,
+              domain: :factual,
+              description: 'Scientific and data-driven decisions prioritize logic over emotion',
+              adjustment_rules: [
+                { name: 'data_present', condition: 'Content contains statistical data or research findings', perspective: :logos, adjustment: 0.1, priority: 10 },
+                { name: 'human_subjects', condition: 'Research involves human subjects', perspective: :ethos, adjustment: 0.1, priority: 8 }
+              ]
+            },
+            emotional: {
+              pathos_weight: 0.50,
+              logos_weight: 0.20,
+              ethos_weight: 0.30,
+              domain: :emotional,
+              description: 'Human-centered decisions value emotional resonance highly',
+              adjustment_rules: [
+                { name: 'personal_story', condition: 'Content includes personal narratives or testimonials', perspective: :pathos, adjustment: 0.15, priority: 10 },
+                { name: 'group_dynamics', condition: 'Decision affects group relationships', perspective: :pathos, adjustment: 0.1, priority: 8 }
+              ]
+            },
+            sensitive: {
+              pathos_weight: 0.30,
+              logos_weight: 0.25,
+              ethos_weight: 0.45,
+              domain: :sensitive,
+              description: 'Ethically complex decisions prioritize moral considerations',
+              adjustment_rules: [
+                { name: 'vulnerable_populations', condition: 'Decision affects vulnerable populations', perspective: :ethos, adjustment: 0.15, priority: 10 },
+                { name: 'rights_implications', condition: 'Decision has rights implications', perspective: :ethos, adjustment: 0.1, priority: 9 }
+              ]
+            },
+            creative: {
+              pathos_weight: 0.40,
+              logos_weight: 0.30,
+              ethos_weight: 0.30,
+              domain: :creative,
+              description: 'Creative decisions balance all perspectives with slight emotional edge',
+              adjustment_rules: [
+                { name: 'innovation_focus', condition: 'Decision involves innovation or new approaches', perspective: :logos, adjustment: 0.05, priority: 7 },
+                { name: 'artistic_expression', condition: 'Decision involves artistic or creative expression', perspective: :pathos, adjustment: 0.1, priority: 8 }
+              ]
+            },
+            balanced: {
+              pathos_weight: 0.333,
+              logos_weight: 0.334,
+              ethos_weight: 0.333,
+              domain: :balanced,
+              description: 'Equal weighting for general-purpose deliberations',
+              adjustment_rules: []
+            },
+            technical: {
+              pathos_weight: 0.10,
+              logos_weight: 0.70,
+              ethos_weight: 0.20,
+              domain: :technical,
+              description: 'Engineering decisions strongly prioritize logical reasoning',
+              adjustment_rules: [
+                { name: 'safety_critical', condition: 'Decision involves safety-critical systems', perspective: :logos, adjustment: 0.05, priority: 10 },
+                { name: 'user_impact', condition: 'Technical change affects end users', perspective: :pathos, adjustment: 0.1, priority: 7 }
+              ]
+            },
+            social: {
+              pathos_weight: 0.40,
+              logos_weight: 0.25,
+              ethos_weight: 0.35,
+              domain: :social,
+              description: 'Community decisions value emotional and ethical dimensions',
+              adjustment_rules: [
+                { name: 'community_impact', condition: 'Decision affects community cohesion', perspective: :ethos, adjustment: 0.1, priority: 9 },
+                { name: 'public_opinion', condition: 'Decision will be subject to public scrutiny', perspective: :pathos, adjustment: 0.05, priority: 8 }
+              ]
+            },
+            business: {
+              pathos_weight: 0.25,
+              logos_weight: 0.45,
+              ethos_weight: 0.30,
+              domain: :business,
+              description: 'Business decisions balance logic with stakeholder impact',
+              adjustment_rules: [
+                { name: 'profit_pressure', condition: 'Financial metrics are primary consideration', perspective: :logos, adjustment: 0.1, priority: 8 },
+                { name: 'reputation_risk', condition: 'Decision affects company reputation', perspective: :ethos, adjustment: 0.1, priority: 9 }
+              ]
+            },
+            maritime: {
+              pathos_weight: 0.20,
+              logos_weight: 0.55,
+              ethos_weight: 0.25,
+              domain: :maritime,
+              description: 'Maritime operations prioritize safety, logistics, and crew welfare',
+              adjustment_rules: [
+                { name: 'safety_critical', condition: 'Decision involves crew safety or vessel integrity', perspective: :ethos, adjustment: 0.15, priority: 10 },
+                { name: 'weather_hazard', condition: 'Weather or sea conditions are a factor', perspective: :logos, adjustment: 0.1, priority: 9 },
+                { name: 'crew_welfare', condition: 'Decision affects crew rest, health, or morale', perspective: :pathos, adjustment: 0.1, priority: 8 },
+                { name: 'regulatory_compliance', condition: 'Decision involves catch limits, seasons, or regulations', perspective: :ethos, adjustment: 0.1, priority: 9 }
+              ]
+            },
+            personal: {
+              pathos_weight: 0.45,
+              logos_weight: 0.30,
+              ethos_weight: 0.25,
+              domain: :personal,
+              description: 'Personal decisions emphasize individual emotional needs',
+              adjustment_rules: [
+                { name: 'life_changing', condition: 'Decision has significant life impact', perspective: :pathos, adjustment: 0.1, priority: 10 },
+                { name: 'relationships', condition: 'Decision affects personal relationships', perspective: :ethos, adjustment: 0.1, priority: 9 }
+              ]
+            }
+          }
+        end
+
+        # Scores content against keyword weights
+        def score_domain(content, keywords)
+          score = 0.0
+          keywords.each do |keyword, weight|
+            score += weight if content.include?(keyword)
+          end
+          score
+        end
+
+        # Checks if content matches a condition
+        def matches_condition(content, condition)
+          lower_content = content.downcase
+          lower_condition = condition.downcase
+
+          # Simple keyword matching
+          keywords = lower_condition.scan(/\b[a-z]+\b/)
+          matching_keywords = keywords.select { |kw| lower_content.include?(kw) }
+
+          matching_keywords.length >= (keywords.length * 0.3).ceil
+        end
+      end
+    end
+  end
+end

data/lib/equipment/consensus_engine.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'equipment/consensus_engine/version'
+
+require_relative 'equipment/consensus_engine/types'
+require_relative 'equipment/consensus_engine/weight_calculator'
+require_relative 'equipment/consensus_engine/tripartite_deliberation'
+require_relative 'equipment/consensus_engine/conflict_resolution'
+require_relative 'equipment/consensus_engine/consensus_engine'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # Main entry point for the ConsensusEngine gem
+    end
+  end
+end