legion-gaia 0.9.63 → 0.9.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d865d2e228e487153ee4681a3d0a939c83090e236f58e99cff670b351d5cc07e
-  data.tar.gz: 84252e97bc38980791c4ac74aaedf1fcc7bc00d6de30c8da7d4fce98d37a89a1
+  metadata.gz: dc0229532bc53d2868fac7cc6279bb2875ceaaedbb63269dc8b5a742a7c95832
+  data.tar.gz: da7e11d18691d6af5e90e2c4da209feaf1b6ab79b4aaa91f4c409e517d7428cf
 SHA512:
-  metadata.gz: 4b307e1dfcf3cfba5e3e0378209c4d562578de7085753f216ed6a3d45e969b3d0e92724f6e428d6635dad31d7d19bdbf5f451b7f0e21406492dca09b97a0f1e0
-  data.tar.gz: 987ad87a47603e4c65cefaad42b26f8817b65154c070040c84936694e7763e62492664c7bb87305d5d03b6e6e6ce4e7d9ab941290f0f41f251011251968811c1
+  metadata.gz: c87775e2f41b815da9b996ceca3383dbf956ec8c8e643c26ec8390fb7477fc0ead9739b4802cbdc5984ebf1266f1d5dd22d145c7b657cc8e7712035f0496932c
+  data.tar.gz: e03a41455d7d36dbb49d89e2b7c74e3db930c07a1a730cb4c695a088c446be020463ff0ea588bdea1ce01b06504890890afa08c42344fbd16e71b6818058727b

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [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
+- Bounded idempotency (FIFO hash, 10k max) prevents duplicate observations per exchange_id
+- Only fires for `:human` type callers; system/internal calls are ignored
+
+## [0.9.65] - 2026-07-23
+### Fixed
+- `resolve_process_identity` now uses `Legion::Identity::Process.canonical_name` exclusively — never `Etc.loginname` or `ENV['USER']` (spoofable, wrong string in corporate environments)
+- Provisional partner registration skips gracefully when identity hasn't resolved yet (no registration under wrong/anonymous string)
+- `drain_growth_frames` moved to public API (Advisory calls it directly)
+- Removed `private_class_method` from Advisory — all methods callable
+
+### Added
+- Advisory now produces `:system_prompt` with partner model slots, growth frames, and epistemic qualifiers — injected via existing legion-llm `gaia_advisory` step (zero legion-llm changes)
+- `Advisory.build_partner_system_prompt(identity:)` — assembles working-memory context for the LLM
+- `Advisory.build_partner_slots(identity:)` — renders PartnerModel slots as natural language
+- `Advisory.drain_growth_content` — drains and renders pending milestone/growth frames
+- `Advisory.build_epistemic_qualifier(identity:)` — delegates to VisibleGrowth for uncertainty markers
+- Log line: `[gaia] advisory partner_prompt injected identity=X length=N` when partner context fires
+
+## [0.9.64] - 2026-07-22
+### Added
+- H9: `Disclosure.report(identity:)` — full partner model transparency surface; includes bond_state, all behavioral_synapses with autonomy_mode, preferences, calibration_weights, imprint_state, prediction_accuracy; each section soft-guarded (nil if extension not loaded, no crash); always includes data_locality statement and termination_available: true
+- H9: `VisibleGrowth.milestone_acknowledgment(identity:, domain:, new_mode:, old_mode:)` — fires once per tier transition per (identity, domain); returns natural-language acknowledgment ("I've noticed you prefer shorter answers — I'm now adjusting my approach.")
+- H9: `VisibleGrowth.pain_revert_acknowledgment(domain:)` — called after 3 consecutive failures reset a synapse; "I've been getting [domain] wrong — I've reset that."
+- H9: `VisibleGrowth.graduation_acknowledgment(identity:)` — fires once per identity when imprint window closes
+- H9: `VisibleGrowth.onboarding_frame(identity:)` — first-contact transparency; plain language about learning, local storage, and termination option; fires once per identity
+- H9: `VisibleGrowth.epistemic_qualifier(identity:, domain:)` — returns hedge/qualifier string during imprint or when relevant synapse is observe-tier; nil when confident (default post-imprint)
+- Wire milestone and pain surfaces into `grade_behavioral_synapses`; pending frames stored in `@pending_growth_frames` (drain via `Gaia.drain_growth_frames`)
+- `GET /api/gaia/partner/:identity/report` route — returns full Disclosure.report for any identity
+
 ## [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

data/lib/legion/gaia/advisory.rb

@@ -20,6 +20,14 @@ module Legion
         advisory[:valence] = Gaia.last_valences if Gaia.last_valences
         merge_tick_data!(advisory, Gaia.registry&.tick_host&.last_tick_result)
         merge_observer_data!(advisory, caller)
+
+        identity = caller&.dig(:requested_by, :identity)
+        partner_prompt = build_partner_system_prompt(identity: identity) if identity
+        if partner_prompt
+          advisory[:system_prompt] = partner_prompt
+          log.info("[gaia] advisory partner_prompt injected identity=#{identity} length=#{partner_prompt.length}")
+        end
+
         result = advisory.compact
         if result.any?
           log.info("GAIA advisory generated conversation_id=#{conversation_id} keys=#{result.keys.join(',')}")
@@ -94,8 +102,58 @@ module Legion
         nil
       end
 
-      private_class_method :merge_tick_data!, :apply_tool_hints!, :apply_suppress!, :merge_observer_data!,
-                           :normalize_routing_hint, :value_for
+      def build_partner_system_prompt(identity:)
+        log.unknown("[gaia] build_partner_system_prompt identity=#{identity} " \
+                    "bond_registry_defined=#{defined?(Legion::Gaia::BondRegistry)} " \
+                    "partner=#{defined?(Legion::Gaia::BondRegistry) && BondRegistry.partner?(identity.to_s)}")
+
+        return nil unless defined?(Legion::Gaia::BondRegistry) && BondRegistry.partner?(identity.to_s)
+
+        parts = ['|gaia:active|']
+
+        slots = build_partner_slots(identity: identity)
+        parts << slots if slots
+        log.unknown("[gaia] partner_slots count=#{slots ? 'present' : 'empty'}")
+
+        growth = drain_growth_content
+        parts << growth if growth
+
+        qualifier = build_epistemic_qualifier(identity: identity)
+        parts << qualifier if qualifier
+
+        parts.join("\n\n")
+      end
+
+      def build_partner_slots(identity:)
+        return nil unless defined?(Legion::Gaia::PartnerModel)
+
+        slots = PartnerModel.build(identity: identity)
+        return nil if slots.empty?
+
+        lines = slots.map do |slot|
+          domain = slot[:domain]
+          content = slot[:content]
+          content_str = content.is_a?(Hash) ? content.map { |k, v| "#{k}: #{v}" }.join(', ') : content.to_s
+          "- #{domain}: #{content_str}"
+        end
+
+        "What I know about working with you:\n#{lines.join("\n")}"
+      end
+
+      def drain_growth_content
+        return nil unless Gaia.respond_to?(:drain_growth_frames)
+
+        frames = Gaia.drain_growth_frames
+        return nil if frames.nil? || frames.empty?
+
+        frames.join("\n")
+      end
+
+      def build_epistemic_qualifier(identity:)
+        return nil unless defined?(Legion::Gaia::VisibleGrowth)
+
+        VisibleGrowth.epistemic_qualifier(identity: identity)
+      end
     end
   end
 end

data/lib/legion/gaia/disclosure.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Legion
+  module Gaia
+    module Disclosure
+      module_function
+
+      # Full partner model report — what the agent knows, how it was earned, what stays local.
+      # Principal-bound: caller reads ONLY their own partner model.
+      #
+      # @param identity [String] the partner identity key
+      # @return [Hash]
+      def report(identity:)
+        identity_str = identity.to_s
+
+        {
+          identity: identity_str,
+          bond_state: fetch_bond_state(identity_str),
+          behavioral_synapses: fetch_behavioral_synapses(identity_str),
+          preferences: fetch_preferences(identity_str),
+          calibration_weights: fetch_calibration_weights(identity_str),
+          imprint_state: fetch_imprint_state,
+          prediction_accuracy: fetch_prediction_accuracy(identity_str),
+          data_locality: 'All data is stored locally on this node. Nothing leaves this machine.',
+          termination_available: true
+        }
+      end
+
+      # --- private section ---
+
+      def fetch_bond_state(identity)
+        entry = Legion::Gaia::BondRegistry.instance_variable_get(:@bonds)[identity]
+        return nil unless entry
+
+        {
+          bond: entry[:bond],
+          strength: entry[:strength],
+          origin: entry[:origin],
+          reinforcement_count: entry[:reinforcement_count],
+          since: entry[:since],
+          preferred_channel: entry[:preferred_channel],
+          lifecycle_state: Legion::Gaia::BondRegistry.bond_state(identity)
+        }
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_bond_state')
+        nil
+      end
+
+      def fetch_behavioral_synapses(identity)
+        all = Legion::Gaia::BehavioralSynapse.all_for(identity: identity)
+        return nil if all.empty?
+
+        all.map do |entry|
+          {
+            id: entry[:id],
+            domain: entry[:domain],
+            directive: entry[:directive],
+            confidence: entry[:confidence],
+            autonomy_mode: Legion::Gaia::BehavioralSynapse::Math.autonomy_mode(entry[:confidence].to_f),
+            status: entry[:status],
+            origin: entry[:origin],
+            consecutive_successes: entry[:consecutive_successes],
+            consecutive_failures: entry[:consecutive_failures],
+            last_reinforced_at: entry[:last_reinforced_at]
+          }
+        end
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_behavioral_synapses')
+        nil
+      end
+
+      def fetch_preferences(identity)
+        return nil unless defined?(Legion::Extensions::Mesh::Helpers::PreferenceProfile)
+
+        result = Legion::Extensions::Mesh::Helpers::PreferenceProfile.for_owner(owner_id: identity)
+        return nil unless result.is_a?(Hash) && result[:directives].is_a?(Array)
+
+        result[:directives]
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_preferences')
+        nil
+      end
+
+      def fetch_calibration_weights(identity)
+        return nil unless defined?(Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration)
+
+        runner = Object.new
+        runner.extend(Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration)
+        result = runner.respond_to?(:calibration_weights_for) ? runner.calibration_weights_for(identity: identity) : nil
+        result.is_a?(Hash) ? result : nil
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_calibration_weights')
+        nil
+      end
+
+      def fetch_imprint_state
+        return nil unless defined?(Legion::Extensions::Coldstart)
+        return nil unless Legion::Extensions::Coldstart.respond_to?(:connected?) &&
+                          Legion::Extensions::Coldstart.connected?
+
+        bootstrap = Legion::Extensions::Coldstart::Helpers::Bootstrap.instance
+        {
+          layer: bootstrap.respond_to?(:current_layer) ? bootstrap.current_layer : nil,
+          observations_count: bootstrap.respond_to?(:observation_count) ? bootstrap.observation_count : nil,
+          active: bootstrap.respond_to?(:imprint_active?) ? bootstrap.imprint_active? : nil
+        }
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_imprint_state')
+        nil
+      end
+
+      def fetch_prediction_accuracy(identity)
+        return nil unless defined?(Legion::Extensions::AgenticInference)
+        return nil unless Legion::Extensions::AgenticInference.respond_to?(:accuracy_for)
+
+        Legion::Extensions::AgenticInference.accuracy_for(identity: identity)
+      rescue StandardError => e
+        Legion::Gaia::Disclosure.handle_exception_quietly(e, 'disclosure.fetch_prediction_accuracy')
+        nil
+      end
+
+      def handle_exception_quietly(exception, operation)
+        return unless defined?(Legion::Logging)
+
+        Legion::Logging.debug("[gaia] #{operation} soft-guarded: #{exception.class}: #{exception.message}")
+      end
+
+      module_function :fetch_bond_state, :fetch_behavioral_synapses, :fetch_preferences,
+                      :fetch_calibration_weights, :fetch_imprint_state, :fetch_prediction_accuracy,
+                      :handle_exception_quietly
+    end
+  end
+end

data/lib/legion/gaia/routes.rb

@@ -63,6 +63,7 @@ module Legion
         register_teams_webhook_route(app)
         register_ingest_route(app)
         register_bond_terminate_route(app)
+        register_partner_report_route(app)
       end
 
       def self.register_status_route(app)
@@ -204,10 +205,20 @@ module Legion
         end
       end
 
+      def self.register_partner_report_route(app)
+        app.get '/api/gaia/partner/:identity/report' do
+          identity = params[:identity]
+          halt 400, json_error('missing_identity', 'identity is required') if identity.to_s.empty?
+
+          result = Legion::Gaia::Disclosure.report(identity: identity)
+          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_bond_terminate_route
+                :register_ingest_route, :register_bond_terminate_route, :register_partner_report_route
       end
     end
   end

data/lib/legion/gaia/version.rb

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

data/lib/legion/gaia/visible_growth.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Legion
+  module Gaia
+    module VisibleGrowth
+      module_function
+
+      # In-memory deduplication sets — reset on restart is intentional (worst case: fires twice)
+      @acknowledged_milestones = Set.new
+      @graduated_identities    = Set.new
+      @onboarded_identities    = Set.new
+      @mutex                   = Mutex.new
+
+      TIER_LABELS = {
+        observe: 'noticing patterns',
+        filter: 'adjusting my approach',
+        transform: 'actively shaping my responses',
+        autonomous: 'acting on this without asking'
+      }.freeze
+
+      DOMAIN_PHRASES = {
+        'brevity' => 'shorter answers',
+        'verbosity' => 'longer, more detailed answers',
+        'tone' => 'the tone',
+        'format' => 'the format',
+        'code' => 'code style',
+        'detail' => 'the level of detail'
+      }.freeze
+
+      # Called when a synapse confidence crosses into a new autonomy tier.
+      # Fires ONCE per (identity, domain, tier transition).
+      #
+      # @param identity [String]
+      # @param domain   [String]
+      # @param new_mode [Symbol] :observe | :filter | :transform | :autonomous
+      # @param old_mode [Symbol]
+      # @return [String, nil] acknowledgment message, or nil if already fired
+      def milestone_acknowledgment(identity:, domain:, new_mode:, old_mode:)
+        key = "#{identity}:#{domain}:#{old_mode}->#{new_mode}"
+        @mutex.synchronize do
+          return nil if @acknowledged_milestones.include?(key)
+
+          @acknowledged_milestones.add(key)
+        end
+
+        phrase = domain_phrase(domain)
+        tier_desc = TIER_LABELS.fetch(new_mode.to_sym, new_mode.to_s)
+
+        "I've noticed you prefer #{phrase} — I'm now #{tier_desc}. Tell me if I've got that wrong."
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.milestone_acknowledgment')
+        nil
+      end
+
+      # Called when pain fires (3 consecutive failures → dampened status).
+      #
+      # @param identity [String] (unused, reserved for future per-identity routing)
+      # @param domain   [String]
+      # @return [String]
+      def pain_revert_acknowledgment(domain:, identity: nil) # rubocop:disable Lint/UnusedMethodArgument
+        phrase = domain_phrase(domain)
+        "I've been getting #{phrase} wrong — I've reset that. What works for you?"
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.pain_revert_acknowledgment')
+        "I reset something that wasn't working — what would you prefer?"
+      end
+
+      # Called at imprint graduation (imprint window closes). Fires once per identity.
+      #
+      # @param identity [String]
+      # @return [String, nil]
+      def graduation_acknowledgment(identity:)
+        @mutex.synchronize do
+          return nil if @graduated_identities.include?(identity.to_s)
+
+          @graduated_identities.add(identity.to_s)
+        end
+
+        "I feel like I know how you work now — I'll ask less and do more. Correct me if I drift."
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.graduation_acknowledgment')
+        nil
+      end
+
+      # Onboarding honesty — first frame at imprint open. Plain language about what's happening.
+      # Fires once per identity.
+      #
+      # @param identity [String]
+      # @return [String, nil] content string for OutputFrame, or nil if already sent
+      def onboarding_frame(identity:)
+        @mutex.synchronize do
+          return nil if @onboarded_identities.include?(identity.to_s)
+
+          @onboarded_identities.add(identity.to_s)
+        end
+
+        build_onboarding_text(identity: identity)
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.onboarding_frame')
+        nil
+      end
+
+      # Epistemic honesty surface — returns a hedge/qualifier to append to a response, or nil.
+      # Returns nil when confident (should be most of the time post-imprint).
+      #
+      # @param identity [String]
+      # @param domain   [String, nil] current exchange domain, if known
+      # @return [String, nil]
+      def epistemic_qualifier(identity:, domain: nil)
+        imprint_active = imprint_active_for?
+        synapse = domain ? Legion::Gaia::BehavioralSynapse.for(identity: identity.to_s, domain: domain.to_s) : nil
+
+        return imprint_qualifier if imprint_active
+        return observe_qualifier(domain) if synapse_observe_tier?(synapse)
+
+        nil
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.epistemic_qualifier')
+        nil
+      end
+
+      # Reset in-memory state (for tests)
+      def reset!
+        @mutex.synchronize do
+          @acknowledged_milestones = Set.new
+          @graduated_identities    = Set.new
+          @onboarded_identities    = Set.new
+        end
+      end
+
+      # --- private helpers ---
+
+      def domain_phrase(domain)
+        DOMAIN_PHRASES.fetch(domain.to_s, domain.to_s.tr('_', ' '))
+      end
+
+      def imprint_active_for?
+        return false unless defined?(Legion::Extensions::Coldstart)
+        return false unless Legion::Extensions::Coldstart.respond_to?(:connected?) &&
+                            Legion::Extensions::Coldstart.connected?
+
+        bootstrap = Legion::Extensions::Coldstart::Helpers::Bootstrap.instance
+        bootstrap.respond_to?(:imprint_active?) && bootstrap.imprint_active?
+      rescue StandardError
+        false
+      end
+
+      def imprint_observation_count
+        return nil unless defined?(Legion::Extensions::Coldstart)
+
+        bootstrap = Legion::Extensions::Coldstart::Helpers::Bootstrap.instance
+        bootstrap.respond_to?(:observation_count) ? bootstrap.observation_count : nil
+      rescue StandardError
+        nil
+      end
+
+      def imprint_qualifier
+        count = imprint_observation_count
+        return "I'm still figuring out how you like things — was this right?" if count.nil? || count < 5
+
+        "I'm still learning your style — let me know if this missed."
+      end
+
+      def synapse_observe_tier?(synapse)
+        return false unless synapse.is_a?(Hash)
+
+        Legion::Gaia::BehavioralSynapse::Math.autonomy_mode(synapse[:confidence].to_f) == :observe
+      end
+
+      def observe_qualifier(domain)
+        "I have a hunch about #{domain_phrase(domain)} — tell me if I'm off."
+      end
+
+      def build_onboarding_text(identity:)
+        lines = [
+          "I'll be learning as we work together — what you prefer, how you like information, " \
+          'what lands and what misses.',
+          'Everything stays on this machine — nothing is sent anywhere else.',
+          'You can end this at any time — your data goes with it, completely.'
+        ]
+
+        bond = Legion::Gaia::BondRegistry.bond(identity.to_s)
+        lines << "You're the partner on this node, so I'll pay closer attention." if bond == :partner
+
+        lines.join(' ')
+      rescue StandardError => e
+        VisibleGrowth.log_quietly(e, 'visible_growth.build_onboarding_text')
+        "I'm learning as we go. Everything stays local. You can end this any time."
+      end
+
+      def log_quietly(exception, operation)
+        return unless defined?(Legion::Logging)
+
+        Legion::Logging.debug("[gaia] #{operation} rescued: #{exception.class}: #{exception.message}")
+      end
+
+      module_function :domain_phrase, :imprint_active_for?, :imprint_observation_count,
+                      :imprint_qualifier, :synapse_observe_tier?, :observe_qualifier,
+                      :build_onboarding_text, :log_quietly
+    end
+  end
+end

data/lib/legion/gaia.rb

@@ -35,6 +35,8 @@ require 'legion/gaia/bond_registry'
 require 'legion/gaia/death_protocol'
 require 'legion/gaia/behavioral_synapse'
 require 'legion/gaia/partner_model'
+require 'legion/gaia/disclosure'
+require 'legion/gaia/visible_growth'
 require 'legion/gaia/tracker_persistence'
 require 'legion/gaia/router'
 
@@ -128,6 +130,7 @@ module Legion
         @started_at = nil
         @active_heartbeats = 0
         @quiescing_phase_handlers_cache = nil
+        @pending_growth_frames = nil
 
         log.info('Legion::Gaia shut down')
       end
@@ -327,6 +330,71 @@ module Legion
         base_status.merge(router_status)
       end
 
+      def drain_growth_frames
+        frames = @pending_growth_frames || []
+        @pending_growth_frames = []
+        frames
+      end
+
+      def observe_from_pipeline(identity:, caller:, exchange_id:)
+        return unless started?
+
+        caller_type = caller&.dig(:requested_by, :type)
+        return unless caller_type == :human
+
+        identity_str = identity.to_s
+        return if identity_str.empty?
+        return if identity_lifecycle_blocked?(identity_str)
+        return if pipeline_observation_seen?(exchange_id)
+
+        mark_pipeline_observation(exchange_id)
+
+        if BondRegistry.bond(identity_str) == :unknown
+          if BondRegistry.partner_entry.nil?
+            BondRegistry.register(identity_str, bond: :partner, priority: :primary,
+                                                origin: :provisional,
+                                                strength: settings&.dig(:partner, :prior_strength) || 0.5)
+            log.info("[gaia] pipeline duckling bond identity=#{identity_str}")
+          else
+            BondRegistry.register(identity_str, bond: nil)
+          end
+        end
+
+        BondRegistry.reinforce(identity_str, multiplier: fetch_imprint_multiplier)
+
+        if defined?(Legion::Extensions::Coldstart)
+          bootstrap = Legion::Extensions::Coldstart::Helpers::Bootstrap.instance
+          bootstrap.record_observation
+        end
+
+        log.debug("[gaia] pipeline observation identity=#{identity_str} exchange_id=#{exchange_id}")
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'gaia.observe_from_pipeline', identity: identity)
+      end
+
+      def pipeline_observation_seen?(exchange_id)
+        return false if exchange_id.nil?
+
+        @pipeline_observations ||= {}
+        @pipeline_observations.key?(exchange_id)
+      end
+
+      def mark_pipeline_observation(exchange_id)
+        return if exchange_id.nil?
+
+        @pipeline_observations ||= {}
+        @pipeline_observation_order ||= []
+
+        @pipeline_observations[exchange_id] = true
+        @pipeline_observation_order << exchange_id
+
+        max_size = settings&.dig(:pipeline_observation, :max_tracked) || 10_000
+        while @pipeline_observation_order.size > max_size
+          oldest = @pipeline_observation_order.shift
+          @pipeline_observations.delete(oldest)
+        end
+      end
+
       private
 
       def heartbeat_mutex
@@ -582,14 +650,22 @@ module Legion
         true
       end
 
-      def observe_interlocutor(input_frame, identity)
+      def observe_interlocutor(input_frame, identity) # rubocop:disable Metrics/AbcSize
         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
-        BondRegistry.register(identity_str, bond: nil) unless BondRegistry.bond(identity_str) != :unknown
+        # Duckling: first authenticated human on a node with no partner → immediate partner
+        if BondRegistry.bond(identity_str) == :unknown
+          if BondRegistry.partner_entry.nil?
+            BondRegistry.register(identity_str, bond: :partner, priority: :primary,
+                                                origin: :provisional, strength: 0.5)
+            log.info("[gaia] duckling bond formed identity=#{identity_str}")
+          else
+            BondRegistry.register(identity_str, bond: nil)
+          end
+        end
 
         # Every interaction reinforces — the evidence accumulation loop
         direct_address = input_frame.metadata[:direct_address] || false
@@ -641,7 +717,9 @@ module Legion
         return unless BondRegistry.partner_entry.nil?
 
         process_identity = resolve_process_identity
-        prior_strength   = settings&.dig(:partner, :prior_strength) || 0.5
+        return if process_identity.nil?
+
+        prior_strength = settings&.dig(:partner, :prior_strength) || 0.5
 
         BondRegistry.register(
           process_identity,
@@ -656,9 +734,13 @@ module Legion
       end
 
       def resolve_process_identity
-        (defined?(Etc) && Etc.respond_to?(:loginname) && Etc.loginname) || ENV.fetch('USER', nil) || 'unknown'
+        return nil unless defined?(Legion::Identity::Process) && Legion::Identity::Process.respond_to?(:canonical_name)
+
+        name = Legion::Identity::Process.canonical_name
+        return nil if name.nil? || name == 'anonymous'
+
+        name
       end
-      private :resolve_process_identity
 
       def record_interaction_trace(observation)
         return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
@@ -733,25 +815,61 @@ module Legion
         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
+        outcome = calibration_outcome(calibration_result[:reaction_score].to_f)
         return unless outcome
 
+        identity   = @last_applied[:identity]&.to_s
         multiplier = fetch_imprint_multiplier
         synapse_ids.each do |sid|
-          BehavioralSynapse.record_outcome(id: sid, outcome: outcome, multiplier: multiplier)
+          grade_single_synapse(sid, outcome: outcome, identity: identity, multiplier: multiplier)
         end
+
         log.info("[gaia] graded synapses count=#{synapse_ids.size} outcome=#{outcome} " \
-                 "reaction_score=#{reaction_score.round(3)}")
+                 "reaction_score=#{calibration_result[:reaction_score].to_f.round(3)}")
         @last_applied = nil
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'gaia.grade_behavioral_synapses')
       end
 
+      def calibration_outcome(reaction_score)
+        if reaction_score >= 0.6
+          :success
+        elsif reaction_score <= 0.4
+          :failure
+        end
+      end
+
+      def grade_single_synapse(sid, outcome:, identity:, multiplier:)
+        pre_entry = BehavioralSynapse.store.values.find { |e| e[:id] == sid }
+        old_mode  = pre_entry ? BehavioralSynapse::Math.autonomy_mode(pre_entry[:confidence].to_f) : nil
+
+        result = BehavioralSynapse.record_outcome(id: sid, outcome: outcome, multiplier: multiplier)
+        return unless result.is_a?(Hash) && result[:found] != false
+
+        surface_pain_frame(result, identity: identity, old_mode: old_mode)
+        surface_milestone_frame(result, identity: identity, old_mode: old_mode)
+      end
+
+      def surface_pain_frame(result, old_mode:, **)
+        return unless result[:status] == 'dampened' && old_mode && old_mode != :observe
+
+        msg = VisibleGrowth.pain_revert_acknowledgment(domain: result[:domain].to_s)
+        enqueue_growth_frame(msg) if msg
+      end
+
+      def surface_milestone_frame(result, identity:, old_mode:)
+        new_mode = BehavioralSynapse::Math.autonomy_mode(result[:confidence].to_f)
+        return unless old_mode && new_mode != old_mode && result[:status] == 'active'
+
+        msg = VisibleGrowth.milestone_acknowledgment(
+          identity: identity.to_s,
+          domain: result[:domain].to_s,
+          new_mode: new_mode,
+          old_mode: old_mode
+        )
+        enqueue_growth_frame(msg) if msg
+      end
+
       def run_partner_deep_learning(identity_str, observation)
         record_interaction_trace(observation)
         evaluate_calibration(observation)
@@ -1278,6 +1396,15 @@ module Legion
 
         "#{compact[0, limit]}..."
       end
+
+      # Stores a growth frame string for delivery on the next response turn.
+      def enqueue_growth_frame(message)
+        return if message.to_s.empty?
+
+        @pending_growth_frames ||= []
+        @pending_growth_frames << message
+        log.info("[gaia] growth frame queued: #{message.inspect}")
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-gaia
 version: !ruby/object:Gem::Version
-  version: 0.9.63
+  version: 0.9.66
 platform: ruby
 authors:
 - Esity
@@ -433,6 +433,7 @@ files:
 - lib/legion/gaia/channels/teams_adapter.rb
 - lib/legion/gaia/cognitive_bus.rb
 - lib/legion/gaia/death_protocol.rb
+- lib/legion/gaia/disclosure.rb
 - lib/legion/gaia/input_frame.rb
 - lib/legion/gaia/intent_classifier.rb
 - lib/legion/gaia/logging.rb
@@ -468,6 +469,7 @@ files:
 - lib/legion/gaia/tick_history.rb
 - lib/legion/gaia/tracker_persistence.rb
 - lib/legion/gaia/version.rb
+- lib/legion/gaia/visible_growth.rb
 - lib/legion/gaia/workflow.rb
 - lib/legion/gaia/workflow/checkpoint.rb
 - lib/legion/gaia/workflow/definition.rb