lex-agentic-social 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a637b1280b8b3159e22384a36f90577406b8f3531189100d5d379cadd2dc00b
-  data.tar.gz: 16d221421b1212af948a0afffa6bb54e149087b13b4d473f1dcfe4cdd459ba27
+  metadata.gz: 9b5652d5875cf5aae7e51adf8b8b09f0e664a719144a7575ac9eb2f4bd7b7b56
+  data.tar.gz: 62101c073d3970708e278b2e7afd1dbbe3efc582eb03246bf19f975ad1999bd4
 SHA512:
-  metadata.gz: 94e0f0c04272c236d18011f3b8bb63798f06be346335bb0dcebac5472439f927817465d2f07bffa5c0633302c0d3bdb8b8a64bb7c30b3d7633a6b38e8cb52029
-  data.tar.gz: 5fbd869c1827ee00431b24d9ac317d001dfd4af19926a241f70f06cccad44656467585b6adea2499df1938524151dc096be4ceac3a784c34d52d8461fc744920
+  metadata.gz: 5e210bfd1a546461a34290e84e49a893cbb792c1d304b2087c759d2345a0cc30ac37c3f15760024ab19fdf83106f7cdefb87fa83c025100fd36852931f60c82f
+  data.tar.gz: 7a49e748bfc08d1c918c494f16d8ec4f579e63b3ec97120b532d168ffc9865e1748c9113025c0dfe7c9505c0f1aa3830624299e16926bc1b60be52187a71b0a5

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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

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'

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.7'
+        VERSION = '0.1.8'
       end
     end
   end

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

@@ -18,6 +18,7 @@ require_relative 'social/moral_reasoning'
 require_relative 'social/governance'
 require_relative 'social/joint_attention'
 require_relative 'social/mirror_system'
+require_relative 'social/attachment'
 
 module Legion
   module Extensions

data/spec/legion/extensions/agentic/social/attachment/helpers/attachment_model_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/social/attachment/helpers/constants'
+require 'legion/extensions/agentic/social/attachment/helpers/attachment_model'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentModel do
+  subject(:model) { described_class.new(agent_id: 'partner-1') }
+
+  describe '#initialize' do
+    it 'sets agent_id' do
+      expect(model.agent_id).to eq('partner-1')
+    end
+
+    it 'starts at initial stage' do
+      expect(model.bond_stage).to eq(:initial)
+    end
+
+    it 'starts with zero strength' do
+      expect(model.attachment_strength).to eq(0.0)
+    end
+
+    it 'starts with secure style' do
+      expect(model.attachment_style).to eq(:secure)
+    end
+
+    it 'starts with base separation tolerance' do
+      expect(model.separation_tolerance).to eq(3)
+    end
+
+    it 'starts with zero interaction count' do
+      expect(model.interaction_count).to eq(0)
+    end
+  end
+
+  describe '#update_from_signals' do
+    let(:signals) do
+      {
+        frequency_score:      0.6,
+        reciprocity_score:    0.5,
+        prediction_accuracy:  0.7,
+        direct_address_ratio: 0.4,
+        channel_consistency:  0.8
+      }
+    end
+
+    it 'computes attachment strength from weighted signals' do
+      model.update_from_signals(signals)
+      expected = (0.6 * 0.3) + (0.5 * 0.25) + (0.7 * 0.2) + (0.4 * 0.15) + (0.8 * 0.1)
+      expect(model.attachment_strength).to be_within(0.01).of(expected)
+    end
+
+    it 'increments interaction count' do
+      model.update_from_signals(signals)
+      expect(model.interaction_count).to eq(1)
+    end
+
+    it 'uses EMA for subsequent updates' do
+      model.update_from_signals(signals)
+      first_strength = model.attachment_strength
+      model.update_from_signals(signals.merge(frequency_score: 1.0))
+      expect(model.attachment_strength).not_to eq(first_strength)
+    end
+  end
+
+  describe '#update_stage!' do
+    it 'transitions to forming at 10 interactions and strength > 0.3' do
+      model.instance_variable_set(:@interaction_count, 10)
+      model.instance_variable_set(:@attachment_strength, 0.35)
+      model.update_stage!
+      expect(model.bond_stage).to eq(:forming)
+    end
+
+    it 'transitions to established at 50 interactions and strength > 0.5' do
+      model.instance_variable_set(:@interaction_count, 50)
+      model.instance_variable_set(:@attachment_strength, 0.55)
+      model.instance_variable_set(:@bond_stage, :forming)
+      model.update_stage!
+      expect(model.bond_stage).to eq(:established)
+    end
+
+    it 'transitions to deep at 200 interactions and strength > 0.7' do
+      model.instance_variable_set(:@interaction_count, 200)
+      model.instance_variable_set(:@attachment_strength, 0.75)
+      model.instance_variable_set(:@bond_stage, :established)
+      model.update_stage!
+      expect(model.bond_stage).to eq(:deep)
+    end
+
+    it 'never regresses stages' do
+      model.instance_variable_set(:@bond_stage, :established)
+      model.instance_variable_set(:@interaction_count, 5)
+      model.instance_variable_set(:@attachment_strength, 0.1)
+      model.update_stage!
+      expect(model.bond_stage).to eq(:established)
+    end
+
+    it 'updates separation tolerance on stage change' do
+      model.instance_variable_set(:@interaction_count, 50)
+      model.instance_variable_set(:@attachment_strength, 0.55)
+      model.instance_variable_set(:@bond_stage, :forming)
+      model.update_stage!
+      expect(model.separation_tolerance).to eq(3 + 2)
+    end
+  end
+
+  describe '#derive_style!' do
+    it 'defaults to secure' do
+      model.derive_style!(frequency_variance: 0.1, reciprocity_imbalance: 0.1,
+                          frequency: 0.5, direct_address_ratio: 0.5)
+      expect(model.attachment_style).to eq(:secure)
+    end
+
+    it 'detects anxious from high variance and imbalance' do
+      model.derive_style!(frequency_variance: 0.5, reciprocity_imbalance: 0.4,
+                          frequency: 0.5, direct_address_ratio: 0.5)
+      expect(model.attachment_style).to eq(:anxious)
+    end
+
+    it 'detects avoidant from low frequency and low direct address' do
+      model.derive_style!(frequency_variance: 0.1, reciprocity_imbalance: 0.1,
+                          frequency: 0.1, direct_address_ratio: 0.1)
+      expect(model.attachment_style).to eq(:avoidant)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete hash' do
+      h = model.to_h
+      expect(h).to include(:agent_id, :attachment_strength, :attachment_style,
+                           :bond_stage, :separation_tolerance, :interaction_count)
+    end
+  end
+
+  describe 'serialization' do
+    it 'round-trips through from_h' do
+      model.instance_variable_set(:@attachment_strength, 0.65)
+      model.instance_variable_set(:@bond_stage, :established)
+      model.instance_variable_set(:@interaction_count, 55)
+      restored = described_class.from_h(model.to_h)
+      expect(restored.to_h).to eq(model.to_h)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/attachment/helpers/attachment_store_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/social/attachment/helpers/constants'
+require 'legion/extensions/agentic/social/attachment/helpers/attachment_model'
+require 'legion/extensions/agentic/social/attachment/helpers/attachment_store'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentStore do
+  subject(:store) { described_class.new }
+
+  describe '#get' do
+    it 'returns nil for unknown agent' do
+      expect(store.get('unknown')).to be_nil
+    end
+  end
+
+  describe '#get_or_create' do
+    it 'creates a new model for unknown agent' do
+      model = store.get_or_create('agent-1')
+      expect(model).to be_a(Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentModel)
+      expect(model.agent_id).to eq('agent-1')
+    end
+
+    it 'returns existing model on second call' do
+      first  = store.get_or_create('agent-1')
+      second = store.get_or_create('agent-1')
+      expect(first).to equal(second)
+    end
+  end
+
+  describe '#dirty?' do
+    it 'starts clean' do
+      expect(store).not_to be_dirty
+    end
+
+    it 'becomes dirty after get_or_create' do
+      store.get_or_create('agent-1')
+      expect(store).to be_dirty
+    end
+  end
+
+  describe '#mark_clean!' do
+    it 'clears dirty flag' do
+      store.get_or_create('agent-1')
+      store.mark_clean!
+      expect(store).not_to be_dirty
+    end
+
+    it 'returns self for chaining' do
+      expect(store.mark_clean!).to eq(store)
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    before { store.get_or_create('partner-1') }
+
+    it 'returns an array of entry hashes' do
+      entries = store.to_apollo_entries
+      expect(entries).to be_an(Array)
+      expect(entries.size).to eq(1)
+    end
+
+    it 'includes content and tags' do
+      entry = store.to_apollo_entries.first
+      expect(entry).to have_key(:content)
+      expect(entry).to have_key(:tags)
+    end
+
+    it 'tags with bond, attachment, and agent_id' do
+      entry = store.to_apollo_entries.first
+      expect(entry[:tags]).to include('bond', 'attachment', 'partner-1')
+    end
+
+    it 'adds partner tag when BondRegistry says partner' do
+      bond_registry = class_double('Legion::Gaia::BondRegistry')
+      stub_const('Legion::Gaia::BondRegistry', bond_registry)
+      allow(bond_registry).to receive(:partner?).with('partner-1').and_return(true)
+      entry = store.to_apollo_entries.first
+      expect(entry[:tags]).to include('partner')
+    end
+  end
+
+  describe '#from_apollo' do
+    let(:mock_store) { double('apollo_local') }
+
+    it 'restores models from query results' do
+      model = Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentModel.new(agent_id: 'p1')
+      model.instance_variable_set(:@attachment_strength, 0.6)
+      model.instance_variable_set(:@bond_stage, :established)
+      content = Legion::JSON.dump(model.to_h) if defined?(Legion::JSON)
+      content ||= JSON.dump(model.to_h)
+
+      allow(mock_store).to receive(:query)
+        .with(text: 'bond attachment', tags: %w[bond attachment])
+        .and_return({ success: true, results: [{ content: content, tags: %w[bond attachment p1] }] })
+
+      result = store.from_apollo(store: mock_store)
+      expect(result).to be true
+      expect(store.get('p1')).not_to be_nil
+      expect(store.get('p1').attachment_strength).to eq(0.6)
+    end
+
+    it 'returns false on empty results' do
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [] })
+      expect(store.from_apollo(store: mock_store)).to be false
+    end
+
+    it 'returns false on error' do
+      allow(mock_store).to receive(:query).and_raise(StandardError, 'db error')
+      expect(store.from_apollo(store: mock_store)).to be false
+    end
+  end
+
+  describe '#all_models' do
+    it 'returns all tracked models' do
+      store.get_or_create('a1')
+      store.get_or_create('a2')
+      expect(store.all_models.size).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/attachment/helpers/constants_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/social/attachment/helpers/constants'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Helpers::Constants do
+  describe 'strength weights' do
+    it 'sums to 1.0' do
+      sum = described_class::FREQUENCY_WEIGHT +
+            described_class::RECIPROCITY_WEIGHT +
+            described_class::PREDICTION_ACCURACY_WEIGHT +
+            described_class::DIRECT_ADDRESS_WEIGHT +
+            described_class::CHANNEL_CONSISTENCY_WEIGHT
+      expect(sum).to eq(1.0)
+    end
+  end
+
+  describe 'BOND_STAGES' do
+    it 'defines 4 stages in order' do
+      expect(described_class::BOND_STAGES).to eq(%i[initial forming established deep])
+    end
+  end
+
+  describe 'ATTACHMENT_STYLES' do
+    it 'defines 3 styles' do
+      expect(described_class::ATTACHMENT_STYLES).to eq(%i[secure anxious avoidant])
+    end
+  end
+
+  describe 'stage thresholds' do
+    it 'has forming thresholds' do
+      expect(described_class::STAGE_THRESHOLDS[:forming]).to eq({ interactions: 10, strength: 0.3 })
+    end
+
+    it 'has established thresholds' do
+      expect(described_class::STAGE_THRESHOLDS[:established]).to eq({ interactions: 50, strength: 0.5 })
+    end
+
+    it 'has deep thresholds' do
+      expect(described_class::STAGE_THRESHOLDS[:deep]).to eq({ interactions: 200, strength: 0.7 })
+    end
+  end
+
+  describe 'SEPARATION_TOLERANCE' do
+    it 'starts at 3' do
+      expect(described_class::BASE_SEPARATION_TOLERANCE).to eq(3)
+    end
+
+    it 'grows with stage' do
+      expect(described_class::SEPARATION_TOLERANCE_GROWTH[:deep]).to be > described_class::SEPARATION_TOLERANCE_GROWTH[:initial]
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/attachment/runners/attachment_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/social/attachment/helpers/constants'
+require 'legion/extensions/agentic/social/attachment/helpers/attachment_model'
+require 'legion/extensions/agentic/social/attachment/helpers/attachment_store'
+require 'legion/extensions/agentic/social/attachment/runners/attachment'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Runners::Attachment do
+  let(:host) { Object.new.extend(described_class) }
+
+  before do
+    # Reset memoized store between specs
+    host.instance_variable_set(:@attachment_store, nil)
+  end
+
+  describe '#update_attachment' do
+    let(:tick_results) do
+      {
+        social_cognition: {
+          reputation_updates:      [
+            { agent_id: 'partner-1', composite: 0.6 }
+          ],
+          reciprocity_ledger_size: 10
+        },
+        theory_of_mind:   {
+          prediction_accuracy: { 'partner-1' => 0.7 }
+        }
+      }
+    end
+
+    let(:human_observations) do
+      [
+        { agent_id: 'partner-1', direct_address: true, channel: 'teams' },
+        { agent_id: 'partner-1', direct_address: false, channel: 'teams' },
+        { agent_id: 'partner-1', direct_address: true, channel: 'cli' }
+      ]
+    end
+
+    it 'returns a result hash' do
+      result = host.update_attachment(tick_results: tick_results, human_observations: human_observations)
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:agents_updated)
+    end
+
+    it 'creates a model for observed agents' do
+      host.update_attachment(tick_results: tick_results, human_observations: human_observations)
+      store = host.send(:attachment_store)
+      expect(store.get('partner-1')).not_to be_nil
+    end
+
+    it 'updates attachment strength' do
+      host.update_attachment(tick_results: tick_results, human_observations: human_observations)
+      model = host.send(:attachment_store).get('partner-1')
+      expect(model.attachment_strength).to be > 0.0
+    end
+
+    it 'marks store dirty' do
+      host.update_attachment(tick_results: tick_results, human_observations: human_observations)
+      expect(host.send(:attachment_store)).to be_dirty
+    end
+
+    it 'handles empty tick results' do
+      result = host.update_attachment(tick_results: {}, human_observations: [])
+      expect(result[:agents_updated]).to eq(0)
+    end
+  end
+
+  describe '#reflect_on_bonds' do
+    let(:mock_store) { double('apollo_local') }
+
+    before do
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [] })
+
+      store = host.send(:attachment_store)
+      model = store.get_or_create('partner-1')
+      model.update_from_signals(frequency_score: 0.6, reciprocity_score: 0.5,
+                                prediction_accuracy: 0.7, direct_address_ratio: 0.4,
+                                channel_consistency: 0.8)
+      model.instance_variable_set(:@interaction_count, 55)
+      model.instance_variable_set(:@bond_stage, :established)
+    end
+
+    it 'returns bond reflection result' do
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(result).to have_key(:bonds_reflected)
+      expect(result).to have_key(:partner_bond)
+    end
+
+    it 'includes partner bond state' do
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      bond = result[:partner_bond]
+      expect(bond[:stage]).to eq(:established)
+      expect(bond[:strength]).to be > 0.0
+    end
+
+    it 'reads communication patterns from Apollo Local' do
+      host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(mock_store).to have_received(:query)
+        .with(hash_including(tags: array_including('bond', 'communication_pattern')))
+    end
+
+    it 'reads relationship arc from Apollo Local' do
+      host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(mock_store).to have_received(:query)
+        .with(hash_including(tags: array_including('bond', 'relationship_arc')))
+    end
+
+    it 'returns error when no store available' do
+      allow(host).to receive(:apollo_local_store).and_return(nil)
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(result[:success]).to be false
+    end
+
+    it 'computes relationship health' do
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(result[:partner_bond][:health]).to be_a(Float)
+      expect(result[:partner_bond][:health]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#attachment_stats' do
+    it 'returns stats hash' do
+      result = host.attachment_stats
+      expect(result).to have_key(:bonds_tracked)
+      expect(result).to have_key(:partner_bond)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-social
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Esity
@@ -125,44 +125,44 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.60'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.60'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-legion
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '0'
 description: 'LEX agentic social domain: empathy, social cognition, theory of mind'
 email:
 - matthewdiverson@gmail.com
@@ -183,6 +183,13 @@ files:
 - lib/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_model.rb
 - lib/legion/extensions/agentic/social/apprenticeship/runners/cognitive_apprenticeship.rb
 - lib/legion/extensions/agentic/social/apprenticeship/version.rb
+- lib/legion/extensions/agentic/social/attachment.rb
+- lib/legion/extensions/agentic/social/attachment/client.rb
+- lib/legion/extensions/agentic/social/attachment/helpers/attachment_model.rb
+- lib/legion/extensions/agentic/social/attachment/helpers/attachment_store.rb
+- lib/legion/extensions/agentic/social/attachment/helpers/constants.rb
+- lib/legion/extensions/agentic/social/attachment/runners/attachment.rb
+- lib/legion/extensions/agentic/social/attachment/version.rb
 - lib/legion/extensions/agentic/social/conflict.rb
 - lib/legion/extensions/agentic/social/conflict/actors/stale_check.rb
 - lib/legion/extensions/agentic/social/conflict/client.rb
@@ -317,6 +324,10 @@ files:
 - spec/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_model_spec.rb
 - spec/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_spec.rb
 - spec/legion/extensions/agentic/social/apprenticeship/runners/cognitive_apprenticeship_spec.rb
+- spec/legion/extensions/agentic/social/attachment/helpers/attachment_model_spec.rb
+- spec/legion/extensions/agentic/social/attachment/helpers/attachment_store_spec.rb
+- spec/legion/extensions/agentic/social/attachment/helpers/constants_spec.rb
+- spec/legion/extensions/agentic/social/attachment/runners/attachment_spec.rb
 - spec/legion/extensions/agentic/social/conflict/actors/stale_check_spec.rb
 - spec/legion/extensions/agentic/social/conflict/client_spec.rb
 - spec/legion/extensions/agentic/social/conflict/helpers/conflict_log_spec.rb