lex-agentic-social 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4e4cf74f2655992c34c4945a8da0de92c597fc5371ff6fa595e583a4cdd88a
-  data.tar.gz: b0696e9bc1f7b990fb8e3a153fd22755edf34e18a6fdce7ea7efe23eccaa5afb
+  metadata.gz: 9b5652d5875cf5aae7e51adf8b8b09f0e664a719144a7575ac9eb2f4bd7b7b56
+  data.tar.gz: 62101c073d3970708e278b2e7afd1dbbe3efc582eb03246bf19f975ad1999bd4
 SHA512:
-  metadata.gz: 362432beb980f6e62f4097db1c37f444929ce2edd84439daee258de6e15dae346b5c33b09e3bfab19b2ca5d38ecd75b8f65269099247586750c329e05f5e7728
-  data.tar.gz: 1309465c2e0655fe62b68b3bfb58cf4f07eb9bbd808215927eb64c240dd4a16575117eb1e3cf6c757d7cd40e586bf3416ce4ddc3ba7feb040d8b2589f6f34c9a
+  metadata.gz: 5e210bfd1a546461a34290e84e49a893cbb792c1d304b2087c759d2345a0cc30ac37c3f15760024ab19fdf83106f7cdefb87fa83c025100fd36852931f60c82f
+  data.tar.gz: 7a49e748bfc08d1c918c494f16d8ec4f579e63b3ec97120b532d168ffc9865e1748c9113025c0dfe7c9505c0f1aa3830624299e16926bc1b60be52187a71b0a5

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.1.8] - 2026-03-31
+
+### Added
+- Attachment sub-module for Phase C bond modeling
+- `AttachmentModel`: per-agent attachment strength, style, and stage tracking with EMA updates and no-regression stage transitions
+- `AttachmentStore`: in-memory store with dirty tracking and Apollo Local persistence (`to_apollo_entries`, `from_apollo`)
+- `Attachment` runner: `update_attachment` (tick integration), `reflect_on_bonds` (dream cycle orchestrator reading cross-module bond data), `attachment_stats`
+
+## [0.1.7] - 2026-03-31
+
+### Changed
+- Migrate `TrustMap` persistence from Data::Local SQLite to Apollo Local (`to_apollo_entries`, `from_apollo`)
+- Add dirty tracking (`dirty?`, `mark_clean!`) to `TrustMap` matching SocialGraph/MentalStateTracker pattern
+- Tag schema: `['trust', 'trust_entry', '<agent_id>', '<domain>']` with optional `'partner'` tag via BondRegistry
+- Remove Data::Local migration registration from trust entry point (migration file retained for existing installs)
+- Add one-time `scripts/migrate_trust_to_apollo.rb` for legacy SQLite data migration
+
 ## [0.1.6] - 2026-03-31
 
 ### Added

data/Gemfile

@@ -3,3 +3,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'rubocop-legion'

data/lex-agentic-social.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-transport', '>= 1.3.9'
 
   spec.add_development_dependency 'rspec', '~> 3.13'
-  spec.add_development_dependency 'rubocop', '~> 1.60'
-  spec.add_development_dependency 'rubocop-legion', '~> 0.1'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.26'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-legion'
+  spec.add_development_dependency 'rubocop-rspec'
 end

data/lib/legion/extensions/agentic/social/attachment/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          class Client
+            include Runners::Attachment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment/helpers/attachment_model.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          module Helpers
+            class AttachmentModel
+              attr_reader :agent_id, :attachment_strength, :attachment_style,
+                          :bond_stage, :separation_tolerance, :interaction_count
+
+              def initialize(agent_id:)
+                @agent_id             = agent_id
+                @attachment_strength  = 0.0
+                @attachment_style     = :secure
+                @bond_stage           = :initial
+                @separation_tolerance = Constants::BASE_SEPARATION_TOLERANCE
+                @interaction_count    = 0
+              end
+
+              def update_from_signals(opts = {})
+                frequency_score      = opts.fetch(:frequency_score, 0.0)
+                reciprocity_score    = opts.fetch(:reciprocity_score, 0.0)
+                prediction_accuracy  = opts.fetch(:prediction_accuracy, 0.0)
+                direct_address_ratio = opts.fetch(:direct_address_ratio, 0.0)
+                channel_consistency  = opts.fetch(:channel_consistency, 0.0)
+
+                raw = (frequency_score * Constants::FREQUENCY_WEIGHT) +
+                      (reciprocity_score * Constants::RECIPROCITY_WEIGHT) +
+                      (prediction_accuracy * Constants::PREDICTION_ACCURACY_WEIGHT) +
+                      (direct_address_ratio * Constants::DIRECT_ADDRESS_WEIGHT) +
+                      (channel_consistency * Constants::CHANNEL_CONSISTENCY_WEIGHT)
+
+                @attachment_strength = if @interaction_count.zero?
+                                         raw.clamp(0.0, 1.0)
+                                       else
+                                         alpha = Constants::STRENGTH_ALPHA
+                                         ((alpha * raw) + ((1.0 - alpha) * @attachment_strength)).clamp(0.0, 1.0)
+                                       end
+                @interaction_count += 1
+              end
+
+              def update_stage!
+                new_stage = derive_stage
+                return if Constants::BOND_STAGES.index(new_stage) <= Constants::BOND_STAGES.index(@bond_stage)
+
+                @bond_stage = new_stage
+                @separation_tolerance = Constants::BASE_SEPARATION_TOLERANCE +
+                                        Constants::SEPARATION_TOLERANCE_GROWTH.fetch(@bond_stage, 0)
+              end
+
+              def derive_style!(opts = {})
+                frequency_variance    = opts.fetch(:frequency_variance, 0.0)
+                reciprocity_imbalance = opts.fetch(:reciprocity_imbalance, 0.0)
+                frequency             = opts.fetch(:frequency, 0.0)
+                direct_address_ratio  = opts.fetch(:direct_address_ratio, 0.0)
+                thresholds = Constants::STYLE_THRESHOLDS
+                @attachment_style = if frequency_variance > thresholds[:anxious_frequency_variance] &&
+                                       reciprocity_imbalance > thresholds[:anxious_reciprocity_imbalance]
+                                      :anxious
+                                    elsif frequency < thresholds[:avoidant_frequency] &&
+                                          direct_address_ratio < thresholds[:avoidant_direct_address]
+                                      :avoidant
+                                    else
+                                      :secure
+                                    end
+              end
+
+              def to_h
+                { agent_id: @agent_id, attachment_strength: @attachment_strength,
+                  attachment_style: @attachment_style, bond_stage: @bond_stage,
+                  separation_tolerance: @separation_tolerance, interaction_count: @interaction_count }
+              end
+
+              def self.from_h(hash)
+                model = new(agent_id: hash[:agent_id])
+                model.instance_variable_set(:@attachment_strength, hash[:attachment_strength].to_f)
+                model.instance_variable_set(:@attachment_style, hash[:attachment_style]&.to_sym || :secure)
+                model.instance_variable_set(:@bond_stage, hash[:bond_stage]&.to_sym || :initial)
+                model.instance_variable_set(:@separation_tolerance, hash[:separation_tolerance]&.to_i || 3)
+                model.instance_variable_set(:@interaction_count, hash[:interaction_count].to_i)
+                model
+              end
+
+              private
+
+              def derive_stage
+                Constants::STAGE_THRESHOLDS.each_key.reverse_each do |stage|
+                  threshold = Constants::STAGE_THRESHOLDS[stage]
+                  return stage if @interaction_count >= threshold[:interactions] &&
+                                  @attachment_strength >= threshold[:strength]
+                end
+                :initial
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment/helpers/attachment_store.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          module Helpers
+            class AttachmentStore
+              def initialize
+                @models = {}
+                @dirty  = false
+              end
+
+              def get(agent_id)
+                @models[agent_id.to_s]
+              end
+
+              def get_or_create(agent_id)
+                key = agent_id.to_s
+                @models[key] ||= begin
+                  @dirty = true
+                  AttachmentModel.new(agent_id: key)
+                end
+              end
+
+              def all_models
+                @models.values
+              end
+
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+                self
+              end
+
+              def to_apollo_entries
+                @models.map do |agent_id, model|
+                  tags = Constants::TAG_PREFIX.dup + [agent_id]
+                  tags << 'partner' if partner?(agent_id)
+                  content = serialize(model.to_h)
+                  { content: content, tags: tags }
+                end
+              end
+
+              def from_apollo(store:)
+                result = store.query(text: 'bond attachment', tags: %w[bond attachment])
+                return false unless result[:success] && result[:results]&.any?
+
+                result[:results].each do |entry|
+                  parsed = deserialize(entry[:content])
+                  next unless parsed && parsed[:agent_id]
+
+                  @models[parsed[:agent_id].to_s] = AttachmentModel.from_h(parsed)
+                end
+                true
+              rescue StandardError => e
+                warn "[attachment_store] from_apollo error: #{e.message}"
+                false
+              end
+
+              private
+
+              def partner?(agent_id)
+                defined?(Legion::Gaia::BondRegistry) && Legion::Gaia::BondRegistry.partner?(agent_id)
+              end
+
+              def serialize(hash)
+                defined?(Legion::JSON) ? Legion::JSON.dump(hash) : ::JSON.dump(hash)
+              end
+
+              def deserialize(content)
+                parsed = defined?(Legion::JSON) ? Legion::JSON.parse(content) : ::JSON.parse(content, symbolize_names: true)
+                parsed.transform_keys(&:to_sym)
+              rescue StandardError => _e
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment/helpers/constants.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          module Helpers
+            module Constants
+              # Strength computation weights (must sum to 1.0)
+              FREQUENCY_WEIGHT            = 0.3
+              RECIPROCITY_WEIGHT          = 0.25
+              PREDICTION_ACCURACY_WEIGHT  = 0.2
+              DIRECT_ADDRESS_WEIGHT       = 0.15
+              CHANNEL_CONSISTENCY_WEIGHT  = 0.1
+
+              # Bond lifecycle stages
+              BOND_STAGES = %i[initial forming established deep].freeze
+
+              # Attachment style classifications
+              ATTACHMENT_STYLES = %i[secure anxious avoidant].freeze
+
+              # Stage progression thresholds
+              STAGE_THRESHOLDS = {
+                forming:     { interactions: 10,  strength: 0.3 },
+                established: { interactions: 50,  strength: 0.5 },
+                deep:        { interactions: 200, strength: 0.7 }
+              }.freeze
+
+              # Separation tolerance (consecutive prediction misses before anxiety signal)
+              BASE_SEPARATION_TOLERANCE = 3
+              SEPARATION_TOLERANCE_GROWTH = {
+                initial: 0, forming: 1, established: 2, deep: 4
+              }.freeze
+
+              # EMA alpha for strength updates
+              STRENGTH_ALPHA = 0.15
+
+              # Style derivation thresholds
+              STYLE_THRESHOLDS = {
+                anxious_frequency_variance:    0.4,
+                anxious_reciprocity_imbalance: 0.3,
+                avoidant_frequency:            0.2,
+                avoidant_direct_address:       0.15
+              }.freeze
+
+              # Apollo Local tag prefix
+              TAG_PREFIX = %w[bond attachment].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment/runners/attachment.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          module Runners
+            module Attachment
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+
+              def update_attachment(tick_results: {}, human_observations: [], **)
+                agents = collect_agent_ids(tick_results, human_observations)
+                return { agents_updated: 0 } if agents.empty?
+
+                agents.each do |agent_id|
+                  model = attachment_store.get_or_create(agent_id)
+                  signals = extract_signals(agent_id, tick_results, human_observations)
+                  model.update_from_signals(signals)
+                  model.update_stage!
+                  model.derive_style!(extract_style_signals(agent_id, human_observations))
+                end
+
+                { agents_updated: agents.size, models: agents.map { |id| attachment_store.get(id)&.to_h } }
+              end
+
+              def reflect_on_bonds(_tick_results: {}, _bond_summary: {}, **)
+                store = apollo_local_store
+                return { success: false, error: :no_store } unless store
+
+                partner_id    = resolve_partner_id
+                model         = attachment_store.get(partner_id) if partner_id
+                comm_patterns = read_communication_patterns(store, partner_id)
+                arc_state     = read_relationship_arc(store, partner_id)
+                health        = compute_relationship_health(model, comm_patterns, arc_state)
+
+                {
+                  bonds_reflected: attachment_store.all_models.size,
+                  partner_bond:    if model
+                                     {
+                                       stage:            model.bond_stage,
+                                       strength:         model.attachment_strength,
+                                       style:            model.attachment_style,
+                                       health:           health,
+                                       milestones_today: arc_state[:milestones_today] || [],
+                                       narrative:        nil
+                                     }
+                                   end
+                }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              def attachment_stats(**)
+                partner_id    = resolve_partner_id
+                partner_model = attachment_store.get(partner_id) if partner_id
+                {
+                  bonds_tracked: attachment_store.all_models.size,
+                  partner_bond:  partner_model&.to_h
+                }
+              end
+
+              private
+
+              def attachment_store
+                @attachment_store ||= Helpers::AttachmentStore.new
+              end
+
+              def collect_agent_ids(tick_results, human_observations)
+                ids = Set.new
+                (tick_results.dig(:social_cognition, :reputation_updates) || []).each do |u|
+                  ids << u[:agent_id].to_s if u[:agent_id]
+                end
+                human_observations.each { |o| ids << o[:agent_id].to_s if o[:agent_id] }
+                ids.to_a
+              end
+
+              def extract_signals(agent_id, tick_results, human_observations)
+                reputation = (tick_results.dig(:social_cognition, :reputation_updates) || [])
+                             .find { |u| u[:agent_id].to_s == agent_id }
+                prediction = tick_results.dig(:theory_of_mind, :prediction_accuracy) || {}
+                obs = human_observations.select { |o| o[:agent_id].to_s == agent_id }
+
+                direct_count = obs.count { |o| o[:direct_address] }
+                channels = obs.filter_map { |o| o[:channel] }.uniq
+
+                {
+                  frequency_score:      obs.size.clamp(0, 10) / 10.0,
+                  reciprocity_score:    (reputation&.dig(:composite) || 0.0).clamp(0.0, 1.0),
+                  prediction_accuracy:  (prediction[agent_id] || 0.0).clamp(0.0, 1.0),
+                  direct_address_ratio: obs.empty? ? 0.0 : (direct_count.to_f / obs.size).clamp(0.0, 1.0),
+                  channel_consistency:  channels.size <= 1 ? 1.0 : (1.0 / channels.size).clamp(0.0, 1.0)
+                }
+              end
+
+              def extract_style_signals(agent_id, human_observations)
+                obs = human_observations.select { |o| o[:agent_id].to_s == agent_id }
+                direct_count = obs.count { |o| o[:direct_address] }
+                {
+                  frequency_variance:    0.0,
+                  reciprocity_imbalance: 0.0,
+                  frequency:             obs.size.clamp(0, 10) / 10.0,
+                  direct_address_ratio:  obs.empty? ? 0.0 : direct_count.to_f / obs.size
+                }
+              end
+
+              def resolve_partner_id
+                if defined?(Legion::Gaia::BondRegistry)
+                  bond = Legion::Gaia::BondRegistry.all_bonds.find { |b| b[:role] == :partner }
+                  return bond&.dig(:identity)&.to_s
+                end
+
+                strongest = attachment_store.all_models.max_by(&:attachment_strength)
+                strongest&.agent_id
+              end
+
+              def apollo_local_store
+                return nil unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                Legion::Apollo::Local
+              end
+
+              def read_communication_patterns(store, partner_id)
+                return {} unless partner_id
+
+                result = store.query(text: 'communication_pattern',
+                                     tags: ['bond', 'communication_pattern', partner_id])
+                return {} unless result[:success] && result[:results]&.any?
+
+                deserialize(result[:results].first[:content]) || {}
+              rescue StandardError => _e
+                {}
+              end
+
+              def read_relationship_arc(store, partner_id)
+                return {} unless partner_id
+
+                result = store.query(text: 'relationship_arc',
+                                     tags: ['bond', 'relationship_arc', partner_id])
+                return {} unless result[:success] && result[:results]&.any?
+
+                deserialize(result[:results].first[:content]) || {}
+              rescue StandardError => _e
+                {}
+              end
+
+              def compute_relationship_health(model, comm_patterns, arc_state)
+                return 0.0 unless model
+
+                strength_component    = model.attachment_strength * 0.4
+                reciprocity_component = (arc_state[:reciprocity_balance] || 0.5) * 0.3
+                consistency_component = (comm_patterns[:consistency] || 0.5) * 0.3
+                (strength_component + reciprocity_component + consistency_component).clamp(0.0, 1.0)
+              end
+
+              def deserialize(content)
+                parsed = defined?(Legion::JSON) ? Legion::JSON.parse(content) : ::JSON.parse(content, symbolize_names: true)
+                parsed.is_a?(Hash) ? parsed.transform_keys(&:to_sym) : {}
+              rescue StandardError => _e
+                {}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Attachment
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/attachment.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'attachment/version'
+require_relative 'attachment/helpers/constants'
+require_relative 'attachment/helpers/attachment_model'
+require_relative 'attachment/helpers/attachment_store'
+require_relative 'attachment/runners/attachment'
+require_relative 'attachment/client'