legion-gaia 0.9.59 → 0.9.60

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcc0656f2d4922688542c1a7a9af486aea087a887f7faf929aa29c75c6ed1b9d
-  data.tar.gz: 27af3cc6e41f056d98c69f7ec83fa8ea7a2e379e4d7a517913a7d71f719ab6bc
+  metadata.gz: 2fc298cf66a402057db523e07a53e4bde4a30a7b3e8090b819b8b1f64569c589
+  data.tar.gz: 6226b64c0fc7ace2122f014784b21f074fae19ebfc214360b5288cfc7d9e80d0
 SHA512:
-  metadata.gz: ea478d48bf2e25902220796b962fd89ebc6c1925453164d4da5902a10af9b08bfbfa6aa5cdc4a062a8b5be189315c739d6ad2cbad87ceb6d8624a54a501da320
-  data.tar.gz: f49728af3557e2a11266dbabd3cd8e8c56878a5bec7ccabcc25ffe115d02c05e0308df9b2fc29b9c89e2ed79000d2855c8cdd7e825eaa1d68f11ee5340e509c0
+  metadata.gz: d74b4bc1634a51f8759771f8c77711a58c92627487ca3c98e2af22c2244ab1c3efc63de5364656179d3232aa8d9ee9a0faa48f7a35d28dfa34aef21e493351bb
+  data.tar.gz: 1d4f2872dc1b9e332160f34676dc1f5950dd6a13b2d72a050c4c65b693546e8743309ba34148cdc3d18cb103127279c5dd8d055832ad2db41e182dcb0adf17d5

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.60] - 2026-07-16
+### Added
+- H2: BehavioralSynapse store with vendored Confidence math (lifecycle: crystallize, lazy decay with intensity resistance, grade via record_outcome, pain at 3 consecutive failures → dampened + event emission)
+- `record_response_applied` public method — attribution facade for legion-llm's final-delivery hook; persists to Apollo Local with self-knowledge/attribution tags
+- Grading path in `evaluate_calibration`: reaction_score >= 0.6 → :success, <= 0.4 → :failure; maps each applied synapse_id via BehavioralSynapse.record_outcome scaled by imprint multiplier
+- TrackerPersistence integration for BehavioralSynapse: Tracker wrapper, hydrate at boot alongside bonds, flush_dirty/flush_all on heartbeat/shutdown
+
 ## [0.9.59] - 2026-07-16
 ### Added
 - H0: Partner identity as first-class store dimension — `record_interaction_trace` adds `partner:<identity>` domain tag; `SessionStore#erase_partner!(identity:)`; `AuditObserver` tool patterns keyed per-identity with `tool_patterns_for(identity)` and `erase_partner!(identity:)`; `TrackerPersistence.register_tracker` is idempotent (re-registration is a no-op, safe for partial-boot resume); fail-closed: no partner state written to shared Postgres when Apollo local is unavailable

data/lib/legion/gaia/behavioral_synapse.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+require 'concurrent/hash'
+require 'securerandom'
+require 'legion/json'
+require 'legion/logging/helper'
+
+module Legion
+  module Gaia
+    module BehavioralSynapse # rubocop:disable Metrics/ModuleLength
+      extend Legion::Logging::Helper
+
+      TO_APOLLO_TAGS = %w[self-knowledge behavior].freeze
+
+      # Vendored confidence math — identical constants to Legion::Extensions::Synapse::Helpers::Confidence.
+      # At runtime we delegate to the real module if it is loaded.
+      module Math
+        STARTING_SCORES = { explicit: 0.7, emergent: 0.3, seeded: 0.5 }.freeze
+        ADJUSTMENTS     = {
+          success: 0.02,
+          failure: -0.05,
+          validation_failure: -0.03,
+          consecutive_bonus: 0.05
+        }.freeze
+        DECAY_RATE = 0.998
+        CONSECUTIVE_BONUS_THRESHOLD = 50
+        AUTONOMY_RANGES = {
+          observe: 0.0..0.3,
+          filter: 0.3..0.6,
+          transform: 0.6..0.8,
+          autonomous: 0.8..1.0
+        }.freeze
+        E_WEIGHT = 3.0
+
+        module_function
+
+        def starting_score(origin)
+          STARTING_SCORES.fetch(origin.to_sym, 0.3)
+        end
+
+        def adjust(confidence, event, consecutive_successes: 0)
+          delta = ADJUSTMENTS.fetch(event.to_sym, 0.0)
+          delta += ADJUSTMENTS[:consecutive_bonus] if consecutive_successes >= CONSECUTIVE_BONUS_THRESHOLD
+          (confidence + delta).clamp(0.0, 1.0)
+        end
+
+        def decay(confidence, hours: 1)
+          (confidence * (DECAY_RATE**hours)).clamp(0.0, 1.0)
+        end
+
+        def autonomy_mode(confidence)
+          AUTONOMY_RANGES.find { |_mode, range| range.cover?(confidence) }&.first || :observe
+        end
+      end
+
+      @store = Concurrent::Hash.new
+      @dirty = false
+      @mutex = Mutex.new
+
+      module_function
+
+      # --- Confidence math delegation ---
+
+      def starting_score(origin)
+        if defined?(Legion::Extensions::Synapse::Helpers::Confidence)
+          Legion::Extensions::Synapse::Helpers::Confidence.starting_score(origin)
+        else
+          Math.starting_score(origin)
+        end
+      end
+
+      def adjust(confidence, event, consecutive_successes: 0)
+        if defined?(Legion::Extensions::Synapse::Helpers::Confidence)
+          Legion::Extensions::Synapse::Helpers::Confidence.adjust(confidence, event,
+                                                                  consecutive_successes: consecutive_successes)
+        else
+          Math.adjust(confidence, event, consecutive_successes: consecutive_successes)
+        end
+      end
+
+      def decay_confidence(confidence, hours: 1)
+        if defined?(Legion::Extensions::Synapse::Helpers::Confidence)
+          Legion::Extensions::Synapse::Helpers::Confidence.decay(confidence, hours: hours)
+        else
+          Math.decay(confidence, hours: hours)
+        end
+      end
+
+      def e_weight
+        if defined?(Legion::Extensions::Synapse::Helpers::Confidence)
+          Legion::Extensions::Synapse::Helpers::Confidence::E_WEIGHT
+        else
+          Math::E_WEIGHT
+        end
+      end
+
+      # --- Public API ---
+
+      def for(identity:, domain:)
+        key = store_key(identity, domain)
+        entry = @store[key]
+        return nil unless entry
+
+        apply_lazy_decay(entry)
+      end
+
+      def crystallize(identity:, domain:, directive:, evidence_trace_ids: [], origin: 'emergent')
+        key = store_key(identity, domain)
+        @mutex.synchronize do
+          return @store[key] if @store[key]
+
+          conf   = starting_score(origin.to_sym)
+          now    = Time.now.utc
+          entry  = {
+            id: SecureRandom.uuid,
+            identity: identity.to_s,
+            domain: domain.to_s,
+            origin: origin.to_s,
+            confidence: conf,
+            emotional_valence: 0.0,
+            emotional_intensity: 0.0,
+            consecutive_failures: 0,
+            consecutive_successes: 0,
+            directive: directive,
+            evidence_trace_ids: Array(evidence_trace_ids),
+            status: 'active',
+            last_applied_at: nil,
+            last_reinforced_at: now,
+            created_at: now
+          }
+          @store[key] = entry
+          @dirty = true
+          log.info("[gaia] synapse crystallized identity=#{identity} domain=#{domain} origin=#{origin} conf=#{conf}")
+          entry
+        end
+      end
+
+      def record_outcome(id:, outcome:, multiplier: 1.0)
+        @mutex.synchronize do
+          entry = find_by_id(id)
+          return { found: false } unless entry
+
+          conf = entry[:confidence]
+          base_event = outcome.to_sym
+          new_conf = adjust(conf, base_event, consecutive_successes: entry[:consecutive_successes])
+
+          # Apply multiplier to delta (scale the delta, not the raw confidence)
+          raw_delta = new_conf - conf
+          scaled_conf = (conf + (raw_delta * multiplier)).clamp(0.0, 1.0)
+
+          if base_event == :success
+            entry[:consecutive_successes] = entry[:consecutive_successes].to_i + 1
+            entry[:consecutive_failures]  = 0
+          elsif base_event == :failure
+            entry[:consecutive_failures]  = entry[:consecutive_failures].to_i + 1
+            entry[:consecutive_successes] = 0
+          end
+
+          entry[:confidence]          = scaled_conf
+          entry[:last_reinforced_at]  = Time.now.utc
+          @dirty = true
+
+          apply_pain(entry) if entry[:consecutive_failures].to_i >= 3
+
+          entry
+        end
+      end
+
+      def all_for(identity:)
+        prefix = "#{identity}:"
+        @store.select { |key, _| key.start_with?(prefix) }.values
+      end
+
+      def erase_partner!(identity:)
+        prefix = "#{identity}:"
+        keys = @store.keys.select { |key| key.start_with?(prefix) }
+        keys.each { |key| @store.delete(key) }
+        @mutex.synchronize { @dirty = true } unless keys.empty?
+        log.info("[gaia] BehavioralSynapse erased identity=#{identity} count=#{keys.size}")
+        keys.size
+      end
+
+      def store
+        @store
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @store = Concurrent::Hash.new
+          @dirty = false
+        end
+      end
+
+      # --- TrackerPersistence support ---
+
+      def dirty?
+        @dirty == true
+      end
+
+      def mark_clean!
+        @dirty = false
+      end
+
+      def to_apollo_entries
+        @store.values.map do |entry|
+          identity = entry[:identity]
+          {
+            content: Legion::JSON.dump(entry),
+            tags: TO_APOLLO_TAGS + ["partner:#{identity}"],
+            confidence: entry[:confidence] || 0.3,
+            access_scope: 'local'
+          }
+        end
+      end
+
+      def from_apollo(store: nil)
+        return unless store
+
+        result = store.query(text: 'behavior', tags: TO_APOLLO_TAGS)
+        return unless result.is_a?(Hash) && result[:success]
+
+        count = 0
+        result[:results]&.each do |entry|
+          hydrate_apollo_entry(entry)
+          count += 1
+        rescue StandardError => e
+          log.debug("[gaia] BehavioralSynapse skipped unparseable Apollo entry: #{e.message}")
+        end
+        log.info("[gaia] BehavioralSynapse hydrated from Apollo count=#{count}")
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.behavioral_synapse.from_apollo')
+      end
+
+      private
+
+      def store_key(identity, domain)
+        "#{identity}:#{domain}"
+      end
+
+      def find_by_id(id)
+        @store.values.find { |entry| entry[:id] == id }
+      end
+
+      def apply_lazy_decay(entry)
+        return entry unless entry[:last_reinforced_at]
+
+        hours = (Time.now.utc - entry[:last_reinforced_at]) / 3600.0
+        intensity = entry[:emotional_intensity].to_f
+        effective_hours = hours / (1 + (intensity * e_weight))
+        return entry if effective_hours < 0.001
+
+        new_conf = decay_confidence(entry[:confidence], hours: effective_hours)
+        @mutex.synchronize do
+          entry[:confidence]         = new_conf
+          entry[:last_reinforced_at] = Time.now.utc
+          @dirty = true
+        end
+        entry
+      end
+
+      def apply_pain(entry)
+        entry[:status]                = 'dampened'
+        entry[:confidence]            = 0.29
+        entry[:consecutive_failures]  = 0
+        entry[:consecutive_successes] = 0
+        log.warn("[gaia] synapse pain id=#{entry[:id]} domain=#{entry[:domain]} identity=#{entry[:identity]}")
+
+        if defined?(Legion::Events) && Legion::Events.respond_to?(:emit)
+          Legion::Events.emit('gaia.behavior.reverted',
+                              id: entry[:id], identity: entry[:identity], domain: entry[:domain])
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.behavioral_synapse.apply_pain', id: entry[:id])
+      end
+
+      def hydrate_apollo_entry(raw_entry)
+        return unless raw_entry[:content].to_s.start_with?('{')
+
+        parsed = Legion::JSON.load(raw_entry[:content])
+        return unless parsed[:id] && parsed[:identity] && parsed[:domain]
+
+        key = store_key(parsed[:identity], parsed[:domain])
+        @mutex.synchronize do
+          @store[key] = {
+            id: parsed[:id],
+            identity: parsed[:identity].to_s,
+            domain: parsed[:domain].to_s,
+            origin: parsed[:origin].to_s,
+            confidence: parsed[:confidence].to_f,
+            emotional_valence: parsed[:emotional_valence].to_f,
+            emotional_intensity: parsed[:emotional_intensity].to_f,
+            consecutive_failures: parsed[:consecutive_failures].to_i,
+            consecutive_successes: parsed[:consecutive_successes].to_i,
+            directive: parsed[:directive],
+            evidence_trace_ids: Array(parsed[:evidence_trace_ids]),
+            status: parsed[:status].to_s,
+            last_applied_at: parsed[:last_applied_at],
+            last_reinforced_at: parse_time(parsed[:last_reinforced_at]),
+            created_at: parse_time(parsed[:created_at])
+          }
+        end
+      end
+
+      def parse_time(value)
+        return value if value.is_a?(Time)
+        return nil if value.nil?
+
+        Time.parse(value.to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      module_function :store_key, :find_by_id, :apply_lazy_decay, :apply_pain, :hydrate_apollo_entry, :parse_time
+
+      # Wrapper class that satisfies TrackerPersistence interface
+      class Tracker
+        def dirty?
+          BehavioralSynapse.dirty?
+        end
+
+        def mark_clean!
+          BehavioralSynapse.mark_clean!
+        end
+
+        def to_apollo_entries
+          BehavioralSynapse.to_apollo_entries
+        end
+
+        def from_apollo(store: nil)
+          BehavioralSynapse.from_apollo(store: store)
+        end
+      end
+    end
+  end
+end

data/lib/legion/gaia/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Gaia
-    VERSION = '0.9.59'
+    VERSION = '0.9.60'
   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/behavioral_synapse'
 require 'legion/gaia/tracker_persistence'
 require 'legion/gaia/router'
 
@@ -118,6 +119,7 @@ module Legion
         @absence_pattern_checked_at = nil
         @last_valences = nil
         @last_response_at = nil
+        @last_applied = nil
         @tick_history = nil
         @tick_count = nil
         @started_at = nil
@@ -258,6 +260,28 @@ module Legion
         handle_exception(e, level: :warn, operation: 'gaia.record_advisory_meta', advisory_id: advisory_id)
       end
 
+      def record_response_applied(advisory_id:, identity:, applied:)
+        return unless started?
+
+        synapse_count = Array(applied[:behavioral_synapse_ids]).size
+        log.info("[gaia] attribution advisory_id=#{advisory_id} identity=#{identity} synapses=#{synapse_count}")
+
+        store = apollo_local_store
+        store&.upsert(
+          content: Legion::JSON.dump(applied.merge(advisory_id: advisory_id, identity: identity)),
+          tags: %w[self-knowledge attribution] + ["partner:#{identity}"],
+          source_channel: 'gaia',
+          confidence: 0.9,
+          access_scope: 'local'
+        )
+
+        @last_applied = applied.merge(advisory_id: advisory_id, identity: identity)
+        { recorded: true, advisory_id: advisory_id }
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.record_response_applied', advisory_id: advisory_id)
+        { recorded: false }
+      end
+
       def status
         return { started: false } unless started?
 
@@ -377,6 +401,7 @@ module Legion
         @registry.discover
         boot_channels
         boot_agent_bridge
+        register_behavioral_synapse_tracker
         hydrate_from_apollo_local
         register_provisional_partner_prior
         log.info('Legion::Gaia agent mode boot complete')
@@ -638,6 +663,8 @@ module Legion
           log.info("[gaia] calibration identity=#{observation[:identity]} " \
                    "deltas=#{result[:deltas].keys.join(',')}")
         end
+
+        grade_behavioral_synapses(result) if result.is_a?(Hash) && result[:reaction_score]
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.evaluate_calibration', identity: observation[:identity])
       end
@@ -655,6 +682,31 @@ module Legion
         @calibration_runner = runner
       end
 
+      def grade_behavioral_synapses(calibration_result)
+        return unless @last_applied.is_a?(Hash)
+
+        synapse_ids = Array(@last_applied[:behavioral_synapse_ids])
+        return if synapse_ids.empty?
+
+        reaction_score = calibration_result[:reaction_score].to_f
+        outcome = if reaction_score >= 0.6
+                    :success
+                  elsif reaction_score <= 0.4
+                    :failure
+                  end
+        return unless outcome
+
+        multiplier = fetch_imprint_multiplier
+        synapse_ids.each do |sid|
+          BehavioralSynapse.record_outcome(id: sid, outcome: outcome, multiplier: multiplier)
+        end
+        log.info("[gaia] graded synapses count=#{synapse_ids.size} outcome=#{outcome} " \
+                 "reaction_score=#{reaction_score.round(3)}")
+        @last_applied = nil
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.grade_behavioral_synapses')
+      end
+
       def fetch_imprint_multiplier
         # Soft-dep on lex-coldstart; returns settings default if unavailable
         return 1.0 unless defined?(Legion::Extensions::Coldstart) && Legion::Extensions::Coldstart.connected?
@@ -835,12 +887,21 @@ module Legion
         handle_exception(e, level: :debug, operation: 'gaia.flush_trackers_on_shutdown')
       end
 
+      def register_behavioral_synapse_tracker
+        TrackerPersistence.register_tracker(
+          :behavioral_synapse,
+          tracker: BehavioralSynapse::Tracker.new,
+          tags: %w[self-knowledge behavior]
+        )
+      end
+
       def hydrate_from_apollo_local
         store = apollo_local_store
         return unless store
 
         TrackerPersistence.hydrate_all(store: store)
         BondRegistry.hydrate_from_apollo(store: store)
+        BehavioralSynapse.from_apollo(store: store)
         log.info('Legion::Gaia hydrated trackers and bond registry from Apollo Local')
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.hydrate_from_apollo_local')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.59
+  version: 0.9.60
 platform: ruby
 authors:
 - Esity
@@ -417,6 +417,7 @@ files:
 - lib/legion/gaia/actors/heartbeat.rb
 - lib/legion/gaia/advisory.rb
 - lib/legion/gaia/audit_observer.rb
+- lib/legion/gaia/behavioral_synapse.rb
 - lib/legion/gaia/bond_registry.rb
 - lib/legion/gaia/bond_store.rb
 - lib/legion/gaia/bond_tracker.rb