lex-agentic-social 0.1.18 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c669852940dd9abfa0890d908ed6520df5ba9aa89dad4fc58fadd28a8ecd8529
-  data.tar.gz: 65832a10c828873e86131c0e1c7adbc23708a70f607ace40f73e1b4aa457dd33
+  metadata.gz: 49f5148e440e4e58060bf6ff47c9dc8d31bfde5092ab17b7ad078fb95344e711
+  data.tar.gz: 191fddf9d835866196a20ed7efafcbfb4ef34729d7d5b585f7d68a95dc225b00
 SHA512:
-  metadata.gz: 821f62c6dd7086ab97cc23958319080e4b6fcd8eddb2f59929bc6c9c9fa24291ef3c2d32eedf08767f67a5cbbad312a9ea9e12703429060a9d3aa3a4d2327284
-  data.tar.gz: 83751ac84ae50a28275479b1ef216f40ec43de7d75f45116e7e383ca649f73763da16b00ca9737ab76d67a23bcf9f3352841c8c49f806dc745874e3f334ab136
+  metadata.gz: e052b2d246149565565a6f0a7654bb7d7bf689bc149c2bb17b22fdcc59c15339178805127b1a07e8a602a3d9fd1fcebb3e5b3a1bacef01622f6f4ac934be120f
+  data.tar.gz: 92f66448450959900ac87054fc9a5b4e9e442b3217f52d35e7b8a6e17c377317932c6f92ed129d64c82c177b101d7c95d30ce0a7e52a818f4d74c49edc87a695

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.19] - 2026-06-01
+### Fixed
+- Calibration LLM preference extraction now uses `Legion::LLM.chat` with explicit system/user messages instead of legacy `Legion::LLM.ask`.
+- Governance Proposal store now persists to Apollo Local on create, vote, and resolution — safety-critical proposal state survives restarts.
+- ConsentMap changes (tier changes, action outcomes, pending approvals) are now saved to local storage automatically on every mutation.
+- ConflictLog now evicts old resolved conflicts (30-day retention) and enforces a 1000-entry cap to prevent unbounded memory growth.
+
 ## [0.1.18] - 2026-05-29
 ### Added
 - Database index on `trust_entries.domain` column for faster filtered domain lookups

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

@@ -65,7 +65,13 @@ module Legion
 
                 context = summarize_traces(traces)
                 prompt = build_preference_prompt(context)
-                result = Legion::LLM.ask(message: prompt)
+                result = Legion::LLM.chat(
+                  message: [
+                    { role: 'system', content: 'You are a preference inference engine. Respond ONLY with JSON.' },
+                    { role: 'user', content: prompt }
+                  ],
+                  caller:  { extension: 'lex-agentic-social', mode: :calibration }
+                )
                 return { success: false, error: :llm_failed } unless result&.content
 
                 parsed = parse_preference_response(result.content)

data/lib/legion/extensions/agentic/social/conflict/helpers/conflict_log.rb

@@ -9,6 +9,9 @@ module Legion
         module Conflict
           module Helpers
             class ConflictLog
+              MAX_CONFLICTS = 1000
+              RESOLVED_RETENTION_DAYS = 30
+
               attr_reader :conflicts
 
               def initialize
@@ -61,6 +64,39 @@ module Legion
               def count
                 @conflicts.size
               end
+
+              def evict
+                evict_expired_resolved
+                evict_overflow
+              end
+
+              private
+
+              def evict_expired_resolved
+                cutoff = Time.now.utc - (RESOLVED_RETENTION_DAYS * 86_400)
+                @conflicts.reject! do |_id, conflict|
+                  conflict[:status] == :resolved && conflict[:resolved_at] && conflict[:resolved_at] < cutoff
+                end
+              end
+
+              def evict_overflow
+                return if @conflicts.size <= MAX_CONFLICTS
+
+                # Evict oldest resolved conflicts first, then oldest active
+                resolved = @conflicts.select { |_, c| c[:status] == :resolved }
+                active   = @conflicts.select { |_, c| c[:status] == :active }
+
+                # Remove oldest resolved until under limit
+                resolved.sort_by { |_, c| c[:resolved_at] || c[:created_at] }
+                        .first(resolved.size - 50)
+                        .each_key { |id| @conflicts.delete(id) }
+                return if @conflicts.size <= MAX_CONFLICTS
+
+                # Still over? Remove oldest active
+                active.sort_by { |_, c| c[:created_at] }
+                      .first(active.size - 10)
+                      .each_key { |id| @conflicts.delete(id) }
+              end
             end
           end
         end

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

@@ -17,6 +17,7 @@ module Legion
 
                 id = conflict_log.record(parties: parties, severity: severity, description: description)
                 conflict = conflict_log.get(id)
+                conflict_log.evict
                 log.info "[conflict] registered: id=#{id[0..7]} severity=#{severity} posture=#{conflict[:posture]} parties=#{parties.join(',')}"
                 { conflict_id: id, severity: severity, posture: conflict[:posture] }
               end

data/lib/legion/extensions/agentic/social/consent/helpers/consent_map.rb

@@ -14,38 +14,32 @@ module Legion
               attr_reader :domains
 
               def initialize
-                @domains = Hash.new do |h, k|
-                  h[k] = {
-                    tier:                 Tiers::DEFAULT_TIER,
-                    success_count:        0,
-                    failure_count:        0,
-                    total_actions:        0,
-                    last_changed_at:      nil,
-                    history:              [],
-                    pending_tier:         nil,
-                    pending_since:        nil,
-                    pending_requested_by: nil
-                  }
-                end
+                @domains = {}
                 load_from_local
               end
 
               def get_tier(domain)
-                @domains[domain][:tier]
+                entry = @domains[domain]
+                return Tiers::DEFAULT_TIER unless entry
+
+                entry[:tier]
               end
 
               def set_tier(domain, tier)
                 return unless Tiers.valid_tier?(tier)
 
+                ensure_domain(domain)
                 entry = @domains[domain]
                 old_tier = entry[:tier]
                 entry[:tier] = tier
                 entry[:last_changed_at] = Time.now.utc
                 entry[:history] << { from: old_tier, to: tier, at: Time.now.utc }
                 entry[:history].shift while entry[:history].size > 50
+                persist!
               end
 
               def record_outcome(domain, success:)
+                ensure_domain(domain)
                 entry = @domains[domain]
                 entry[:total_actions] += 1
                 if success
@@ -53,18 +47,19 @@ module Legion
                 else
                   entry[:failure_count] += 1
                 end
+                persist!
               end
 
               def success_rate(domain)
                 entry = @domains[domain]
-                return 0.0 if entry[:total_actions].zero?
+                return 0.0 unless entry && entry[:total_actions].positive?
 
                 entry[:success_count].to_f / entry[:total_actions]
               end
 
               def eligible_for_change?(domain)
                 entry = @domains[domain]
-                return false if entry[:total_actions] < Tiers::MIN_ACTIONS_TO_PROMOTE
+                return false unless entry && entry[:total_actions] >= Tiers::MIN_ACTIONS_TO_PROMOTE
 
                 if entry[:last_changed_at]
                   (Time.now.utc - entry[:last_changed_at]) >= Tiers::PROMOTION_COOLDOWN
@@ -106,28 +101,36 @@ module Legion
               end
 
               def set_pending(domain, proposed_tier:, requested_by: 'system')
+                ensure_domain(domain)
                 entry = @domains[domain]
                 entry[:pending_tier] = proposed_tier
                 entry[:pending_since] = Time.now
                 entry[:pending_requested_by] = requested_by
+                persist!
                 entry
               end
 
               def clear_pending(domain)
                 entry = @domains[domain]
+                return unless entry
+
                 entry[:pending_tier] = nil
                 entry[:pending_since] = nil
                 entry[:pending_requested_by] = nil
+                persist!
                 entry
               end
 
               def pending?(domain)
-                !@domains[domain][:pending_tier].nil?
+                entry = @domains[domain]
+                return false unless entry
+
+                !entry[:pending_tier].nil?
               end
 
               def pending_expired?(domain, timeout: APPROVAL_TIMEOUT)
                 entry = @domains[domain]
-                return false unless entry[:pending_since]
+                return false unless entry && entry[:pending_since]
 
                 Time.now - entry[:pending_since] > timeout
               end
@@ -170,6 +173,7 @@ module Legion
                     []
                   end
 
+                  @domains[key] = new_entry
                   @domains[key].merge!(
                     tier:            row[:tier].to_sym,
                     success_count:   row[:success_count].to_i,
@@ -185,6 +189,28 @@ module Legion
 
               private
 
+              def ensure_domain(domain)
+                @domains[domain] = new_entry unless @domains.key?(domain)
+              end
+
+              def new_entry
+                {
+                  tier:                 Tiers::DEFAULT_TIER,
+                  success_count:        0,
+                  failure_count:        0,
+                  total_actions:        0,
+                  last_changed_at:      nil,
+                  history:              [],
+                  pending_tier:         nil,
+                  pending_since:        nil,
+                  pending_requested_by: nil
+                }
+              end
+
+              def persist!
+                save_to_local
+              end
+
               def success_rate_from(entry)
                 return 0.0 if entry[:total_actions].zero?
 

data/lib/legion/extensions/agentic/social/governance/helpers/proposal.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'time'
 require 'securerandom'
 
 module Legion
@@ -8,16 +9,14 @@ module Legion
       module Social
         module Governance
           module Helpers
-            # NOTE: Proposal state is stored in-memory only (@proposals hash).
-            # This is a safety-critical system (controls consent and containment approval).
-            # Persistence to a durable store (e.g. legion-data) is required so that
-            # proposals survive process restarts. Implementing persistence is tracked
-            # as a separate task.
             class Proposal
+              PROPOSAL_TAG_BASE = %w[governance proposal].freeze
+
               attr_reader :proposals
 
               def initialize
                 @proposals = {}
+                load_from_apollo
               end
 
               def create(category:, description:, proposer:, council_size: Layers::MIN_COUNCIL_SIZE)
@@ -34,6 +33,7 @@ module Legion
                   created_at:    Time.now.utc,
                   resolved_at:   nil
                 }
+                save_proposal(id)
                 id
               end
 
@@ -51,6 +51,7 @@ module Legion
                   prop[:votes_against] << voter
                 end
 
+                save_proposal(proposal_id)
                 check_resolution(proposal_id)
               end
 
@@ -68,11 +69,65 @@ module Legion
 
                 prop[:status]      = :timed_out
                 prop[:resolved_at] = Time.now.utc
+                save_proposal(proposal_id)
                 prop
               end
 
+              def load_from_apollo
+                return false unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                result = Legion::Apollo::Local.query_by_tags(tags: PROPOSAL_TAG_BASE, limit: 1000)
+                return false unless result[:success] && result[:results].is_a?(Array)
+
+                result[:results].each do |entry|
+                  data = ::JSON.parse(entry[:content], symbolize_names: true)
+                  pid = data[:proposal_id]
+                  next unless pid
+
+                  # Convert string timestamps back to Time objects
+                  data[:created_at] = Time.parse(data[:created_at].to_s) if data[:created_at]
+                  data[:resolved_at] = data[:resolved_at] ? Time.parse(data[:resolved_at].to_s) : nil
+
+                  # Ensure status is a symbol
+                  data[:status] = data[:status].to_sym if data[:status].is_a?(String)
+
+                  @proposals[pid] = data
+                rescue StandardError => e
+                  Legion::Logging.warn "[governance] load_from_apollo parse error: #{e.message}"
+                end
+
+                @proposals.any?
+              rescue StandardError => e
+                Legion::Logging.warn "[governance] load_from_apollo failed: #{e.message}"
+                false
+              end
+
               private
 
+              def save_proposal(proposal_id)
+                return unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                prop = @proposals[proposal_id]
+                return unless prop
+
+                # Convert to JSON-safe format
+                serializable = prop.dup
+                serializable[:created_at] = prop[:created_at].is_a?(Time) ? prop[:created_at].iso8601 : prop[:created_at]
+                serializable[:resolved_at] = prop[:resolved_at]&.iso8601
+
+                content = Legion::JSON.dump(serializable)
+                tags = PROPOSAL_TAG_BASE + ["category:#{prop[:category]}", "status:#{prop[:status]}"]
+
+                Legion::Apollo::Local.upsert(
+                  content:               content,
+                  tags:                  tags,
+                  access_scope:          'private',
+                  identity_principal_id: nil
+                )
+              rescue StandardError => e
+                Legion::Logging.warn "[governance] save_proposal failed: #{e.message}"
+              end
+
               def check_resolution(proposal_id)
                 prop = @proposals[proposal_id]
                 total_votes = prop[:votes_for].size + prop[:votes_against].size
@@ -80,11 +135,13 @@ module Legion
                 if Layers.quorum_met?(prop[:votes_for].size, prop[:council_size])
                   prop[:status] = :approved
                   prop[:resolved_at] = Time.now.utc
+                  save_proposal(proposal_id)
                   :approved
                 elsif Layers.quorum_met?(prop[:votes_against].size, prop[:council_size]) ||
                       total_votes >= prop[:council_size]
                   prop[:status] = :rejected
                   prop[:resolved_at] = Time.now.utc
+                  save_proposal(proposal_id)
                   :rejected
                 else
                   :pending

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.18'
+        VERSION = '0.1.19'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-social
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Esity