lex-agentic-self 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 478de6acedf6c72ba3a5c715bc57f3124505486720b473b2db536d4abe48c58c
-  data.tar.gz: 8846a168b7d882d7e981a3d87eb87565e25b10ac24530221748382fdda1128cb
+  metadata.gz: aa196a32fb12a9051c899a77c904db1b019bcf20fa722522f4560aa06325c1c5
+  data.tar.gz: 21ea04fbbd1a0bb7ccbaf1baeb93c062c036818cecd316f907d82ba4607fc640
 SHA512:
-  metadata.gz: 20df44e864e415b127e1f26a0d28bb0ed19c6589b53a40afbace9587c1166be962b6b8305e74c7ad4d4ea6b41eb9091f90328cbc3e23c3ab44ab9172cced706f
-  data.tar.gz: c768c0cc1794a6502e37d2c6524feaec104c8d47116e654f7d5dd19330768130212516cc074011b97b4e8e97f21c33931242e4cebf9ce0fba92064919bf7396d
+  metadata.gz: 2e5f6191d0093ad34c915a5368d71b1457f9774e393fff5f9d0424784ca38c250ce3c3ae3c3be6c0fc4c9b4a43ac8b2148bd3917b3ed37e102181aa2beae1e1a
+  data.tar.gz: 2bc178f3bfc1001ccc64af277a3e9fac685fea350964107883b6d001a4fe8da31fd3287b18e3a4b6838bd293798737c1c8eeb9fac3c77d44010be734e97279d0

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.1.11] - 2026-03-31
+
+### Fixed
+- `ArcEngine#to_h` now returns the last computed `relationship_health` score instead of always nil; `relationship_health()` caches result in `@last_health`
+- `ArcEngine#arc_state_hash` now includes `milestones_today` key (milestones with `created_at` matching today in local time)
+- `SelfTalk::Runners::SelfTalk#stub_turn_content` replaced by `mechanical_turn_content` backed by `VOICE_BANK` — produces real, meaningful content for critic/advocate/explorer/pragmatist voices; unknown types fall back to `VOICE_BANK_GENERIC`
+- `SelfTalk::Runners::SelfTalk#generate_summary_for_dialogue` replaces static "Dialogue concluded" fallback with `mechanical_summary` — includes turn count, voices, and dominant position
+- `Identity::Runners::Entra#rotate_client_secret` now emits a `Legion::Logging.warn` when `rotation_enabled: true` but Graph API rotation is not yet implemented, and returns `action_required` with instructions instead of a silent error
+
+## [0.1.10] - 2026-03-31
+
+### Added
+- RelationshipArc sub-module for Phase C relational intelligence
+- Constants: chapters, milestone types, health weights, chapter thresholds
+- Milestone: typed data class with UUID, significance clamping, serialization
+- ArcEngine: chapter progression, milestone tracking, relationship health, Apollo Local persistence
+- RelationshipArc runner: record_milestone, update_arc, arc_stats with NarrativeIdentity episode stamping
+
 ## [0.1.9] - 2026-03-31
 
 ### Added

data/Gemfile

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

data/lex-agentic-self.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'faraday', '~> 2.0'
   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/self/identity/runners/entra.rb

@@ -293,8 +293,11 @@ module Legion
 
                 return { rotated: false, worker_id: worker_id, dry_run: true, would_rotate: true } if dry_run
 
-                # Graph API rotation would go here when permission is granted
-                { rotated: false, worker_id: worker_id, error: 'graph_api_rotation_not_implemented' }
+                # Graph API rotation is blocked on Azure Application.ReadWrite.All permission.
+                # Emit a loud warning so callers are never silently misled.
+                Legion::Logging.warn "[identity:entra] Client secret rotation is enabled but Graph API rotation is not yet implemented. Worker: #{worker_id}"
+                { rotated: false, worker_id: worker_id, error: 'graph_api_rotation_not_implemented',
+                  action_required: 'Manual rotation needed — Graph API write permission not yet granted' }
               end
 
               def credential_refresh_cycle(**)

data/lib/legion/extensions/agentic/self/relationship_arc/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/relationship_arc/helpers/constants'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/milestone'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/arc_engine'
+require 'legion/extensions/agentic/self/relationship_arc/runners/relationship_arc'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+          class Client
+            include Runners::RelationshipArc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/relationship_arc/helpers/arc_engine.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+          module Helpers
+            class ArcEngine
+              attr_reader :agent_id, :current_chapter, :milestones
+
+              BOND_STAGE_ORDER = %i[initial forming established deep].freeze
+              private_constant :BOND_STAGE_ORDER
+
+              def initialize(agent_id:)
+                @agent_id        = agent_id
+                @current_chapter = :formative
+                @milestones      = []
+                @dirty           = false
+              end
+
+              def add_milestone(type:, description:, significance:, **)
+                ms = Milestone.new(type: type, description: description, significance: significance)
+                @milestones << ms
+                @milestones.shift while @milestones.size > Constants::MAX_MILESTONES
+                @dirty = true
+                ms
+              end
+
+              def update_chapter!(bond_stage: :initial, **)
+                new_chapter = derive_chapter(bond_stage)
+                return if Constants::CHAPTERS.index(new_chapter) <= Constants::CHAPTERS.index(@current_chapter)
+
+                @current_chapter = new_chapter
+                @dirty = true
+              end
+
+              def relationship_health(attachment_strength: 0.0, reciprocity_balance: 0.5,
+                                      communication_consistency: 0.5, **)
+                w = Constants::HEALTH_WEIGHTS
+                score = (attachment_strength.to_f * w[:attachment_strength]) +
+                        (reciprocity_balance.to_f * w[:reciprocity_balance]) +
+                        (communication_consistency.to_f * w[:communication_consistency])
+                @last_health = score.clamp(0.0, 1.0)
+              end
+
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+                self
+              end
+
+              def to_apollo_entries
+                tags = Constants::TAG_PREFIX.dup + [@agent_id]
+                tags << 'partner' if partner?(@agent_id)
+                [{ content: serialize(arc_state_hash), tags: tags }]
+              end
+
+              def from_apollo(store:)
+                result = store.query(text: 'relationship_arc', tags: Constants::TAG_PREFIX + [@agent_id])
+                return false unless result[:success] && result[:results]&.any?
+
+                parsed = deserialize(result[:results].first[:content])
+                return false unless parsed
+
+                @current_chapter = parsed[:current_chapter]&.to_sym || :formative
+                @milestones = (parsed[:milestones] || []).map { |mh| Milestone.from_h(mh.transform_keys(&:to_sym)) }
+                true
+              rescue StandardError => e
+                warn "[arc_engine] from_apollo error: #{e.message}"
+                false
+              end
+
+              def to_h
+                { agent_id: @agent_id, current_chapter: @current_chapter,
+                  milestones: @milestones.map(&:to_h),
+                  relationship_health: @last_health, milestone_count: @milestones.size }
+              end
+
+              private
+
+              def arc_state_hash
+                { agent_id: @agent_id, current_chapter: @current_chapter,
+                  milestones: @milestones.map(&:to_h),
+                  milestones_today: @milestones.select { |m| milestone_today?(m) }.map(&:to_h) }
+              end
+
+              def milestone_today?(milestone)
+                ts = milestone.respond_to?(:created_at) ? milestone.created_at : milestone[:created_at]
+                return false unless ts
+
+                today = ::Time.now
+                t = ts.is_a?(::Time) ? ts.localtime : ::Time.parse(ts.to_s)
+                t.year == today.year && t.mon == today.mon && t.mday == today.mday
+              rescue StandardError => e
+                warn "[arc_engine] milestone_today? error: #{e.message}"
+                false
+              end
+
+              def derive_chapter(bond_stage)
+                Constants::CHAPTER_THRESHOLDS.each_key.reverse_each do |chapter|
+                  threshold = Constants::CHAPTER_THRESHOLDS[chapter]
+                  stage_idx = BOND_STAGE_ORDER.index(threshold[:stage]) || 0
+                  current_stage_idx = BOND_STAGE_ORDER.index(bond_stage) || 0
+
+                  return chapter if @milestones.size >= threshold[:milestones] &&
+                                    current_stage_idx >= stage_idx
+                end
+                :formative
+              end
+
+              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.is_a?(Hash) ? parsed.transform_keys(&:to_sym) : nil
+              rescue StandardError => _e
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/relationship_arc/helpers/constants.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+          module Helpers
+            module Constants
+              CHAPTERS = %i[formative developing established deepening].freeze
+
+              MILESTONE_TYPES = %i[
+                first_interaction first_direct_address stage_transition
+                prediction_accuracy communication_shift absence_return
+              ].freeze
+
+              HEALTH_WEIGHTS = {
+                attachment_strength:       0.4,
+                reciprocity_balance:       0.3,
+                communication_consistency: 0.3
+              }.freeze
+
+              MAX_MILESTONES = 200
+
+              CHAPTER_THRESHOLDS = {
+                developing:  { milestones: 3,  stage: :forming },
+                established: { milestones: 10, stage: :established },
+                deepening:   { milestones: 25, stage: :deep }
+              }.freeze
+
+              TAG_PREFIX = %w[bond relationship_arc].freeze
+              MILESTONE_TAG_PREFIX = %w[bond milestone].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/relationship_arc/helpers/milestone.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+          module Helpers
+            class Milestone
+              attr_reader :id, :type, :description, :significance, :created_at
+
+              def initialize(type:, description:, significance:, id: nil, created_at: nil)
+                @id           = id || SecureRandom.uuid
+                @type         = type.to_sym
+                @description  = description
+                @significance = significance.to_f.clamp(0.0, 1.0)
+                @created_at   = created_at || Time.now.utc
+              end
+
+              def to_h
+                { id: @id, type: @type, description: @description,
+                  significance: @significance, created_at: @created_at.iso8601 }
+              end
+
+              def self.from_h(hash)
+                new(
+                  id:           hash[:id],
+                  type:         hash[:type],
+                  description:  hash[:description],
+                  significance: hash[:significance],
+                  created_at:   hash[:created_at] ? Time.parse(hash[:created_at].to_s) : nil
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/relationship_arc/runners/relationship_arc.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+          module Runners
+            module RelationshipArc
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+
+              def record_milestone(agent_id:, type:, description:, significance:, **)
+                unless Helpers::Constants::MILESTONE_TYPES.include?(type.to_sym)
+                  return { success: false,
+                           error:   "unknown type: #{type}" }
+                end
+
+                engine = arc_engine_for(agent_id)
+                ms = engine.add_milestone(type: type, description: description, significance: significance)
+
+                stamp_narrative_episode(ms)
+
+                { success: true, milestone: ms.to_h }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              def update_arc(agent_id:, attachment_state: {}, **)
+                engine = arc_engine_for(agent_id)
+                engine.update_chapter!(bond_stage: attachment_state[:bond_stage] || :initial)
+
+                { success: true, current_chapter: engine.current_chapter,
+                  milestone_count: engine.milestones.size }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              def arc_stats(agent_id:, **)
+                engine = arc_engine_for(agent_id)
+                engine.to_h
+              end
+
+              private
+
+              def arc_engine_for(agent_id)
+                @arc_engines ||= {}
+                @arc_engines[agent_id.to_s] ||= Helpers::ArcEngine.new(agent_id: agent_id.to_s)
+              end
+
+              def stamp_narrative_episode(milestone)
+                narrator = resolve_narrative_identity
+                return unless narrator
+
+                narrator.record_episode(
+                  content:           milestone.description,
+                  episode_type:      :relationship,
+                  emotional_valence: 0.3,
+                  significance:      milestone.significance,
+                  domain:            :relationship,
+                  tags:              ['partner', 'milestone', milestone.type.to_s]
+                )
+              rescue StandardError => e
+                warn "[relationship_arc] narrative stamp failed: #{e.message}"
+              end
+
+              def resolve_narrative_identity
+                return nil unless defined?(Legion::Extensions::Agentic::Self::NarrativeIdentity::Client)
+
+                @narrative_client ||= Legion::Extensions::Agentic::Self::NarrativeIdentity::Client.new
+              rescue StandardError => _e
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/relationship_arc/version.rb

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

data/lib/legion/extensions/agentic/self/relationship_arc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'relationship_arc/version'
+require_relative 'relationship_arc/helpers/constants'
+require_relative 'relationship_arc/helpers/milestone'
+require_relative 'relationship_arc/helpers/arc_engine'
+require_relative 'relationship_arc/runners/relationship_arc'
+require_relative 'relationship_arc/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Self
+        module RelationshipArc
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/self/self_talk/runners/self_talk.rb

@@ -104,6 +104,35 @@ module Legion
                 { decayed: decayed, voices: voice_list }
               end
 
+              VOICE_BANK = {
+                critic:     [
+                  { content: 'What could go wrong with this approach?', position: :challenge },
+                  { content: 'Are we overlooking any risks here?', position: :challenge },
+                  { content: 'This needs more careful consideration.', position: :caution }
+                ],
+                advocate:   [
+                  { content: 'This aligns with our core values.', position: :support },
+                  { content: 'The potential benefits outweigh the risks.', position: :support },
+                  { content: 'We should move forward with this.', position: :affirm }
+                ],
+                explorer:   [
+                  { content: 'What alternatives have we not considered?', position: :explore },
+                  { content: 'There may be an unconventional approach here.', position: :explore },
+                  { content: 'Let us examine this from another angle.', position: :clarify }
+                ],
+                pragmatist: [
+                  { content: 'What is the simplest path forward?', position: :simplify },
+                  { content: 'Focus on what is actionable now.', position: :prioritize },
+                  { content: 'We need concrete next steps.', position: :clarify }
+                ]
+              }.freeze
+
+              VOICE_BANK_GENERIC = [
+                { content: 'Let us think this through carefully.', position: :clarify },
+                { content: 'More reflection is needed on this topic.', position: :clarify },
+                { content: 'What do we know for certain here?', position: :clarify }
+              ].freeze
+
               private
 
               def engine
@@ -124,7 +153,7 @@ module Legion
                   )
                   return [llm_result, :llm] if llm_result
                 end
-                [stub_turn_content(voice_data.voice_type, dialogue_data.topic), :mechanical]
+                [mechanical_turn_content(voice_data.voice_type, dialogue_data.topic), :mechanical]
               end
 
               def build_prior_turns(dialogue_data)
@@ -135,13 +164,14 @@ module Legion
                 end
               end
 
-              def stub_turn_content(voice_type, topic)
-                { content: "[#{voice_type} perspective on #{topic}]", position: :clarify }
+              def mechanical_turn_content(voice_type, _topic)
+                bank = VOICE_BANK.fetch(voice_type.to_sym, VOICE_BANK_GENERIC)
+                bank.sample
               end
 
               def generate_summary_for_dialogue(dialogue_id)
                 dialogue_data = engine.dialogues[dialogue_id]
-                return 'Dialogue concluded' unless dialogue_data
+                return mechanical_summary(nil) unless dialogue_data
 
                 if Helpers::LlmEnhancer.available?
                   turns = dialogue_data.turns.map do |t|
@@ -161,7 +191,15 @@ module Legion
                   return llm_result[:summary] if llm_result
                 end
 
-                'Dialogue concluded'
+                mechanical_summary(dialogue_data)
+              end
+
+              def mechanical_summary(dialogue_data)
+                turns = dialogue_data&.turns || []
+                voices = turns.filter_map { |t| t.respond_to?(:voice_id) ? engine.voices[t.voice_id]&.name || t.voice_id : t[:voice_id] }.uniq
+                positions = turns.filter_map { |t| t.respond_to?(:position) ? t.position : t[:position] }.tally
+                dominant = positions.max_by { |_, count| count }&.first
+                "#{turns.size} turns across #{voices.join(', ')} voices. Dominant position: #{dominant || 'none'}."
               end
             end
           end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Self
-        VERSION = '0.1.9'
+        VERSION = '0.1.11'
       end
     end
   end

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

@@ -17,6 +17,7 @@ require_relative 'self/agency'
 require_relative 'self/reflection'
 require_relative 'self/anosognosia'
 require_relative 'self/default_mode_network'
+require_relative 'self/relationship_arc'
 
 module Legion
   module Extensions

data/spec/legion/extensions/agentic/self/identity/runners/entra_spec.rb

@@ -338,6 +338,59 @@ RSpec.describe Legion::Extensions::Agentic::Self::Identity::Runners::Entra do
       expect(result[:action_required]).to be false
       expect(result[:days_remaining]).to be > 30
     end
+
+    context 'when rotation_enabled is true and secret is expiring (fix 5)' do
+      before do
+        stub_const('Legion::Settings', Class.new do
+          def self.dig(*keys)
+            map = {
+              %i[identity entra rotation_enabled]     => true,
+              %i[identity entra rotation_buffer_days] => 30
+            }
+            map[keys]
+          end
+
+          def self.[](_key) = {}
+        end)
+      end
+
+      it 'emits a warning log when graph api rotation is not implemented' do
+        vault_mod = Module.new do
+          def self.read_client_secret(**)
+            { client_secret: 'val', client_secret_expires_at: (Time.now + (86_400 * 10)).iso8601 }
+          end
+        end
+        stub_const('Legion::Extensions::Agentic::Self::Identity::Helpers::VaultSecrets', vault_mod)
+
+        warned = false
+        allow(Legion::Logging).to receive(:warn) do |msg|
+          warned = true if msg.include?('graph_api_rotation_not_implemented') ||
+                           msg.include?('Graph API rotation is not yet implemented')
+        end
+
+        result = client.rotate_client_secret(worker_id: 'w1')
+
+        expect(warned).to be true
+        expect(result[:rotated]).to be false
+        expect(result[:error]).to eq('graph_api_rotation_not_implemented')
+        expect(result[:action_required]).to include('Manual rotation needed')
+      end
+
+      it 'returns dry_run result without warning when dry_run: true' do
+        vault_mod = Module.new do
+          def self.read_client_secret(**)
+            { client_secret: 'val', client_secret_expires_at: (Time.now + (86_400 * 10)).iso8601 }
+          end
+        end
+        stub_const('Legion::Extensions::Agentic::Self::Identity::Helpers::VaultSecrets', vault_mod)
+
+        expect(Legion::Logging).not_to receive(:warn).with(a_string_including('not yet implemented'))
+
+        result = client.rotate_client_secret(worker_id: 'w1', dry_run: true)
+        expect(result[:dry_run]).to be true
+        expect(result[:would_rotate]).to be true
+      end
+    end
   end
 
   # ---------------------------------------------------------------------------

data/spec/legion/extensions/agentic/self/relationship_arc/helpers/arc_engine_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/constants'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/milestone'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/arc_engine'
+
+RSpec.describe Legion::Extensions::Agentic::Self::RelationshipArc::Helpers::ArcEngine do
+  subject(:engine) { described_class.new(agent_id: 'partner-1') }
+
+  describe '#initialize' do
+    it 'starts in formative chapter' do
+      expect(engine.current_chapter).to eq(:formative)
+    end
+
+    it 'starts with empty milestones' do
+      expect(engine.milestones).to be_empty
+    end
+  end
+
+  describe '#add_milestone' do
+    it 'adds a milestone' do
+      engine.add_milestone(type: :first_interaction, description: 'Hello', significance: 0.8)
+      expect(engine.milestones.size).to eq(1)
+    end
+
+    it 'returns the milestone' do
+      ms = engine.add_milestone(type: :first_interaction, description: 'Hello', significance: 0.8)
+      expect(ms).to be_a(Legion::Extensions::Agentic::Self::RelationshipArc::Helpers::Milestone)
+    end
+
+    it 'marks dirty' do
+      engine.add_milestone(type: :first_interaction, description: 'Hello', significance: 0.8)
+      expect(engine).to be_dirty
+    end
+
+    it 'caps at MAX_MILESTONES' do
+      201.times { |i| engine.add_milestone(type: :first_interaction, description: "ms #{i}", significance: 0.1) }
+      expect(engine.milestones.size).to eq(200)
+    end
+  end
+
+  describe '#update_chapter!' do
+    it 'transitions to developing after enough milestones' do
+      4.times { engine.add_milestone(type: :first_interaction, description: 'x', significance: 0.5) }
+      engine.update_chapter!(bond_stage: :forming)
+      expect(engine.current_chapter).to eq(:developing)
+    end
+
+    it 'never regresses' do
+      engine.instance_variable_set(:@current_chapter, :established)
+      engine.update_chapter!(bond_stage: :initial)
+      expect(engine.current_chapter).to eq(:established)
+    end
+  end
+
+  describe '#relationship_health' do
+    it 'computes weighted health score' do
+      health = engine.relationship_health(
+        attachment_strength:       0.8,
+        reciprocity_balance:       0.6,
+        communication_consistency: 0.7
+      )
+      expected = (0.8 * 0.4) + (0.6 * 0.3) + (0.7 * 0.3)
+      expect(health).to be_within(0.01).of(expected)
+    end
+
+    it 'clamps to 0.0..1.0' do
+      health = engine.relationship_health(
+        attachment_strength:       1.5,
+        reciprocity_balance:       1.5,
+        communication_consistency: 1.5
+      )
+      expect(health).to eq(1.0)
+    end
+  end
+
+  describe '#dirty? and #mark_clean!' do
+    it 'starts clean' do
+      expect(engine).not_to be_dirty
+    end
+
+    it 'cleans up' do
+      engine.add_milestone(type: :first_interaction, description: 'x', significance: 0.5)
+      engine.mark_clean!
+      expect(engine).not_to be_dirty
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    before { engine.add_milestone(type: :first_interaction, description: 'Hello', significance: 0.8) }
+
+    it 'returns entries with arc state' do
+      entries = engine.to_apollo_entries
+      expect(entries).to be_an(Array)
+      expect(entries.first[:tags]).to include('bond', 'relationship_arc', 'partner-1')
+    end
+  end
+
+  describe '#from_apollo' do
+    let(:mock_store) { double('apollo_local') }
+
+    it 'restores state from Apollo' do
+      engine.add_milestone(type: :first_interaction, description: 'Hello', significance: 0.8)
+      engine.instance_variable_set(:@current_chapter, :developing)
+      content = engine.send(:serialize, engine.send(:arc_state_hash))
+
+      new_engine = described_class.new(agent_id: 'partner-1')
+      allow(mock_store).to receive(:query)
+        .and_return({ success: true, results: [{ content: content, tags: %w[bond relationship_arc partner-1] }] })
+
+      expect(new_engine.from_apollo(store: mock_store)).to be true
+      expect(new_engine.current_chapter).to eq(:developing)
+      expect(new_engine.milestones.size).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      h = engine.to_h
+      expect(h).to include(:agent_id, :current_chapter, :milestones, :relationship_health)
+    end
+
+    it 'relationship_health is nil before relationship_health() is called' do
+      expect(engine.to_h[:relationship_health]).to be_nil
+    end
+
+    it 'relationship_health reflects the last computed value' do
+      engine.relationship_health(
+        attachment_strength:       0.8,
+        reciprocity_balance:       0.6,
+        communication_consistency: 0.7
+      )
+      h = engine.to_h
+      expected = (0.8 * 0.4) + (0.6 * 0.3) + (0.7 * 0.3)
+      expect(h[:relationship_health]).to be_within(0.01).of(expected)
+    end
+
+    it 'includes milestone_count' do
+      engine.add_milestone(type: :first_interaction, description: 'x', significance: 0.5)
+      expect(engine.to_h[:milestone_count]).to eq(1)
+    end
+  end
+
+  describe '#arc_state_hash (via to_apollo_entries)' do
+    it 'includes milestones_today for milestones added today' do
+      engine.add_milestone(type: :first_interaction, description: 'today', significance: 0.9)
+      entries = engine.to_apollo_entries
+      parsed = JSON.parse(entries.first[:content], symbolize_names: true)
+      expect(parsed).to have_key(:milestones_today)
+      expect(parsed[:milestones_today].size).to eq(1)
+    end
+
+    it 'milestones_today is empty when milestones have old timestamps' do
+      ms = Legion::Extensions::Agentic::Self::RelationshipArc::Helpers::Milestone.new(
+        type: :first_interaction, description: 'old', significance: 0.5,
+        created_at: Time.now.utc - (2 * 86_400)
+      )
+      engine.instance_variable_get(:@milestones) << ms
+      entries = engine.to_apollo_entries
+      parsed = JSON.parse(entries.first[:content], symbolize_names: true)
+      expect(parsed[:milestones_today]).to eq([])
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/relationship_arc/helpers/constants_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/constants'
+
+RSpec.describe Legion::Extensions::Agentic::Self::RelationshipArc::Helpers::Constants do
+  describe 'CHAPTERS' do
+    it 'defines 4 chapters in order' do
+      expect(described_class::CHAPTERS).to eq(%i[formative developing established deepening])
+    end
+  end
+
+  describe 'MILESTONE_TYPES' do
+    it 'includes expected types' do
+      expect(described_class::MILESTONE_TYPES).to include(:first_interaction, :stage_transition,
+                                                          :prediction_accuracy, :absence_return)
+    end
+  end
+
+  describe 'HEALTH_WEIGHTS' do
+    it 'sums to 1.0' do
+      expect(described_class::HEALTH_WEIGHTS.values.sum).to eq(1.0)
+    end
+  end
+
+  describe 'MAX_MILESTONES' do
+    it 'caps at 200' do
+      expect(described_class::MAX_MILESTONES).to eq(200)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/relationship_arc/helpers/milestone_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/constants'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/milestone'
+
+RSpec.describe Legion::Extensions::Agentic::Self::RelationshipArc::Helpers::Milestone do
+  subject(:milestone) do
+    described_class.new(type: :first_interaction, description: 'First hello', significance: 0.8)
+  end
+
+  describe '#initialize' do
+    it 'sets type' do
+      expect(milestone.type).to eq(:first_interaction)
+    end
+
+    it 'generates a UUID' do
+      expect(milestone.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'clamps significance to 0.0..1.0' do
+      ms = described_class.new(type: :first_interaction, description: 'test', significance: 1.5)
+      expect(ms.significance).to eq(1.0)
+    end
+
+    it 'records timestamp' do
+      expect(milestone.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete hash' do
+      h = milestone.to_h
+      expect(h).to include(:id, :type, :description, :significance, :created_at)
+    end
+  end
+
+  describe '.from_h' do
+    it 'round-trips' do
+      restored = described_class.from_h(milestone.to_h)
+      expect(restored.type).to eq(milestone.type)
+      expect(restored.description).to eq(milestone.description)
+      expect(restored.significance).to eq(milestone.significance)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/relationship_arc/runners/relationship_arc_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/constants'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/milestone'
+require 'legion/extensions/agentic/self/relationship_arc/helpers/arc_engine'
+require 'legion/extensions/agentic/self/relationship_arc/runners/relationship_arc'
+
+RSpec.describe Legion::Extensions::Agentic::Self::RelationshipArc::Runners::RelationshipArc do
+  let(:described_module) { described_class }
+  let(:host) { Object.new.extend(described_module) }
+
+  before { host.instance_variable_set(:@arc_engines, nil) }
+
+  describe '#record_milestone' do
+    it 'records a milestone for an agent' do
+      result = host.record_milestone(agent_id: 'p1', type: :first_interaction,
+                                     description: 'Hello', significance: 0.8)
+      expect(result[:success]).to be true
+      expect(result[:milestone][:type]).to eq(:first_interaction)
+    end
+
+    it 'returns error for unknown type' do
+      result = host.record_milestone(agent_id: 'p1', type: :bogus,
+                                     description: 'x', significance: 0.5)
+      expect(result[:success]).to be false
+    end
+
+    it 'calls NarrativeIdentity record_episode when available' do
+      narrator = double('narrator')
+      allow(host).to receive(:resolve_narrative_identity).and_return(narrator)
+      allow(narrator).to receive(:record_episode).and_return({ success: true })
+
+      host.record_milestone(agent_id: 'p1', type: :first_interaction,
+                            description: 'Hello', significance: 0.8)
+      expect(narrator).to have_received(:record_episode)
+        .with(hash_including(episode_type: :relationship, significance: 0.8))
+    end
+  end
+
+  describe '#update_arc' do
+    it 'updates chapter based on attachment state' do
+      3.times do
+        host.record_milestone(agent_id: 'p1', type: :first_interaction,
+                              description: 'x', significance: 0.5)
+      end
+      result = host.update_arc(agent_id: 'p1', attachment_state: { bond_stage: :forming })
+      expect(result[:success]).to be true
+    end
+
+    it 'returns arc summary' do
+      result = host.update_arc(agent_id: 'p1', attachment_state: {})
+      expect(result).to have_key(:current_chapter)
+      expect(result).to have_key(:milestone_count)
+    end
+  end
+
+  describe '#arc_stats' do
+    it 'returns stats' do
+      result = host.arc_stats(agent_id: 'p1')
+      expect(result).to have_key(:current_chapter)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/runners/self_talk_llm_spec.rb

@@ -137,7 +137,7 @@ RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk, '
         result = client.conclude_dialogue(dialogue_id: did)
         expect(result[:concluded]).to be true
         report = client.dialogue_report(dialogue_id: did)
-        expect(report[:dialogue][:conclusion]).to eq('Dialogue concluded')
+        expect(report[:dialogue][:conclusion]).to match(/turns across .* voices\. Dominant position:/)
       end
     end
 
@@ -151,7 +151,7 @@ RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk, '
         result = client.conclude_dialogue(dialogue_id: did)
         expect(result[:concluded]).to be true
         report = client.dialogue_report(dialogue_id: did)
-        expect(report[:dialogue][:conclusion]).to eq('Dialogue concluded')
+        expect(report[:dialogue][:conclusion]).to match(/turns across .* voices\. Dominant position:/)
       end
     end
 

data/spec/legion/extensions/agentic/self/self_talk/runners/self_talk_spec.rb

@@ -193,4 +193,64 @@ RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk do
       expect(voice[:name]).to eq('Critic')
     end
   end
+
+  describe 'mechanical voice bank (fix 3)' do
+    let(:runner_class) do
+      Class.new do
+        include Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk
+      end
+    end
+    let(:runner) { runner_class.new }
+
+    it 'produces real content for known voice types' do
+      %i[critic advocate explorer pragmatist].each do |type|
+        result = runner.send(:mechanical_turn_content, type, 'test topic')
+        expect(result[:content]).not_to be_empty
+        expect(result[:content]).not_to match(/\A\[/)
+        expect(result[:position]).not_to be_nil
+      end
+    end
+
+    it 'falls back to generic bank for unknown voice types' do
+      result = runner.send(:mechanical_turn_content, :unknown_voice, 'some topic')
+      expect(result[:content]).not_to be_empty
+      expect(result[:position]).not_to be_nil
+    end
+
+    it 'VOICE_BANK covers critic, advocate, explorer, pragmatist' do
+      bank = Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk::VOICE_BANK
+      expect(bank.keys).to include(:critic, :advocate, :explorer, :pragmatist)
+    end
+  end
+
+  describe 'mechanical summary (fix 4)' do
+    let(:runner_class) do
+      Class.new do
+        include Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk
+      end
+    end
+    let(:runner) { runner_class.new }
+
+    it 'produces a non-empty summary when dialogue_data is nil' do
+      summary = runner.send(:mechanical_summary, nil)
+      expect(summary).to be_a(String)
+      expect(summary).not_to be_empty
+    end
+
+    it 'includes turn count in summary' do
+      did = start_dialogue(topic: 'summary test')
+      vid = register_voice(name: 'Critic', type: :critic)
+      client.add_turn(dialogue_id: did, voice_id: vid, content: 'Point one', position: :challenge)
+      client.add_turn(dialogue_id: did, voice_id: vid, content: 'Point two', position: :challenge)
+
+      result = client.conclude_dialogue(dialogue_id: did)
+      expect(result[:concluded]).to be true
+    end
+
+    it 'conclude_dialogue without summary uses mechanical_summary' do
+      did = start_dialogue(topic: 'no summary')
+      result = client.conclude_dialogue(dialogue_id: did)
+      expect(result[:concluded]).to be true
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-self
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Esity
@@ -139,44 +139,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 self domain: identity, metacognition, self-model'
 email:
 - matthewdiverson@gmail.com
@@ -309,6 +309,13 @@ files:
 - lib/legion/extensions/agentic/self/reflection/helpers/reflection_store.rb
 - lib/legion/extensions/agentic/self/reflection/runners/reflection.rb
 - lib/legion/extensions/agentic/self/reflection/version.rb
+- lib/legion/extensions/agentic/self/relationship_arc.rb
+- lib/legion/extensions/agentic/self/relationship_arc/client.rb
+- lib/legion/extensions/agentic/self/relationship_arc/helpers/arc_engine.rb
+- lib/legion/extensions/agentic/self/relationship_arc/helpers/constants.rb
+- lib/legion/extensions/agentic/self/relationship_arc/helpers/milestone.rb
+- lib/legion/extensions/agentic/self/relationship_arc/runners/relationship_arc.rb
+- lib/legion/extensions/agentic/self/relationship_arc/version.rb
 - lib/legion/extensions/agentic/self/self_model.rb
 - lib/legion/extensions/agentic/self/self_model/client.rb
 - lib/legion/extensions/agentic/self/self_model/helpers/capability.rb
@@ -416,6 +423,10 @@ files:
 - spec/legion/extensions/agentic/self/reflection/helpers/reflection_spec.rb
 - spec/legion/extensions/agentic/self/reflection/helpers/reflection_store_spec.rb
 - spec/legion/extensions/agentic/self/reflection/runners/reflection_spec.rb
+- spec/legion/extensions/agentic/self/relationship_arc/helpers/arc_engine_spec.rb
+- spec/legion/extensions/agentic/self/relationship_arc/helpers/constants_spec.rb
+- spec/legion/extensions/agentic/self/relationship_arc/helpers/milestone_spec.rb
+- spec/legion/extensions/agentic/self/relationship_arc/runners/relationship_arc_spec.rb
 - spec/legion/extensions/agentic/self/self_model/client_spec.rb
 - spec/legion/extensions/agentic/self/self_model/helpers/capability_spec.rb
 - spec/legion/extensions/agentic/self/self_model/helpers/knowledge_domain_spec.rb