legionio 1.9.50 → 1.9.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 836093ff32350c705da43ab5a36cf9b0e5e135e24556bf5b2c10c50df421ee11
-  data.tar.gz: ac682d87908c360cc90409e9fa773a5a8937245104394dbcd940fea67ca10141
+  metadata.gz: ede4c3b865760acda216ca62dec3963eeba1dc510fa8320438e9fc6f5d290810
+  data.tar.gz: 4428bd1a57998cf59bc887fbbcf67fea6f37c1c4b3036f142dd0bff74d87823c
 SHA512:
-  metadata.gz: f350c4a919b2746bd5fcc72dfa22e03b4e30217a5d934a6fb50411903708473d394e8652b7bb09b27672ee1c93ed222c586a241d93f5aa40eaddae690521a312
-  data.tar.gz: e80c66310e5e90fc93c19cc3c672e4075dac237b27105a0ea3cc5c8cad5d295841bfeb0a893edaf34a1615b44b7fe843c6c060bdc69ef03086ccc200ced7e609
+  metadata.gz: 12130c29fd51936cd819fc0aa7d320a0b5455b0bd20f4693196bf3e853ff2775ad1d5654233e00469795edc1cfc2c78377292c7b290d02fc2d821818da35ffa0
+  data.tar.gz: ae8b7b9820a8735cfbf6bcaa4bf74b05d49d63a628d4ed06a6a9ed5ffb360138a77f8ea8ad71637c20abbbc3b3b50bf08cf1b0683465b1207ecddffd6386b394

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Legion Changelog
 
+## [1.9.52] - 2026-08-07
+### Fixed
+- `/api/stats` + `legion llm status` now report routing on and read circuit state from Inventory SSOT; removed dead `Discovery::System/Ollama` guards and retargeted CLI discovery at `Inventory::Discovery::System`
+- Fixed §4 exception-handling violations: `stats.rb` and `llm_command.rb` now use `handle_exception` instead of silent swallows or unstructured logging
+
+## [1.9.51] - 2026-07-31
+### Fixed
+- Puma: add `force_shutdown_after` (default 10s) to server_settings to prevent indefinite shutdown hangs when streaming connections are wedged (puma/puma#3569). Previously Puma's default of `-1` meant SIGTERM would wait forever on any open SSE/streaming body thread that could not be interrupted
+
 ## [1.9.50] - 2026-07-15
 ### Fixed
 - Backfill extension routes with API router after boot to fix /api/extensions/* 404s

data/lib/legion/api/default_settings.rb

@@ -20,10 +20,11 @@ module Legion
 
       def self.puma_defaults
         {
-          min_threads:        10,
-          max_threads:        16,
-          persistent_timeout: 20,
-          first_data_timeout: 30
+          min_threads:          10,
+          max_threads:          16,
+          persistent_timeout:   20,
+          first_data_timeout:   30,
+          force_shutdown_after: 10
         }
       end
 

data/lib/legion/api/stats.rb

@@ -4,6 +4,8 @@ module Legion
   class API < Sinatra::Base
     module Routes
       module Stats
+        extend Legion::Logging::Helper
+
         def self.registered(app)
           app.get '/api/stats' do
             result = {}
@@ -137,16 +139,14 @@ module Legion
             info[:default_provider] = s[:default_provider]
             info[:pipeline_enabled] = s[:pipeline_enabled] == true
 
-            if defined?(Legion::LLM::Router) && Legion::LLM::Router.routing_enabled?
+            if defined?(Legion::LLM::Router) # legit optional-gem guard (standards §6): legion-llm may be absent
               info[:routing_enabled] = true
-              tracker = Legion::LLM::Router.health_tracker
-              if tracker
-                providers = s[:providers] || {}
-                info[:provider_health] = providers.each_with_object({}) do |(name, _cfg), h|
-                  h[name] = { circuit: tracker.circuit_state(name)&.to_s }
-                rescue StandardError
-                  nil
-                end
+              info[:provider_health] = Legion::LLM::Inventory.lanes.each_with_object({}) do |lane, h|
+                key = "#{lane[:provider_family]}/#{lane[:instance_id]}"
+                h[key] = { circuit: lane.dig(:health, :circuit_state)&.to_s }
+              rescue StandardError => e
+                handle_exception(e, level: :warn, operation: 'api.stats.provider_health', lane: lane[:id])
+                next # skip the malformed lane, but the failure is logged + published, not swallowed
               end
             else
               info[:routing_enabled] = false
@@ -158,6 +158,7 @@ module Legion
             end
             info
           rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'api.stats.collect_llm')
             { error: e.message }
           end
 

data/lib/legion/cli/chat/tools/model_comparison.rb

@@ -56,7 +56,7 @@ module Legion
             return pricing if models_str.nil? || models_str.strip.empty?
 
             names = models_str.split(',').map(&:strip).map(&:downcase)
-            pricing.select { |k, _| names.any? { |n| k.downcase.include?(n) } } # rubocop:disable Style/ArrayIntersect
+            pricing.select { |k, _| names.any? { |n| k.downcase.include?(n) } }
           end
 
           def self.format_comparison(selected, tokens)

data/lib/legion/cli/chat_command.rb

@@ -1045,8 +1045,8 @@ module Legion
         def handle_review_in_session(scope, out)
           scope = (scope || '').strip
           diff = case scope
-                 when 'staged'  then `git diff --staged 2>/dev/null`
-                 when 'branch'  then `git diff main...HEAD 2>/dev/null`
+                 when 'staged' then `git diff --staged 2>/dev/null`
+                 when 'branch' then `git diff main...HEAD 2>/dev/null`
                  when '', 'uncommitted' then `git diff 2>/dev/null`
                  else
                    out.error('Usage: /review [staged|uncommitted|branch]')

data/lib/legion/cli/llm_command.rb

@@ -5,6 +5,8 @@ require 'thor'
 module Legion
   module CLI
     class Llm < Thor
+      include Legion::Logging::Helper
+
       namespace 'llm'
 
       def self.exit_on_failure?
@@ -163,31 +165,31 @@ module Legion
         end
 
         def collect_routing
-          return { enabled: false } unless defined?(Legion::LLM::Router)
+          return { enabled: false } unless defined?(Legion::LLM::Router) # legit optional-gem guard (standards §6)
 
           {
-            enabled:    Legion::LLM::Router.routing_enabled?,
+            enabled:    true,
             local_tier: Legion::LLM::Router.tier_available?(:local),
             fleet_tier: Legion::LLM::Router.tier_available?(:fleet),
             cloud_tier: Legion::LLM::Router.tier_available?(:cloud)
           }
         rescue StandardError => e
-          Legion::Logging.warn("LlmCommand#collect_routing failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'cli.llm.collect_routing')
           { enabled: false }
         end
 
         def collect_system
-          return {} unless defined?(Legion::LLM::Discovery::System)
+          return {} unless defined?(Legion::LLM::Inventory::Discovery::System) # legit optional-gem guard (standards §6)
 
-          Legion::LLM::Discovery::System.refresh! if Legion::LLM::Discovery::System.stale?
+          Legion::LLM::Inventory::Discovery::System.refresh! if Legion::LLM::Inventory::Discovery::System.stale?
           {
-            platform:        Legion::LLM::Discovery::System.platform,
-            total_memory_mb: Legion::LLM::Discovery::System.total_memory_mb,
-            avail_memory_mb: Legion::LLM::Discovery::System.available_memory_mb,
-            memory_pressure: Legion::LLM::Discovery::System.memory_pressure?
+            platform:        Legion::LLM::Inventory::Discovery::System.platform,
+            total_memory_mb: Legion::LLM::Inventory::Discovery::System.total_memory_mb,
+            avail_memory_mb: Legion::LLM::Inventory::Discovery::System.available_memory_mb,
+            memory_pressure: Legion::LLM::Inventory::Discovery::System.memory_pressure?
           }
         rescue StandardError => e
-          Legion::Logging.warn("LlmCommand#collect_system failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'cli.llm.collect_system')
           {}
         end
 
@@ -199,13 +201,14 @@ module Legion
             next unless cfg[:enabled]
 
             models = [cfg[:default_model]].compact
-            if name == :ollama && defined?(Legion::LLM::Discovery::Ollama)
+            if name == :ollama && defined?(Legion::LLM::Inventory) # legit optional-gem guard (standards §6)
               begin
-                Legion::LLM::Discovery::Ollama.refresh! if Legion::LLM::Discovery::Ollama.stale?
-                discovered = Legion::LLM::Discovery::Ollama.model_names
+                discovered = Legion::LLM::Inventory.lanes
+                                                   .select { |l| l[:provider_family].to_s == 'ollama' }
+                                                   .map { |l| l[:model] }.compact.uniq
                 models = discovered unless discovered.empty?
               rescue StandardError => e
-                Legion::Logging.debug("LlmCommand#collect_models ollama discovery failed: #{e.message}") if defined?(Legion::Logging)
+                handle_exception(e, level: :warn, operation: 'cli.llm.collect_models')
               end
             end
             result[name] = models

data/lib/legion/helpers/context.rb

@@ -25,7 +25,7 @@ module Legion
           return { success: true, files: [] } unless Dir.exist?(base)
 
           files = Dir.glob(File.join(base, '**', '*')).select { |f| File.file?(f) }
-                                                      .map do |f|
+                     .map do |f|
             f.sub("#{context_dir}/",
                   '')
           end

data/lib/legion/service.rb

@@ -382,8 +382,9 @@ module Legion
       max_threads = puma_cfg[:max_threads]
       thread_spec = "#{min_threads}:#{max_threads}"
       puma_timeouts = {
-        persistent_timeout: puma_cfg[:persistent_timeout],
-        first_data_timeout: puma_cfg[:first_data_timeout]
+        persistent_timeout:   puma_cfg[:persistent_timeout],
+        first_data_timeout:   puma_cfg[:first_data_timeout],
+        force_shutdown_after: puma_cfg[:force_shutdown_after]
       }.compact
 
       tls_cfg = build_api_tls_config(api_settings)

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.9.50'
+  VERSION = '1.9.52'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.9.50
+  version: 1.9.52
 platform: ruby
 authors:
 - Esity
@@ -434,27 +434,7 @@ files:
 - docker_deploy.rb
 - exe/legion
 - exe/legionio
-- exe/replay_ledger
 - exe/rollback_ledger
-- extensions-agentic/lex-consent/db/migrations/001_create_consent_maps.rb
-- extensions-agentic/lex-consent/lex-consent.gemspec
-- extensions-agentic/lex-consent/lib/legion/extensions/agentic/consent.rb
-- extensions-agentic/lex-consent/lib/legion/extensions/agentic/consent/actors/tier_evaluation.rb
-- extensions-agentic/lex-consent/lib/legion/extensions/agentic/consent/models/consent_map.rb
-- extensions-agentic/lex-consent/lib/legion/extensions/agentic/consent/runners/consent.rb
-- extensions-agentic/lex-consent/lib/legion/extensions/agentic/consent/version.rb
-- extensions-agentic/lex-reconciliation/Gemfile
-- extensions-agentic/lex-reconciliation/README.md
-- extensions-agentic/lex-reconciliation/lex-reconciliation.gemspec
-- extensions-agentic/lex-reconciliation/lib/legion/extensions/reconciliation.rb
-- extensions-agentic/lex-reconciliation/lib/legion/extensions/reconciliation/actors/reconciliation_cycle.rb
-- extensions-agentic/lex-reconciliation/lib/legion/extensions/reconciliation/drift_log.rb
-- extensions-agentic/lex-reconciliation/lib/legion/extensions/reconciliation/runners/drift_checker.rb
-- extensions-agentic/lex-reconciliation/lib/legion/extensions/reconciliation/version.rb
-- extensions-agentic/lex-reconciliation/spec/legion/extensions/reconciliation/drift_log_spec.rb
-- extensions-agentic/lex-reconciliation/spec/legion/extensions/reconciliation/runners/drift_checker_spec.rb
-- extensions-agentic/lex-reconciliation/spec/legion/extensions/reconciliation_spec.rb
-- extensions-agentic/lex-reconciliation/spec/spec_helper.rb
 - integration/self_generate_spec.rb
 - legionio.gemspec
 - lib/legion.rb

data/exe/replay_ledger

@@ -1,395 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# One-off script to migrate local ledger data to prod database.
-# Handles FK remapping for identity tables by matching on natural keys.
-#
-# Usage:
-#   LOCAL_DB_URL="postgres://localhost/legionio" PROD_DB_URL="postgres://user:pass@prod/legionio" bundle exec exe/replay_ledger
-#
-# Optional:
-#   REPLAY_DRY_RUN=true     (show counts, don't write)
-
-require 'sequel'
-require 'logger'
-require 'uri'
-require 'json'
-require 'fileutils'
-
-log = Logger.new($stdout)
-log.level = Logger::INFO
-
-# --- Signal handling for clean exit ---
-module MigrationState
-  @shutdown = false
-  class << self
-    attr_accessor :shutdown
-  end
-end
-
-%w[INT TERM HUP].each do |sig|
-  Signal.trap(sig) do
-    if MigrationState.shutdown
-      warn "\nForce quit."
-      exit!(1)
-    end
-    MigrationState.shutdown = true
-    warn "\nShutdown requested — finishing current row, then saving manifests and exiting cleanly..."
-  end
-end
-
-local_url = ENV.fetch('LOCAL_DB_URL', 'postgres://localhost/legionio')
-dry_run   = ENV['REPLAY_DRY_RUN'] == 'true'
-
-# Read prod creds from ~/.legionio/settings/z_data_override.json
-prod_settings_path = File.expand_path('~/.legionio/settings/z_data_override.json')
-abort "Missing #{prod_settings_path} — create it with host/database/user/password" unless File.exist?(prod_settings_path)
-prod_config = JSON.parse(File.read(prod_settings_path))
-prod_creds = prod_config.dig('data', 'creds') || abort("No data.creds in #{prod_settings_path}")
-prod_url = "postgres://#{prod_creds['user']}:#{URI.encode_www_form_component(prod_creds['password'])}@#{prod_creds['host']}/#{prod_creds['database']}"
-
-LOCAL = Sequel.connect(local_url)
-PROD  = Sequel.connect(prod_url)
-
-log.info "Local: #{local_url.sub(/:[^:@]+@/, ':***@')}"
-log.info "Prod:  postgres://#{prod_creds['user']}:***@#{prod_creds['host']}/#{prod_creds['database']}"
-log.info "Mode:  #{dry_run ? 'DRY RUN' : 'LIVE'}"
-
-# ============================================================
-# PHASE 1: Sync identity_providers (match on name)
-# ============================================================
-
-log.info '--- Phase 1: identity_providers ---'
-local_providers = LOCAL[:identity_providers].all
-prod_providers = PROD[:identity_providers].all
-prod_provider_by_name = prod_providers.to_h { |p| [p[:name], p] }
-provider_id_map = {} # local_id → prod_id
-
-local_providers.each do |lp|
-  prod_match = prod_provider_by_name[lp[:name]]
-  if prod_match
-    provider_id_map[lp[:id]] = prod_match[:id]
-  else
-    row = lp.except(:id)
-    if dry_run
-      log.info "  [DRY] Would insert provider: #{lp[:name]}"
-      provider_id_map[lp[:id]] = -1
-    else
-      new_id = PROD[:identity_providers].insert(row)
-      provider_id_map[lp[:id]] = new_id
-      log.info "  Inserted provider: #{lp[:name]} → id=#{new_id}"
-    end
-  end
-end
-log.info "  Provider map: #{provider_id_map.size} entries (#{provider_id_map.count { |_, v| v != -1 }} matched)"
-
-# ============================================================
-# PHASE 2: Sync identity_principals (match on canonical_name)
-# ============================================================
-
-log.info '--- Phase 2: identity_principals ---'
-local_principals = LOCAL[:identity_principals].all
-prod_principals = PROD[:identity_principals].all
-prod_principal_by_name = prod_principals.to_h { |p| [p[:canonical_name], p] }
-principal_id_map = {} # local_id → prod_id
-
-local_principals.each do |lp|
-  prod_match = prod_principal_by_name[lp[:canonical_name]]
-  if prod_match
-    principal_id_map[lp[:id]] = prod_match[:id]
-  else
-    row = lp.except(:id)
-    if dry_run
-      log.info "  [DRY] Would insert principal: #{lp[:canonical_name]}"
-      principal_id_map[lp[:id]] = -1
-    else
-      new_id = PROD[:identity_principals].insert(row)
-      principal_id_map[lp[:id]] = new_id
-      log.info "  Inserted principal: #{lp[:canonical_name]} → id=#{new_id}"
-    end
-  end
-end
-log.info "  Principal map: #{principal_id_map.size} entries (#{principal_id_map.count { |_, v| v != -1 }} matched)"
-
-# ============================================================
-# PHASE 3: Sync identities (match on principal_id + provider_identity_key)
-# ============================================================
-
-log.info '--- Phase 3: identities ---'
-local_identities = LOCAL[:identities].all
-prod_identities = PROD[:identities].all
-prod_identity_by_key = prod_identities.to_h { |i| ["#{i[:principal_id]}:#{i[:provider_identity_key]}", i] }
-identity_id_map = {} # local_id → prod_id
-
-local_identities.each do |li|
-  mapped_principal = principal_id_map[li[:principal_id]]
-  mapped_provider = provider_id_map[li[:provider_id]]
-  prod_key = "#{mapped_principal}:#{li[:provider_identity_key]}"
-  prod_match = prod_identity_by_key[prod_key]
-
-  if prod_match
-    identity_id_map[li[:id]] = prod_match[:id]
-  else
-    row = li.except(:id)
-    row[:principal_id] = mapped_principal
-    row[:provider_id] = mapped_provider
-    if dry_run
-      log.info "  [DRY] Would insert identity: #{li[:provider_identity_key]} (principal=#{mapped_principal})"
-      identity_id_map[li[:id]] = -1
-    else
-      new_id = PROD[:identities].insert(row)
-      identity_id_map[li[:id]] = new_id
-      log.info "  Inserted identity: #{li[:provider_identity_key]} → id=#{new_id}"
-    end
-  end
-end
-log.info "  Identity map: #{identity_id_map.size} entries (#{identity_id_map.count { |_, v| v != -1 }} matched)"
-
-# ============================================================
-# PHASE 4: LLM tables — remap identity FKs, preserve UUID links
-# ============================================================
-
-def remap_identity_columns(row, principal_map, identity_map)
-  result = row.dup
-  # Different tables use different column names
-  %i[principal_id caller_principal_id].each do |col|
-    result[col] = principal_map[result[col]] if result.key?(col) && result[col] && principal_map.key?(result[col])
-  end
-  %i[identity_id caller_identity_id].each do |col|
-    result[col] = identity_map[result[col]] if result.key?(col) && result[col] && identity_map.key?(result[col])
-  end
-  result
-end
-
-MANIFEST_DIR = '/tmp/legion_migration_manifests'
-
-# rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
-def migrate_table(local_db, prod_db, table, id_map_out, log:, dry_run:, fk_maps: {}, identity_maps: {})
-  count = local_db[table].count
-  if count.zero?
-    log.info "  #{table}: 0 rows, skipping"
-    return
-  end
-
-  log.info "  #{table}: #{count} rows to migrate..."
-
-  # Check for UUID column to detect duplicates
-  columns = local_db[table].columns
-  has_uuid = columns.include?(:uuid)
-  log.info "  #{table}: loading existing UUIDs from prod..." if has_uuid
-  prod_uuids = if has_uuid
-                 PROD[table].select_map(:uuid).to_set
-               else
-                 Set.new
-               end
-  log.info "  #{table}: #{prod_uuids.size} existing UUIDs on prod" if has_uuid
-
-  FileUtils.mkdir_p(MANIFEST_DIR)
-  manifest_path = File.join(MANIFEST_DIR, "#{table}.json")
-  ids_path = File.join(MANIFEST_DIR, "#{table}_ids.jsonl")
-
-  inserted = 0
-  skipped = 0
-  start_time = Time.now
-
-  # Use block form to avoid file descriptor leaks
-  File.open(ids_path, 'a') do |ids_file|
-    local_db[table].order(:id).each do |row|
-      if MigrationState.shutdown
-        log.warn "  #{table}: INTERRUPTED at row #{inserted + skipped}/#{count} — exiting cleanly"
-        break
-      end
-
-      local_id = row[:id]
-
-      # Skip if already exists on prod (by UUID)
-      if has_uuid && row[:uuid] && prod_uuids.include?(row[:uuid])
-        prod_row = prod_db[table].where(uuid: row[:uuid]).first
-        id_map_out[local_id] = prod_row[:id] if prod_row
-        skipped += 1
-        next
-      end
-
-      new_row = row.except(:id)
-
-      # Remap FK columns — if map is empty, NULL the column (deferred backfill)
-      fk_maps.each do |column, map|
-        next unless new_row.key?(column) && new_row[column]
-
-        new_row[column] = if map.empty?
-                            nil
-                          elsif map.key?(new_row[column])
-                            map[new_row[column]]
-                          end
-      end
-
-      # Remap identity columns
-      new_row = remap_identity_columns(new_row, identity_maps[:principals] || {}, identity_maps[:identities] || {}) unless identity_maps.empty?
-
-      if dry_run
-        inserted += 1
-        id_map_out[local_id] = -1
-      else
-        begin
-          new_id = prod_db[table].insert(new_row)
-          id_map_out[local_id] = new_id
-          ids_file.puts("#{local_id},#{new_id}")
-          ids_file.flush
-          inserted += 1
-        rescue Sequel::ForeignKeyConstraintViolation => e
-          log.warn "  #{table}: FK violation on local_id=#{local_id} — #{e.message.lines.first.strip} — skipping"
-          skipped += 1
-        rescue Sequel::UniqueConstraintViolation => e
-          log.warn "  #{table}: duplicate on local_id=#{local_id} — #{e.message.lines.first.strip} — skipping"
-          skipped += 1
-        rescue Sequel::DatabaseError => e
-          log.error "  #{table}: DB error on local_id=#{local_id} — #{e.message.lines.first.strip} — skipping"
-          skipped += 1
-        end
-      end
-
-      # Progress logging every 100 rows
-      next unless ((inserted + skipped) % 100).zero?
-
-      elapsed = (Time.now - start_time).round(1)
-      rate = ((inserted + skipped) / [elapsed, 0.1].max).round(1)
-      log.info "  #{table}: progress #{inserted + skipped}/#{count} (inserted=#{inserted} skipped=#{skipped}) #{elapsed}s #{rate} rows/s"
-    end
-  end
-
-  # Write final summary manifest
-  manifest = {
-    table:          table.to_s,
-    started_at:     start_time.iso8601,
-    completed_at:   Time.now.iso8601,
-    inserted_count: inserted,
-    skipped_count:  skipped,
-    interrupted:    MigrationState.shutdown,
-    ids_file:       ids_path
-  }
-  File.write(manifest_path, JSON.pretty_generate(manifest))
-
-  elapsed = (Time.now - start_time).round(1)
-  log.info "  #{table}: done inserted=#{inserted} skipped=#{skipped} elapsed=#{elapsed}s"
-  log.info "  #{table}: manifest → #{manifest_path}"
-  log.info "  #{table}: IDs → #{ids_path}"
-end
-# rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
-
-identity_maps = { principals: principal_id_map, identities: identity_id_map }
-
-# --- llm_conversations ---
-conversation_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 4: llm_conversations ---'
-  migrate_table(LOCAL, PROD, :llm_conversations, conversation_id_map,
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_message_inference_requests ---
-request_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 5: llm_message_inference_requests ---'
-  migrate_table(LOCAL, PROD, :llm_message_inference_requests, request_id_map,
-                fk_maps: { conversation_id: conversation_id_map, latest_message_id: {} },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_message_inference_responses ---
-response_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 6: llm_message_inference_responses ---'
-  migrate_table(LOCAL, PROD, :llm_message_inference_responses, response_id_map,
-                fk_maps: { message_inference_request_id: request_id_map, response_message_id: {} },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_message_inference_metrics ---
-metrics_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 7: llm_message_inference_metrics ---'
-  migrate_table(LOCAL, PROD, :llm_message_inference_metrics, metrics_id_map,
-                fk_maps: { message_inference_request_id:  request_id_map,
-                           message_inference_response_id: response_id_map },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_messages ---
-message_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 8: llm_messages ---'
-  migrate_table(LOCAL, PROD, :llm_messages, message_id_map,
-                fk_maps: { conversation_id:               conversation_id_map,
-                           message_inference_request_id:  request_id_map,
-                           message_inference_response_id: response_id_map,
-                           parent_message_id:             message_id_map },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_tool_calls ---
-tool_call_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 9: llm_tool_calls ---'
-  migrate_table(LOCAL, PROD, :llm_tool_calls, tool_call_id_map,
-                fk_maps: { conversation_id:               conversation_id_map,
-                           message_inference_response_id: response_id_map,
-                           requested_by_message_id:       message_id_map,
-                           result_message_id:             message_id_map },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- llm_tool_call_attempts ---
-tool_attempt_id_map = {}
-unless MigrationState.shutdown
-  log.info '--- Phase 10: llm_tool_call_attempts ---'
-  migrate_table(LOCAL, PROD, :llm_tool_call_attempts, tool_attempt_id_map,
-                fk_maps: { tool_call_id: tool_call_id_map },
-                identity_maps: identity_maps, log: log, dry_run: dry_run)
-end
-
-# --- Update latest_message_id and response_message_id now that messages exist ---
-unless dry_run || MigrationState.shutdown
-  log.info '--- Phase 11: Backfill deferred FK columns ---'
-
-  backfilled = 0
-  LOCAL[:llm_message_inference_requests].where(Sequel.~(latest_message_id: nil)).each do |row|
-    break if MigrationState.shutdown
-
-    prod_req_id = request_id_map[row[:id]]
-    prod_msg_id = message_id_map[row[:latest_message_id]]
-    next unless prod_req_id && prod_msg_id
-
-    PROD[:llm_message_inference_requests].where(id: prod_req_id).update(latest_message_id: prod_msg_id)
-    backfilled += 1
-  end
-
-  LOCAL[:llm_message_inference_responses].where(Sequel.~(response_message_id: nil)).each do |row|
-    break if MigrationState.shutdown
-
-    prod_resp_id = response_id_map[row[:id]]
-    prod_msg_id = message_id_map[row[:response_message_id]]
-    next unless prod_resp_id && prod_msg_id
-
-    PROD[:llm_message_inference_responses].where(id: prod_resp_id).update(response_message_id: prod_msg_id)
-    backfilled += 1
-  end
-
-  log.info "  Deferred FK backfill complete: #{backfilled} updates"
-end
-
-# --- Summary ---
-log.info '=== Migration Summary ==='
-log.info "  Providers:  #{provider_id_map.size}"
-log.info "  Principals: #{principal_id_map.size}"
-log.info "  Identities: #{identity_id_map.size}"
-log.info "  Conversations: #{conversation_id_map.size}"
-log.info "  Requests:   #{request_id_map.size}"
-log.info "  Responses:  #{response_id_map.size}"
-log.info "  Metrics:    #{metrics_id_map.size}"
-log.info "  Messages:   #{message_id_map.size}"
-log.info "  Tool calls: #{tool_call_id_map.size}"
-log.info "  Tool attempts: #{tool_attempt_id_map.size}"
-log.info "  Manifests:  #{MANIFEST_DIR}/"
-log.info dry_run ? '[DRY RUN COMPLETE]' : '[MIGRATION COMPLETE]'
-
-log.info '  To rollback: bundle exec exe/rollback_ledger'

data/extensions-agentic/lex-consent/db/migrations/001_create_consent_maps.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:consent_maps) do
-      primary_key :id
-      String  :worker_id,    null: false
-      String  :from_tier,    null: false
-      String  :to_tier,      null: false
-      String  :requested_by, null: false
-      String  :state,        null: false, default: 'pending_approval'
-      String  :resolved_by
-      Time    :resolved_at
-      String  :notes,        text: true
-      String  :context,      text: true
-      Time    :created_at
-      Time    :updated_at
-
-      index :worker_id
-      index :state
-      index %i[worker_id state]
-    end
-  end
-end