legion-gaia 0.9.62 → 0.9.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71bb865569a9d7730467a7ef628b7d4518a138356a7643e193a48ab3007373a1
-  data.tar.gz: 9dc329a3c2a1965d89e24709eed516d50f4bc17dca0d721ed91152c6b9c7c799
+  metadata.gz: d865d2e228e487153ee4681a3d0a939c83090e236f58e99cff670b351d5cc07e
+  data.tar.gz: 84252e97bc38980791c4ac74aaedf1fcc7bc00d6de30c8da7d4fce98d37a89a1
 SHA512:
-  metadata.gz: d583fa1b87e559a140610e7c8dbef90f6f357833265c21f94ec87ac5bce166f3666250f371d498ce8752453a5e9e0cc33948e5e69f3945beb5e166153c1f7c8e
-  data.tar.gz: 4200917911b720000f7c029220180817546ba824a12af7ff1d970c0920aa82a56028a6f783ca312ead58ec37ee283d9a362b0f87e164fb97a8351e974bff6e90
+  metadata.gz: 4b307e1dfcf3cfba5e3e0378209c4d562578de7085753f216ed6a3d45e969b3d0e92724f6e428d6635dad31d7d19bdbf5f451b7f0e21406492dca09b97a0f1e0
+  data.tar.gz: 987ad87a47603e4c65cefaad42b26f8817b65154c070040c84936694e7763e62492664c7bb87305d5d03b6e6e6ce4e7d9ab941290f0f41f251011251968811c1

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.9.63] - 2026-07-22
+### Added
+- H8: `DeathProtocol.terminate_bond(identity:, confirm:)` — single entry point for bond termination; walks cascade across all stores (bond, behavioral_synapses, session, audit, attribution, calibration, preferences, memory_traces, predictions, trust); returns proof-of-destruction receipt with per-store results; emits `gaia.bond.terminated` event
+- H8: `BondRegistry.set_bond_state` / `bond_state` / `terminating?` / `terminated?` — explicit lifecycle state management for partner bonds
+- H8 ingress barrier: `ingest`, `observe_interlocutor`, and `record_response_applied` all reject writes for terminating/terminated identities with a log warning and early return
+- H8 irreversibility: `observe_interlocutor` blocks re-registration of terminated identities — a new bond requires explicit `begin_new_imprint` (out of scope)
+- DELETE `/api/gaia/bond/:identity` route — terminates a bond and returns the receipt
+- Soft-guarded erasure helpers for optional stores (calibration, preferences, memory traces, predictions, trust) — skips gracefully when extension not loaded, raises on actual store errors
+
 ## [0.9.62] - 2026-07-22
 ### Added
 - H8 prep: `BondRegistry.erase_partner!(identity:)` — thread-safe deletion of a single bond entry; marks registry dirty; emits `gaia.bond.erased` event if `Legion::Events` is defined; idempotent (no raise on missing identity)

data/lib/legion/gaia/bond_registry.rb

@@ -11,9 +11,10 @@ module Legion
 
       TO_APOLLO_TAGS = %w[self-knowledge bond].freeze
 
-      @bonds   = Concurrent::Hash.new
-      @dirty   = false
-      @mutex   = Mutex.new
+      @bonds        = Concurrent::Hash.new
+      @bond_states  = Concurrent::Hash.new
+      @dirty        = false
+      @mutex        = Mutex.new
 
       module_function
 
@@ -262,9 +263,26 @@ module Legion
         { erased: !erased.nil?, identity: identity }
       end
 
+      def set_bond_state(identity, state)
+        @bond_states[identity.to_s] = state.to_sym
+      end
+
+      def bond_state(identity)
+        @bond_states[identity.to_s]
+      end
+
+      def terminating?(identity)
+        @bond_states[identity.to_s] == :terminating
+      end
+
+      def terminated?(identity)
+        @bond_states[identity.to_s] == :terminated
+      end
+
       def reset!
         @mutex.synchronize do
           @bonds = Concurrent::Hash.new
+          @bond_states = Concurrent::Hash.new
           @dirty = false
         end
         log.debug('BondRegistry reset')

data/lib/legion/gaia/death_protocol.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module Gaia
+    module DeathProtocol
+      extend Legion::Logging::Helper
+
+      module_function
+
+      # The single entry point for bond termination.
+      # confirm: must be true (explicit consent gate).
+      # Returns: { terminated: true, identity:, receipt: { store => result } }
+      def terminate_bond(identity:, confirm:)
+        raise ArgumentError, 'confirm: must be true to terminate' unless confirm == true
+
+        identity_str = identity.to_s
+
+        # 1. Set bond state to :terminating (blocks new writes)
+        Legion::Gaia::BondRegistry.set_bond_state(identity_str, :terminating)
+
+        # 2. Walk every store's erase_partner!
+        receipt = build_erasure_receipt(identity_str)
+
+        # 3. Set bond state to :terminated
+        Legion::Gaia::BondRegistry.set_bond_state(identity_str, :terminated)
+
+        # 4. Emit event
+        if defined?(Legion::Events) && Legion::Events.respond_to?(:emit)
+          Legion::Events.emit('gaia.bond.terminated', identity: identity_str, receipt: receipt)
+        end
+
+        # 5. Log receipt
+        log.info("[gaia] bond terminated identity=#{identity_str} stores=#{receipt.keys.size}")
+
+        { terminated: true, identity: identity_str, receipt: receipt }
+      end
+
+      private
+
+      def build_erasure_receipt(identity_str)
+        {
+          bond: erase_store(:bond) { Legion::Gaia::BondRegistry.erase_partner!(identity: identity_str) },
+          behavioral_synapses: erase_store(:behavioral_synapses) do
+            Legion::Gaia::BehavioralSynapse.erase_partner!(identity: identity_str)
+          end,
+          session: erase_store(:session) do
+            Legion::Gaia.session_store&.erase_partner!(identity: identity_str)
+          end,
+          audit: erase_store(:audit) do
+            Legion::Gaia::AuditObserver.instance.erase_partner!(identity: identity_str)
+          end,
+          attribution: erase_store(:attribution) { Legion::Gaia.erase_attribution!(identity: identity_str) },
+          calibration: erase_calibration(identity_str),
+          preferences: erase_preferences(identity_str),
+          memory_traces: erase_memory_traces(identity_str),
+          predictions: erase_predictions(identity_str),
+          trust: erase_trust(identity_str)
+        }
+      end
+
+      def erase_store(name)
+        result = yield
+        result.is_a?(Hash) ? result : { erased: true }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=#{name} error=#{e.message}")
+        raise
+      end
+
+      def erase_calibration(identity_str)
+        unless defined?(Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration)
+          return { skipped: true, reason: :calibration_unavailable }
+        end
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration)
+        return { skipped: true, reason: :no_erase_method } unless runner.respond_to?(:erase_partner!)
+
+        erase_store(:calibration) { runner.erase_partner!(identity: identity_str) }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=calibration error=#{e.message}")
+        raise
+      end
+
+      def erase_preferences(identity_str)
+        unless defined?(Legion::Extensions::Mesh::Helpers::PreferenceProfile)
+          return { skipped: true, reason: :preferences_unavailable }
+        end
+
+        klass = Legion::Extensions::Mesh::Helpers::PreferenceProfile
+        return { skipped: true, reason: :no_erase_method } unless klass.respond_to?(:erase_partner!)
+
+        erase_store(:preferences) { klass.erase_partner!(identity: identity_str) }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=preferences error=#{e.message}")
+        raise
+      end
+
+      def erase_memory_traces(identity_str)
+        unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          return { skipped: true, reason: :memory_trace_unavailable }
+        end
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+        return { skipped: true, reason: :no_erase_method } unless runner.respond_to?(:erase_partner!)
+
+        erase_store(:memory_traces) { runner.erase_partner!(identity: identity_str) }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=memory_traces error=#{e.message}")
+        raise
+      end
+
+      def erase_predictions(identity_str)
+        unless defined?(Legion::Extensions::Agentic::Prediction::Helpers::Store)
+          return { skipped: true, reason: :predictions_unavailable }
+        end
+
+        store = Legion::Extensions::Agentic::Prediction::Helpers::Store
+        return { skipped: true, reason: :no_erase_method } unless store.respond_to?(:erase_partner!)
+
+        erase_store(:predictions) { store.erase_partner!(identity: identity_str) }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=predictions error=#{e.message}")
+        raise
+      end
+
+      def erase_trust(identity_str)
+        unless defined?(Legion::Extensions::Agentic::Social::Trust::Helpers::TrustStore)
+          return { skipped: true, reason: :trust_unavailable }
+        end
+
+        store = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustStore
+        return { skipped: true, reason: :no_erase_method } unless store.respond_to?(:erase_partner!)
+
+        erase_store(:trust) { store.erase_partner!(identity: identity_str) }
+      rescue StandardError => e
+        log.error("[gaia] death_protocol store=trust error=#{e.message}")
+        raise
+      end
+
+      module_function :build_erasure_receipt, :erase_store, :erase_calibration, :erase_preferences,
+                      :erase_memory_traces, :erase_predictions, :erase_trust
+    end
+  end
+end

data/lib/legion/gaia/routes.rb

@@ -10,7 +10,7 @@
 module Legion
   module Gaia
     module Routes
-      def self.registered(app)
+      def self.registered(app) # rubocop:disable Metrics/AbcSize
         app.helpers do # rubocop:disable Metrics/BlockLength
           unless method_defined?(:gaia_available?)
             define_method(:gaia_available?) do
@@ -62,6 +62,7 @@ module Legion
         register_sessions_route(app)
         register_teams_webhook_route(app)
         register_ingest_route(app)
+        register_bond_terminate_route(app)
       end
 
       def self.register_status_route(app)
@@ -193,10 +194,20 @@ module Legion
         end
       end
 
+      def self.register_bond_terminate_route(app)
+        app.delete '/api/gaia/bond/:identity' do
+          identity = params[:identity]
+          halt 400, json_error('missing_identity', 'identity is required') if identity.to_s.empty?
+
+          result = Legion::Gaia::DeathProtocol.terminate_bond(identity: identity, confirm: true)
+          json_response(result)
+        end
+      end
+
       class << self
         private :register_status_route, :register_ticks_route, :register_channels_route,
                 :register_buffer_route, :register_sessions_route, :register_teams_webhook_route,
-                :register_ingest_route
+                :register_ingest_route, :register_bond_terminate_route
       end
     end
   end

data/lib/legion/gaia/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Gaia
-    VERSION = '0.9.62'
+    VERSION = '0.9.63'
   end
 end

data/lib/legion/gaia.rb

@@ -32,6 +32,7 @@ require 'legion/gaia/proactive'
 require 'legion/gaia/offline_handler'
 require 'legion/gaia/proactive_dispatcher'
 require 'legion/gaia/bond_registry'
+require 'legion/gaia/death_protocol'
 require 'legion/gaia/behavioral_synapse'
 require 'legion/gaia/partner_model'
 require 'legion/gaia/tracker_persistence'
@@ -206,10 +207,15 @@ module Legion
       def ingest(input_frame)
         return { ingested: false, reason: :not_started } unless started?
 
+        identity = extract_identity(input_frame)
+        if identity && (BondRegistry.terminating?(identity.to_s) || BondRegistry.terminated?(identity.to_s))
+          log.warn("[gaia] rejected ingest for terminated/terminating identity=#{identity}")
+          return { ingested: false, reason: :identity_terminated }
+        end
+
         signal = input_frame.to_signal
         @sensory_buffer.push(signal)
 
-        identity = extract_identity(input_frame)
         session = @session_store&.find_or_create(identity: identity || :anonymous)
         @session_store&.touch(session.id, channel_id: input_frame.channel_id) if session
 
@@ -290,6 +296,12 @@ module Legion
       def record_response_applied(advisory_id:, identity:, applied:)
         return unless started?
 
+        identity_str = identity.to_s
+        if BondRegistry.terminating?(identity_str) || BondRegistry.terminated?(identity_str)
+          log.warn("[gaia] rejected write for terminated/terminating identity=#{identity_str}")
+          return { recorded: false, reason: :identity_terminated }
+        end
+
         synapse_count = Array(applied[:behavioral_synapse_ids]).size
         log.info("[gaia] attribution advisory_id=#{advisory_id} identity=#{identity} synapses=#{synapse_count}")
 
@@ -563,8 +575,17 @@ module Legion
         ctx[:channel_identity] || ctx[:user_id] || ctx[:identity]
       end
 
+      def identity_lifecycle_blocked?(identity_str)
+        return false unless BondRegistry.terminating?(identity_str) || BondRegistry.terminated?(identity_str)
+
+        log.warn("[gaia] rejected write for terminated/terminating identity=#{identity_str}")
+        true
+      end
+
       def observe_interlocutor(input_frame, identity)
         identity_str = identity.to_s
+        return if identity_lifecycle_blocked?(identity_str)
+
         auth_ctx = input_frame.auth_context || {}
 
         # Ensure the identity is registered so reinforce has a target

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.62
+  version: 0.9.63
 platform: ruby
 authors:
 - Esity
@@ -432,6 +432,7 @@ files:
 - lib/legion/gaia/channels/teams/webhook_handler.rb
 - lib/legion/gaia/channels/teams_adapter.rb
 - lib/legion/gaia/cognitive_bus.rb
+- lib/legion/gaia/death_protocol.rb
 - lib/legion/gaia/input_frame.rb
 - lib/legion/gaia/intent_classifier.rb
 - lib/legion/gaia/logging.rb