legion-gaia 0.9.60 → 0.9.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fc298cf66a402057db523e07a53e4bde4a30a7b3e8090b819b8b1f64569c589
-  data.tar.gz: 6226b64c0fc7ace2122f014784b21f074fae19ebfc214360b5288cfc7d9e80d0
+  metadata.gz: 12edcb61bebce4bbbd39edcbdb2db2281570ebea9fdf532b6b5ecf35a1d97fbb
+  data.tar.gz: aa4e1afe3bae0e4159d2d1975726f9dcafb216d4f72f63582f22089feae5a323
 SHA512:
-  metadata.gz: d74b4bc1634a51f8759771f8c77711a58c92627487ca3c98e2af22c2244ab1c3efc63de5364656179d3232aa8d9ee9a0faa48f7a35d28dfa34aef21e493351bb
-  data.tar.gz: 1d4f2872dc1b9e332160f34676dc1f5950dd6a13b2d72a050c4c65b693546e8743309ba34148cdc3d18cb103127279c5dd8d055832ad2db41e182dcb0adf17d5
+  metadata.gz: b404500f3c22a620c2ddb27957d1b163377cc0301059aaa5e7cf94d0b0880bf9377e9da9191a6680674a3ab5e3cce5f8c9d7019b0bd9874fd6180ebaf14cb1d4
+  data.tar.gz: 27d9e1ea9bbc959c18c7ddc0e101feddb569e2c8fd52f16106e39a1b96af510d4c1abd371b8ded229ae8b6e3d391b62a0d9e872d67a4b941a2762abb5981c397

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.61] - 2026-07-16
+### Added
+- H4: `PartnerModel` — 7-slot working-memory competition (§12.4); only filter/transform/autonomous tier synapses compete, observe-tier excluded; unified ranking across synapses, traces, and preferences by `strength × (1 + emotional_intensity)`; `observe_mode_entries` transparency surface
+- Wire `update_from_observation` on `PreferenceProfile` in `observe_interlocutor` (soft-guarded on lex-mesh)
+- Correction detection: explicit negative feedback after applied behavioral response → correction trace via lex-agentic-memory
+- Crystallization path: N corroborating corrections (default threshold 3) per (identity, domain) → `BehavioralSynapse.crystallize` with `origin: 'emergent'`
+
 ## [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)

data/lib/legion/gaia/partner_model.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Legion
+  module Gaia
+    module PartnerModel
+      # Working-memory slot competition (§12.4).
+      # Only filter/transform/autonomous tier synapses compete — observe-tier synapses are
+      # tracked separately via observe_mode_entries and never consume working-memory slots.
+      MAX_WORKING_MEMORY_SLOTS = 7
+
+      # Source-confidence defaults for preference candidates.
+      PREFERENCE_SOURCE_CONFIDENCE = {
+        explicit: 1.0,
+        preference_learning: 0.75,
+        llm_inference: 0.65,
+        observation: 0.55
+      }.freeze
+
+      module_function
+
+      # Build the working-memory slot array for this identity.
+      #
+      # @param identity [String, Symbol] the partner identity key
+      # @param synapses [Array, nil] BehavioralSynapse entries; fetched from store if nil
+      # @param traces   [Array, nil] episodic/semantic trace hashes from lex-agentic-memory
+      # @param preferences [Array, nil] PreferenceProfile directives with :source and :content
+      # @return [Array<Hash>] at most MAX_WORKING_MEMORY_SLOTS slot hashes, sorted by score desc
+      def build(identity:, synapses: nil, traces: nil, preferences: nil)
+        identity_str = identity.to_s
+        candidates = []
+        candidates.concat(synapse_candidates(identity: identity_str, synapses: synapses))
+        candidates.concat(trace_candidates(traces))
+        candidates.concat(preference_candidates(preferences))
+
+        max_slots = Legion::Gaia.settings&.dig(:partner_model, :max_slots) || MAX_WORKING_MEMORY_SLOTS
+
+        candidates
+          .sort_by { |c| -slot_score(c) }
+          .first(max_slots)
+          .map { |c| c.slice(:type, :domain, :content, :strength, :source_id, :autonomy_mode) }
+      end
+
+      # Returns observe-tier synapses for this identity (transparency surface — not in working memory).
+      #
+      # @param identity [String, Symbol]
+      # @return [Array<Hash>]
+      def observe_mode_entries(identity:)
+        identity_str = identity.to_s
+        all = Legion::Gaia::BehavioralSynapse.all_for(identity: identity_str)
+        all.select { |entry| autonomy_tier(entry[:confidence]) == :observe }
+           .map do |entry|
+             {
+               type: :synapse,
+               domain: entry[:domain],
+               content: entry[:directive],
+               strength: entry[:confidence],
+               source_id: entry[:id],
+               autonomy_mode: :observe
+             }
+           end
+      end
+
+      # --- private helpers ---
+
+      def synapse_candidates(identity:, synapses:)
+        entries = synapses || Legion::Gaia::BehavioralSynapse.all_for(identity: identity)
+        entries.filter_map do |entry|
+          tier = autonomy_tier(entry[:confidence])
+          next unless %i[filter transform autonomous].include?(tier)
+
+          {
+            type: :synapse,
+            domain: entry[:domain],
+            content: entry[:directive],
+            strength: entry[:confidence].to_f,
+            emotional_intensity: entry[:emotional_intensity].to_f,
+            source_id: entry[:id],
+            autonomy_mode: tier
+          }
+        end
+      end
+
+      def trace_candidates(traces)
+        return [] unless traces.is_a?(Array)
+
+        traces.map do |trace|
+          strength = (trace[:strength] || trace[:confidence]).to_f
+          intensity = (trace[:emotional_intensity] || 0.5).to_f
+          {
+            type: :trace,
+            domain: Array(trace[:domain_tags]).first.to_s,
+            content: trace[:content_payload],
+            strength: strength,
+            emotional_intensity: intensity,
+            source_id: trace[:trace_id],
+            autonomy_mode: nil
+          }
+        end
+      end
+
+      def preference_candidates(preferences)
+        return [] unless preferences.is_a?(Array)
+
+        preferences.map do |pref|
+          source_key = pref[:source].to_s.to_sym
+          strength = PREFERENCE_SOURCE_CONFIDENCE.fetch(source_key, 0.55)
+          {
+            type: :preference,
+            domain: pref[:domain].to_s,
+            content: pref[:content] || pref[:directive],
+            strength: strength,
+            emotional_intensity: 0.3,
+            source_id: pref[:id],
+            autonomy_mode: nil
+          }
+        end
+      end
+
+      def slot_score(candidate)
+        strength  = candidate[:strength].to_f
+        intensity = candidate[:emotional_intensity].to_f
+        strength * (1.0 + intensity)
+      end
+
+      def autonomy_tier(confidence)
+        Legion::Gaia::BehavioralSynapse::Math.autonomy_mode(confidence.to_f)
+      end
+
+      module_function :synapse_candidates, :trace_candidates, :preference_candidates,
+                      :slot_score, :autonomy_tier
+    end
+  end
+end

data/lib/legion/gaia/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Gaia
-    VERSION = '0.9.60'
+    VERSION = '0.9.61'
   end
 end

data/lib/legion/gaia.rb

@@ -33,6 +33,7 @@ require 'legion/gaia/offline_handler'
 require 'legion/gaia/proactive_dispatcher'
 require 'legion/gaia/bond_registry'
 require 'legion/gaia/behavioral_synapse'
+require 'legion/gaia/partner_model'
 require 'legion/gaia/tracker_persistence'
 require 'legion/gaia/router'
 
@@ -120,6 +121,7 @@ module Legion
         @last_valences = nil
         @last_response_at = nil
         @last_applied = nil
+        @correction_counts = nil
         @tick_history = nil
         @tick_count = nil
         @started_at = nil
@@ -401,6 +403,7 @@ module Legion
         @registry.discover
         boot_channels
         boot_agent_bridge
+        @correction_counts = Concurrent::Hash.new(0)
         register_behavioral_synapse_tracker
         hydrate_from_apollo_local
         register_provisional_partner_prior
@@ -583,11 +586,7 @@ module Legion
           bootstrap.record_observation
         end
 
-        # The gate: only partner-level identities get deep learning
-        if BondRegistry.partner?(identity_str)
-          record_interaction_trace(observation)
-          evaluate_calibration(observation)
-        end
+        run_partner_deep_learning(identity_str, observation) if BondRegistry.partner?(identity_str)
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.observe_interlocutor', identity: identity)
       end
@@ -707,6 +706,91 @@ module Legion
         handle_exception(e, level: :warn, operation: 'gaia.grade_behavioral_synapses')
       end
 
+      def run_partner_deep_learning(identity_str, observation)
+        record_interaction_trace(observation)
+        evaluate_calibration(observation)
+        update_preference_profile(identity_str, observation)
+        detect_and_record_correction(identity_str, observation)
+      end
+
+      def update_preference_profile(identity_str, observation)
+        return unless defined?(Legion::Extensions::Mesh::Helpers::PreferenceProfile)
+
+        Legion::Extensions::Mesh::Helpers::PreferenceProfile.update_from_observation(
+          owner_id: identity_str, signals: observation
+        )
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.update_preference_profile', identity: identity_str)
+      end
+
+      def detect_and_record_correction(identity_str, observation)
+        return unless defined?(Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration)
+        return unless @last_applied&.dig(:behavioral_synapse_ids)&.any?
+
+        ensure_calibration_runner
+        feedback_result = @calibration_runner.detect_explicit_feedback(content: observation[:content].to_s)
+        return unless feedback_result[:feedback] == :negative
+
+        record_correction_trace(identity: identity_str, applied: @last_applied, observation: observation)
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.detect_and_record_correction', identity: identity_str)
+      end
+
+      def record_correction_trace(identity:, applied:, observation:)
+        return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+        runner.store_trace(
+          type: :correction,
+          content_payload: {
+            correction_type: :explicit_negative_feedback,
+            applied_synapse_ids: Array(applied[:behavioral_synapse_ids]),
+            channel: observation[:channel],
+            content_type: observation[:content_type]
+          },
+          domain_tags: ['correction', "partner:#{identity}"],
+          origin: :direct_experience,
+          emotional_valence: -0.5,
+          emotional_intensity: 0.6,
+          confidence: 0.9
+        ).tap do |trace_result|
+          log.info("[gaia] correction trace identity=#{identity} " \
+                   "trace=#{trace_result[:trace_id].to_s[0, 8]} " \
+                   "synapse_ids=#{Array(applied[:behavioral_synapse_ids]).size}")
+          check_crystallization(identity: identity, applied: applied, trace_id: trace_result[:trace_id])
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.record_correction_trace', identity: identity)
+      end
+
+      def check_crystallization(identity:, applied:, trace_id:)
+        domain = applied[:domain].to_s
+        return if domain.empty?
+
+        threshold = settings&.dig(:partner_model, :crystallize_threshold) || 3
+        @correction_counts ||= Concurrent::Hash.new(0)
+        key = "#{identity}:#{domain}"
+        @correction_counts[key] += 1
+        count = @correction_counts[key]
+
+        return unless count >= threshold
+
+        synapse_ids = Array(applied[:behavioral_synapse_ids])
+        BehavioralSynapse.crystallize(
+          identity: identity,
+          domain: domain,
+          directive: applied[:directive].to_s,
+          evidence_trace_ids: synapse_ids + [trace_id.to_s],
+          origin: 'emergent'
+        )
+        @correction_counts[key] = 0
+        log.info("[gaia] crystallization triggered identity=#{identity} domain=#{domain} " \
+                 "corrections=#{count} threshold=#{threshold}")
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'gaia.check_crystallization', identity: identity)
+      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?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.60
+  version: 0.9.61
 platform: ruby
 authors:
 - Esity
@@ -443,6 +443,7 @@ files:
 - lib/legion/gaia/offline_handler.rb
 - lib/legion/gaia/output_frame.rb
 - lib/legion/gaia/output_router.rb
+- lib/legion/gaia/partner_model.rb
 - lib/legion/gaia/phase_wiring.rb
 - lib/legion/gaia/proactive.rb
 - lib/legion/gaia/proactive_delivery.rb