legion-gaia 0.9.66 → 0.9.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0229532bc53d2868fac7cc6279bb2875ceaaedbb63269dc8b5a742a7c95832
-  data.tar.gz: da7e11d18691d6af5e90e2c4da209feaf1b6ab79b4aaa91f4c409e517d7428cf
+  metadata.gz: a478fc13f85356c56fd876e2a2fb8b875bdcb5d1f4ad74ffb109af0c29281d96
+  data.tar.gz: 5e8fd3ac446ff77d56774c53d26a1ff49f1e7fedb58614091fa79bb297fc32b5
 SHA512:
-  metadata.gz: c87775e2f41b815da9b996ceca3383dbf956ec8c8e643c26ec8390fb7477fc0ead9739b4802cbdc5984ebf1266f1d5dd22d145c7b657cc8e7712035f0496932c
-  data.tar.gz: e03a41455d7d36dbb49d89e2b7c74e3db930c07a1a730cb4c695a088c446be020463ff0ea588bdea1ce01b06504890890afa08c42344fbd16e71b6818058727b
+  metadata.gz: c643cd9e9b6c68990543afb913dae64e4768c9e2d869d34ab5d9ac46a00e02f1d9c2562011d10ca6708ca5e047bfbda9fb5b26efd691f2f95e3aff44b22dd49e
+  data.tar.gz: aaff63a4112a475a5ada9c77907bafaa1f732e0a113f8720a2115b8be153a31f70c8b00704dcc52ff0d293cbabee88ed727b00d014cd306a9f1ccc43764c61b6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.9.67] - 2026-07-24
+### Added
+- H5: `Legion::Gaia::Gut.check(identity:, draft_stats:)` — fast per-response conflict detection (v1: correction veto only). Compares draft stats against high-strength correction traces and transform-tier behavioral synapses. No LLM calls. Completes within 50ms latency budget (scalar setting); degrades to no-op if exceeded. Soft-guarded on lex-agentic-memory. The gut itself is a behavioral synapse (`domain: 'gut'`); new partners start in observe mode (emergent confidence 0.3 → observe tier).
+- H6: `Legion::Gaia::Anticipation.build(identity:, context:)` — builds anticipation context from actionable pending predictions (confidence >= threshold). Pre-stages RAG entries capped at 25% of total. Soft-guarded on lex-agentic-inference.
+- H6: `Legion::Gaia::Anticipation.resolve(identity:, prediction_id:, actual:)` — grades a pending prediction as `:correct`, `:incorrect`, or `:partial` against the partner's actual input. Entropy guard: no resolution under high identity entropy.
+- H6: `Legion::Gaia::Anticipation.deferred?(identity:, anticipation:)` — §12.8 emotional modulation: negative-valence anticipations defer when partner affect baseline is low. Soft-guarded on lex-agentic-affect.
+- Settings defaults: `gut.latency_budget_ms` (50ms), `gut.correction_min_strength` (0.6), `gut.correction_trace_limit` (20), `anticipation.actionable_threshold` (0.65)
+
 ## [0.9.66] - 2026-07-24
 ### Added
 - `Gaia.observe_from_pipeline(identity:, caller:, exchange_id:)` — pipeline observation for API clients; reinforces bond, triggers coldstart, registers duckling partner on first human request

data/lib/legion/gaia/anticipation.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/logging/helper'
+
+module Legion
+  module Gaia
+    # H6 — prediction pre-staging with emotional modulation (§12.8).
+    #
+    # Reads pending predictions from lex-agentic-inference (if available).
+    # Actionable predictions (confidence >= threshold) trigger pre-staged RAG retrieval,
+    # capped at 25% of total entries.
+    #
+    # Emotional modulation: negative-valence anticipations defer when the partner's affect
+    # baseline is low (soft-guarded on lex-agentic-affect).
+    #
+    # Entropy guard: no resolution under high identity entropy (consistent with H2).
+    # Soft-guarded throughout: returns nil when dependencies are absent.
+    module Anticipation
+      extend Legion::Logging::Helper
+
+      # Threshold below which the partner's affect baseline is considered "low".
+      LOW_AFFECT_BASELINE = 0.3
+
+      # Cap on pre-staged entries as a fraction of total RAG entries.
+      PRESTAGE_CAP_RATIO = 0.25
+
+      module_function
+
+      # Build anticipation context for advisory.
+      #
+      # @param identity [String] partner identity
+      # @param context [Hash] current request context, e.g. { rag_entry_count:, entropy: }
+      # @return [Hash, nil]
+      #   { prediction_id:, content:, confidence:, pre_staged: [...] }
+      #   nil when lex-agentic-inference not loaded or no actionable predictions
+      def build(identity:, context:)
+        return nil unless inference_available?
+
+        runner = inference_runner
+        result = runner.pending_predictions(identity: identity.to_s)
+        predictions = Array(result[:predictions])
+        return nil if predictions.empty?
+
+        actionable = predictions.select { |p| p[:confidence].to_f >= actionable_threshold }
+        return nil if actionable.empty?
+
+        # Pick the highest-confidence actionable prediction
+        best = actionable.max_by { |p| p[:confidence].to_f }
+
+        # Emotional modulation: defer negative-valence anticipation when affect baseline is low
+        if deferred?(identity: identity, anticipation: best)
+          log.info("[anticipation] deferred identity=#{identity} prediction_id=#{best[:prediction_id].to_s[0, 8]} " \
+                   'reason=emotional_state')
+          return nil
+        end
+
+        pre_staged = build_prestaged(context: context, prediction: best)
+
+        log.info("[anticipation] built identity=#{identity} prediction_id=#{best[:prediction_id].to_s[0, 8]} " \
+                 "confidence=#{best[:confidence].to_f.round(3)} pre_staged=#{pre_staged.size}")
+
+        {
+          prediction_id: best[:prediction_id],
+          content: best[:description] || best[:context].to_s,
+          confidence: best[:confidence].to_f,
+          pre_staged: pre_staged
+        }
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.anticipation.build', identity: identity)
+        nil
+      end
+
+      # Resolve a pending anticipation against the partner's actual next input.
+      #
+      # Grades the prediction as :correct, :incorrect, or :partial and records the outcome.
+      # Skipped under high identity entropy.
+      #
+      # @param identity [String] partner identity
+      # @param prediction_id [String] UUID of the prediction to resolve
+      # @param actual [String] the partner's actual input
+      # @return [Hash, nil]
+      #   { resolved: true/false, outcome:, prediction_id: }
+      #   nil when dependencies unavailable
+      def resolve(identity:, prediction_id:, actual:)
+        return nil unless inference_available?
+
+        identity_str = identity.to_s
+
+        if high_entropy?(identity: identity_str)
+          log.info("[anticipation] resolve skipped identity=#{identity_str} reason=high_entropy")
+          return { resolved: false, reason: :high_entropy, prediction_id: prediction_id }
+        end
+
+        outcome = grade_prediction(prediction_id: prediction_id, actual: actual, identity: identity_str)
+        runner = inference_runner
+        result = runner.resolve_prediction(prediction_id: prediction_id, outcome: outcome,
+                                           actual: actual, identity: identity_str)
+
+        log.info("[anticipation] resolved identity=#{identity_str} prediction_id=#{prediction_id.to_s[0, 8]} " \
+                 "outcome=#{outcome}")
+
+        result
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.anticipation.resolve',
+                            identity: identity, prediction_id: prediction_id)
+        nil
+      end
+
+      # Check if an anticipation should be deferred due to emotional state.
+      #
+      # Deferred when the anticipation has negative emotional context AND the partner's
+      # current affect baseline is low (§12.8 emotional modulation).
+      #
+      # @param identity [String] partner identity
+      # @param anticipation [Hash] prediction entry with optional :emotional_context
+      # @return [Boolean]
+      def deferred?(identity:, anticipation:)
+        return false unless anticipation.is_a?(Hash)
+
+        anticipation_valence = extract_valence(anticipation)
+        return false unless anticipation_valence < 0.0
+
+        affect_baseline_low?(identity: identity.to_s)
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.anticipation.deferred', identity: identity)
+        false
+      end
+
+      def inference_available?
+        defined?(Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction) == 'constant'
+      end
+
+      def inference_runner
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction)
+        runner
+      end
+
+      def actionable_threshold
+        settings = Legion::Gaia.settings
+        settings&.dig(:anticipation, :actionable_threshold) ||
+          (defined?(Legion::Extensions::Agentic::Inference::Prediction::Helpers::Modes::PREDICTION_CONFIDENCE_MIN) &&
+           Legion::Extensions::Agentic::Inference::Prediction::Helpers::Modes::PREDICTION_CONFIDENCE_MIN) ||
+          0.65
+      end
+
+      # Builds pre-staged RAG entries capped at 25% of total context entries.
+      def build_prestaged(context:, prediction:)
+        return [] unless context.is_a?(Hash)
+
+        rag_count = context[:rag_entry_count].to_i
+        return [] if rag_count.zero?
+
+        cap = [(rag_count * PRESTAGE_CAP_RATIO).ceil, 1].max
+        prediction_context = prediction[:context]
+        return [] unless prediction_context.is_a?(Hash) && prediction_context[:pre_stage_entries].is_a?(Array)
+
+        prediction_context[:pre_stage_entries].first(cap)
+      end
+
+      # Grade a prediction as :correct, :incorrect, or :partial.
+      def grade_prediction(prediction_id:, actual:, identity:)
+        return :incorrect unless inference_available?
+
+        runner = inference_runner
+        pred_result = runner.get_prediction(prediction_id: prediction_id, identity: identity)
+        return :incorrect unless pred_result[:found]
+
+        prediction = pred_result[:prediction]
+        predicted = prediction[:description].to_s.downcase.strip
+        actual_str = actual.to_s.downcase.strip
+
+        return :incorrect if predicted.empty? || actual_str.empty?
+
+        if actual_str.include?(predicted) || predicted.include?(actual_str)
+          :correct
+        elsif partial_match?(predicted, actual_str)
+          :partial
+        else
+          :incorrect
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.anticipation.grade_prediction',
+                            prediction_id: prediction_id)
+        :incorrect
+      end
+
+      def partial_match?(predicted, actual)
+        pred_words = predicted.split(/\s+/).reject(&:empty?)
+        actual_words = actual.split(/\s+/).reject(&:empty?)
+        return false if pred_words.empty? || actual_words.empty?
+
+        overlap = pred_words & actual_words
+        ratio = overlap.size.to_f / [pred_words.size, actual_words.size].min
+        ratio >= 0.5
+      end
+
+      # Returns true when the partner's affect baseline is below LOW_AFFECT_BASELINE.
+      def affect_baseline_low?(identity:)
+        return false unless defined?(Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore)
+
+        model_store = Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore.new
+        model = model_store.get(identity)
+        return false unless model.respond_to?(:emotional_state)
+
+        negative_states = %i[stressed anxious frustrated overwhelmed sad]
+        negative_states.include?(model.emotional_state)
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.anticipation.affect_baseline_low', identity: identity)
+        false
+      end
+
+      def extract_valence(anticipation)
+        ctx = anticipation[:emotional_context]
+        if ctx.is_a?(Hash)
+          ctx[:valence].to_f
+        elsif ctx.is_a?(Numeric)
+          ctx.to_f
+        else
+          0.0
+        end
+      end
+
+      def high_entropy?(identity:)
+        return false unless defined?(Legion::Extensions::Agentic::Self::Helpers::IdentityFingerprint)
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Self::Helpers::IdentityFingerprint)
+        entropy = runner.identity_entropy(identity: identity)
+        threshold = Legion::Gaia.settings&.dig(:identity, :high_entropy_threshold) || 0.7
+        entropy.to_f >= threshold
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/legion/gaia/gut.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module Gaia
+    # H5 — fast per-response conflict detection (v1: correction veto only).
+    #
+    # Runs at the final-delivery hook (response_return). Deterministic pattern matching
+    # against high-strength correction traces and transform-tier behavioral synapses.
+    # No LLM calls. Must complete within the latency budget (default 50ms).
+    #
+    # The gut itself is a behavioral synapse (domain: 'gut') whose autonomy_mode gates
+    # what happens: observe = audit-only, filter = restraint directives, transform+ = veto.
+    # New partners always start in observe mode (emergent confidence 0.3 → observe tier).
+    module Gut
+      extend Legion::Logging::Helper
+
+      module_function
+
+      # Check for conflicts between draft response stats and known corrections/synapses.
+      #
+      # @param identity [String] partner identity
+      # @param draft_stats [Hash] stats about the draft response, e.g.
+      #   { length_tokens:, format:, domain:, content_flags: [] }
+      # @return [Hash, nil]
+      #   { conflict: true, confidence: Float, violated_trace_ids: [...], directive: Hash }
+      #   { conflict: false }
+      #   nil when gut check unavailable (no memory, no synapses, or latency exceeded)
+      def check(identity:, draft_stats:)
+        deadline = monotonic_now + (latency_budget_ms / 1000.0)
+
+        gut_synapse = Legion::Gaia::BehavioralSynapse.for(identity: identity.to_s, domain: 'gut')
+        gut_mode = gut_mode_for(gut_synapse)
+
+        return nil if gut_mode == :unavailable
+
+        violations = check_correction_traces(identity: identity.to_s, draft_stats: draft_stats,
+                                             deadline: deadline)
+
+        if violations.nil?
+          log.debug("[gut] latency budget exceeded identity=#{identity}")
+          return nil
+        end
+
+        synapse_violations = check_transform_synapses(identity: identity.to_s,
+                                                      draft_stats: draft_stats,
+                                                      deadline: deadline)
+
+        if synapse_violations.nil?
+          log.debug("[gut] latency budget exceeded (synapse phase) identity=#{identity}")
+          return nil
+        end
+
+        all_violations = violations + synapse_violations
+        return { conflict: false } if all_violations.empty?
+
+        violated_trace_ids = all_violations.flat_map { |v| v[:trace_ids] }.uniq
+        confidence         = all_violations.map { |v| v[:strength] }.max.to_f
+        directive          = all_violations.first[:directive] || {}
+
+        log.info("[gut] conflict detected identity=#{identity} " \
+                 "violations=#{all_violations.size} confidence=#{confidence.round(3)} " \
+                 "mode=#{gut_mode}")
+
+        { conflict: true, confidence: confidence, violated_trace_ids: violated_trace_ids, directive: directive }
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.gut.check', identity: identity)
+        nil
+      end
+
+      def latency_budget_ms
+        settings = Legion::Gaia.settings
+        settings&.dig(:gut, :latency_budget_ms) || 50.0
+      end
+
+      def monotonic_now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      def deadline_exceeded?(deadline)
+        monotonic_now >= deadline
+      end
+
+      # Returns the autonomy mode for the gut synapse, or :unavailable if gut should not run.
+      # New partners get :observe (observe = audit only, no veto action).
+      def gut_mode_for(gut_synapse)
+        return :observe if gut_synapse.nil?
+
+        Legion::Gaia::BehavioralSynapse::Math.autonomy_mode(gut_synapse[:confidence].to_f)
+      end
+
+      # Compare draft_stats against high-strength correction traces for the partner.
+      # Returns array of violation hashes, or nil if deadline exceeded.
+      def check_correction_traces(identity:, draft_stats:, deadline:)
+        return [] unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+
+        return nil if deadline_exceeded?(deadline)
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+
+        result = runner.retrieve_by_domain(
+          domain_tag: "partner:#{identity}",
+          min_strength: correction_min_strength,
+          limit: correction_trace_limit
+        )
+
+        return nil if deadline_exceeded?(deadline)
+
+        correction_traces = Array(result[:traces]).select { |t| correction_trace?(t) }
+        violations = []
+
+        correction_traces.each do |trace|
+          return nil if deadline_exceeded?(deadline)
+
+          next unless trace_conflicts_with_draft?(trace, draft_stats)
+
+          violations << {
+            trace_ids: [trace[:trace_id].to_s],
+            strength: trace[:strength].to_f,
+            directive: directive_from_trace(trace)
+          }
+        end
+
+        violations
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.gut.check_correction_traces', identity: identity)
+        []
+      end
+
+      # Check transform-tier behavioral synapses for conflicts with draft stats.
+      # Returns array of violation hashes, or nil if deadline exceeded.
+      def check_transform_synapses(identity:, draft_stats:, deadline:)
+        return nil if deadline_exceeded?(deadline)
+
+        synapses = Legion::Gaia::BehavioralSynapse.all_for(identity: identity)
+        transform_synapses = synapses.select do |s|
+          mode = Legion::Gaia::BehavioralSynapse::Math.autonomy_mode(s[:confidence].to_f)
+          %i[transform autonomous].include?(mode)
+        end
+
+        violations = []
+
+        transform_synapses.each do |synapse|
+          return nil if deadline_exceeded?(deadline)
+
+          next unless synapse_conflicts_with_draft?(synapse, draft_stats)
+
+          violations << {
+            trace_ids: Array(synapse[:evidence_trace_ids]),
+            strength: synapse[:confidence].to_f,
+            directive: synapse[:directive].is_a?(Hash) ? synapse[:directive] : {}
+          }
+        end
+
+        violations
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.gut.check_transform_synapses', identity: identity)
+        []
+      end
+
+      def correction_trace?(trace)
+        return false unless trace.is_a?(Hash)
+
+        trace[:trace_type].to_s == 'correction' ||
+          Array(trace[:domain_tags]).any? { |tag| tag.to_s == 'correction' }
+      end
+
+      # Checks if a correction trace conflicts with the draft stats.
+      # Conflict = the draft exhibits a pattern that the correction explicitly negated.
+      def trace_conflicts_with_draft?(trace, draft_stats)
+        payload = trace[:content_payload]
+        return false unless payload.is_a?(Hash)
+
+        stats = draft_stats.is_a?(Hash) ? draft_stats : {}
+        trace_verbosity_conflict?(payload, stats) ||
+          trace_format_conflict?(payload, stats) ||
+          trace_content_flag_conflict?(payload, stats) ||
+          trace_domain_conflict?(payload, stats)
+      end
+
+      def trace_verbosity_conflict?(payload, stats)
+        type = payload[:correction_type].to_s
+        return false unless type.include?('verbosity') || type.include?('length')
+
+        budget = payload[:budget_tokens] || payload[:max_tokens]
+        budget && stats[:length_tokens].to_i > budget.to_i
+      end
+
+      def trace_format_conflict?(payload, stats)
+        return false unless payload[:rejected_format]
+
+        stats[:format].to_s == payload[:rejected_format].to_s
+      end
+
+      def trace_content_flag_conflict?(payload, stats)
+        return false unless payload[:rejected_content_flags].is_a?(Array)
+
+        draft_flags = Array(stats[:content_flags]).map(&:to_s)
+        rejected    = payload[:rejected_content_flags].map(&:to_s)
+        draft_flags.intersect?(rejected)
+      end
+
+      def trace_domain_conflict?(payload, stats)
+        return false unless payload[:correction_type].to_s == 'explicit_negative_feedback'
+
+        applied_domains = Array(stats[:applied_domains]).map(&:to_s)
+        blocked_domains = Array(payload[:blocked_domains]).map(&:to_s)
+        blocked_domains.any? && applied_domains.intersect?(blocked_domains)
+      end
+
+      # Checks if a transform-tier synapse's directive conflicts with draft stats.
+      def synapse_conflicts_with_draft?(synapse, draft_stats)
+        directive = synapse[:directive]
+        return false unless directive.is_a?(Hash)
+
+        stats = draft_stats.is_a?(Hash) ? draft_stats : {}
+        synapse_budget_conflict?(directive, stats) || synapse_format_conflict?(directive, stats)
+      end
+
+      def synapse_budget_conflict?(directive, stats)
+        return false unless directive[:budget_ratio]
+
+        baseline  = stats[:baseline_tokens].to_i
+        draft_len = stats[:length_tokens].to_i
+        allowed   = (baseline * directive[:budget_ratio].to_f).to_i
+        allowed.positive? && draft_len > allowed
+      end
+
+      def synapse_format_conflict?(directive, stats)
+        return false unless directive[:format] && stats[:format]
+
+        stats[:format].to_s != directive[:format].to_s
+      end
+
+      def directive_from_trace(trace)
+        payload = trace[:content_payload]
+        return {} unless payload.is_a?(Hash)
+
+        dir = {}
+        dir[:budget_tokens] = payload[:budget_tokens] if payload[:budget_tokens]
+        dir[:rejected_format] = payload[:rejected_format] if payload[:rejected_format]
+        dir[:correction_type] = payload[:correction_type] if payload[:correction_type]
+        dir
+      end
+
+      def correction_min_strength
+        settings = Legion::Gaia.settings
+        settings&.dig(:gut, :correction_min_strength) || 0.6
+      end
+
+      def correction_trace_limit
+        settings = Legion::Gaia.settings
+        settings&.dig(:gut, :correction_trace_limit) || 20
+      end
+    end
+  end
+end

data/lib/legion/gaia/settings.rb

@@ -16,7 +16,9 @@ module Legion
           session: { persistence: 'auto', ttl: 86_400 },
           output: { mobile_max_length: 500, suggest_channel_switch: true },
           notifications: default_notifications,
-          partner: default_partner
+          partner: default_partner,
+          gut: default_gut,
+          anticipation: default_anticipation
         }
       end
 
@@ -39,6 +41,20 @@ module Legion
         }
       end
 
+      def default_gut
+        {
+          latency_budget_ms: 50.0,
+          correction_min_strength: 0.6,
+          correction_trace_limit: 20
+        }
+      end
+
+      def default_anticipation
+        {
+          actionable_threshold: 0.65
+        }
+      end
+
       def default_notifications
         {
           enabled: true,

data/lib/legion/gaia/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Gaia
-    VERSION = '0.9.66'
+    VERSION = '0.9.67'
   end
 end

data/lib/legion/gaia.rb

@@ -34,6 +34,8 @@ require 'legion/gaia/proactive_dispatcher'
 require 'legion/gaia/bond_registry'
 require 'legion/gaia/death_protocol'
 require 'legion/gaia/behavioral_synapse'
+require 'legion/gaia/gut'
+require 'legion/gaia/anticipation'
 require 'legion/gaia/partner_model'
 require 'legion/gaia/disclosure'
 require 'legion/gaia/visible_growth'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.66
+  version: 0.9.67
 platform: ruby
 authors:
 - Esity
@@ -416,6 +416,7 @@ files:
 - lib/legion/gaia.rb
 - lib/legion/gaia/actors/heartbeat.rb
 - lib/legion/gaia/advisory.rb
+- lib/legion/gaia/anticipation.rb
 - lib/legion/gaia/audit_observer.rb
 - lib/legion/gaia/behavioral_synapse.rb
 - lib/legion/gaia/bond_registry.rb
@@ -434,6 +435,7 @@ files:
 - lib/legion/gaia/cognitive_bus.rb
 - lib/legion/gaia/death_protocol.rb
 - lib/legion/gaia/disclosure.rb
+- lib/legion/gaia/gut.rb
 - lib/legion/gaia/input_frame.rb
 - lib/legion/gaia/intent_classifier.rb
 - lib/legion/gaia/logging.rb