legionio 1.9.39 → 1.9.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e168c173741e3abdcd5a911fb95506e1c599e8a934befdd8221991ebdae1185
-  data.tar.gz: 00a1dad9c0234f3ef0e166d9f1844bde95a8c344adb9df28fd5f095bd5fe6b49
+  metadata.gz: 13eae4c67a25af55b4f7b02423e493a1c102831f204a34368ea16e04f529d5ff
+  data.tar.gz: 44219061da324461fc19a69fc23b7ad1108fd29f696f27133e15b47e3de98e33
 SHA512:
-  metadata.gz: 0b9bda655ae5a8b731feebf9e7bd14539c1ddc13117ad57c799921f2b7eda72a9cf3bfb45c0f64ff7967176c94a35d9471e7a099432423a2ed6e1fd9dcb663ce
-  data.tar.gz: 05b7947bdf2ab01cb026c0afd1bc2d0b385ec643a3f486b3b749ee676ba9383ce3cc276304abd7f60fb317f7f11a1e75f3578b6f06b4d93f9dcca0b77ed5735d
+  metadata.gz: a92ef53aba4416fb0a777fa0be7c4a8b822f1c102cbe45b0fa6d46b7c052db1501fa7e9b05922c3e9188ef589c15f202632b2b4efc9a53476cea6843c62cfa4d
+  data.tar.gz: dc10e34337589079aae562d8db6557c95e9c43b246b8a9f66c05d7b153413947d06bd28f26603aea95ba95987db9ba214b7ac97de40701d2b75b6190032fbcb0

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Legion Changelog
 
+## [1.9.40] - 2026-06-01
+
+### Added
+- 
+
 ## [1.9.39] - 2026-05-30
 
 ### Fixed

data/exe/replay_ledger

@@ -0,0 +1,395 @@
+#!/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/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, 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/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, 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/exe/rollback_ledger

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Rollback a ledger migration using the manifests generated by replay_ledger.
+#
+# Usage:
+#   bundle exec exe/rollback_ledger
+#   ROLLBACK_DRY_RUN=true bundle exec exe/rollback_ledger   (show what would be deleted)
+
+require 'sequel'
+require 'logger'
+require 'uri'
+require 'json'
+
+log = Logger.new($stdout)
+log.level = Logger::INFO
+
+dry_run = ENV['ROLLBACK_DRY_RUN'] == 'true'
+manifest_dir = ENV.fetch('MANIFEST_DIR', '/tmp/legion_migration_manifests')
+
+abort "No manifest directory at #{manifest_dir} — nothing to rollback" unless File.directory?(manifest_dir)
+
+# Read prod creds
+prod_settings_path = File.expand_path('~/.legionio/settings/z_data_override.json')
+abort "Missing #{prod_settings_path}" 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']}"
+
+PROD = Sequel.connect(prod_url)
+log.info "Prod: postgres://#{prod_creds['user']}:***@#{prod_creds['host']}/#{prod_creds['database']}"
+log.info "Mode: #{dry_run ? 'DRY RUN' : 'LIVE ROLLBACK'}"
+log.info "Manifests: #{manifest_dir}"
+
+# Delete in reverse FK order
+TABLES_REVERSE = %w[
+  llm_tool_call_attempts
+  llm_tool_calls
+  llm_messages
+  llm_message_inference_metrics
+  llm_message_inference_responses
+  llm_message_inference_requests
+  llm_conversations
+].freeze
+
+total_deleted = 0
+
+TABLES_REVERSE.each do |table|
+  ids_file = File.join(manifest_dir, "#{table}_ids.jsonl")
+  unless File.exist?(ids_file)
+    log.info "  #{table}: no IDs file, skipping"
+    next
+  end
+
+  # Read prod IDs (second column in "local_id,prod_id" format)
+  ids = File.readlines(ids_file, chomp: true).filter_map do |line|
+    next if line.strip.empty?
+
+    line.split(',')[1]&.to_i
+  end
+
+  if ids.empty?
+    log.info "  #{table}: 0 inserted IDs, skipping"
+    next
+  end
+
+  log.info "  #{table}: #{ids.size} rows to delete..."
+
+  if dry_run
+    log.info "  [DRY] Would delete #{ids.size} rows from #{table} (first 5 IDs: #{ids.first(5).join(',')})"
+  else
+    ids.each_slice(500) do |batch|
+      deleted = PROD[table.to_sym].where(id: batch).delete
+      total_deleted += deleted
+    end
+    log.info "  #{table}: deleted #{ids.size} rows"
+  end
+end
+
+# Also handle deferred FK backfills (latest_message_id, response_message_id)
+# These were UPDATEs, not INSERTs — set them back to NULL
+unless dry_run
+  requests_manifest = File.join(manifest_dir, 'llm_message_inference_requests.json')
+  if File.exist?(requests_manifest)
+    JSON.parse(File.read(requests_manifest))['inserted_ids'] || []
+    # These were inserted rows that got deleted above, so no backfill undo needed
+  end
+end
+
+log.info "=== Rollback #{dry_run ? 'Preview' : 'Complete'} ==="
+log.info "  Total deleted: #{dry_run ? '(dry run)' : total_deleted}"

data/lib/legion/cli/setup_command.rb

@@ -166,11 +166,16 @@ module Legion
         written = []
         skipped = []
 
+        llm_installed, = partition_gems(PACKS[:llm][:gems])
+        out.warn('LLM pack not installed. Run: legionio setup llm') if llm_installed.empty? && !options[:json]
+
         write_codex_config(base_url, written, skipped)
-        write_claude_code_proxy_config(base_url, written, skipped)
+        # write_claude_code_proxy_config(base_url, written, skipped) # too destructive for enterprise users
+        write_zsh_legionio(base_url, written, skipped)
+        write_pack_marker(:'proxy-mode')
 
         if options[:json]
-          out.json(written: written, skipped: skipped, base_url: base_url)
+          out.json(written: written, skipped: skipped, base_url: base_url, profile: 'legionio')
         else
           out.spacer
           out.success("LegionIO proxy mode configured (#{written.size} written, #{skipped.size} skipped)")
@@ -178,8 +183,13 @@ module Legion
           skipped.each { |f| puts "  Skipped (already exists, use --force to overwrite): #{f}" }
           out.spacer
           puts "  LegionIO API: #{base_url.sub('/v1', '')}"
-          puts '  Codex CLI:    legion llm proxy (uses ~/.codex/config.toml)'
+          puts '  Codex CLI:    codex --profile legionio'
           puts '  Claude Code:  set ANTHROPIC_BASE_URL in your shell or ~/.claude/settings.json'
+          if written.any? { |f| f.end_with?('.zsh_legionio') }
+            out.spacer
+            puts '  To activate shell functions in this session, run:'
+            puts '    source ~/.zsh_legionio'
+          end
           out.spacer
         end
       end
@@ -313,6 +323,7 @@ module Legion
         end
 
         write_python_marker(python3, packages)
+        write_pack_marker(:python)
 
         if options[:json]
           out.json(venv: PYTHON_VENV_DIR, python: python_version(python3), results: results)
@@ -339,8 +350,15 @@ module Legion
             missing: missing }
         end
 
+        python_status  = { name: :python, description: 'Python venv + document/data packages',
+                           installed: File.exist?(PYTHON_MARKER), missing: [] }
+        proxy_status   = { name: :'proxy-mode', description: 'Codex CLI + shell helper functions for LegionIO proxy',
+                           installed: File.exist?(File.expand_path('~/.legionio/.packs/proxy-mode')), missing: [] }
+
         if options[:json]
-          out.json(packs: pack_statuses)
+          out.json(packs:      pack_statuses,
+                   python:     python_status.slice(:name, :description, :installed),
+                   proxy_mode: proxy_status.slice(:name, :description, :installed))
         else
           out.header('Feature Packs')
           out.spacer
@@ -355,6 +373,10 @@ module Legion
               puts "    #{out.colorize(g, :muted)} (missing)"
             end
           end
+          [python_status, proxy_status].each do |ps|
+            icon = ps[:installed] ? out.colorize('installed', :success) : out.colorize('not installed', :muted)
+            puts "  #{out.colorize(ps[:name].to_s.ljust(12), :label)} #{icon}  #{ps[:description]}"
+          end
           out.spacer
         end
       end
@@ -742,31 +764,129 @@ module Legion
         end
 
         def write_codex_config(base_url, written, skipped)
-          codex_dir  = File.expand_path('~/.codex')
-          codex_path = File.join(codex_dir, 'config.toml')
+          codex_dir = File.expand_path('~/.codex')
+          FileUtils.mkdir_p(codex_dir)
+
+          write_codex_profile(codex_dir, base_url, written, skipped)
+          write_codex_catalog(codex_dir, written, skipped)
+          write_codex_main_config(codex_dir, base_url, written, skipped)
+        end
 
-          if File.exist?(codex_path) && !options[:force]
-            skipped << codex_path
+        def write_codex_profile(codex_dir, base_url, written, skipped)
+          profile_path = File.join(codex_dir, 'legionio.config.toml')
+
+          if File.exist?(profile_path) && !options[:force]
+            skipped << profile_path
             return
           end
 
-          FileUtils.mkdir_p(codex_dir)
-
+          catalog_path = File.join(codex_dir, 'legionio-catalog.json')
           content = <<~TOML
             model = "legionio"
-            model_provider = "legion"
+            model_provider = "legionio"
+            model_catalog_json = "#{catalog_path}"
 
-            [model_providers.legion]
+            [model_providers.legionio]
             name = "LegionIO"
             env_key = "LEGION_API_KEY"
             base_url = "#{base_url}"
             wire_api = "responses"
           TOML
 
-          File.write(codex_path, content)
-          written << codex_path
+          File.write(profile_path, content)
+          written << profile_path
+        rescue StandardError => e
+          raise Thor::Error, "Failed to write #{profile_path}: #{e.message}"
+        end
+
+        def write_codex_catalog(codex_dir, written, skipped)
+          catalog_path = File.join(codex_dir, 'legionio-catalog.json')
+
+          if File.exist?(catalog_path) && !options[:force]
+            skipped << catalog_path
+            return
+          end
+
+          catalog = {
+            models: [
+              {
+                id:             'legionio',
+                name:           'LegionIO',
+                context_size:   262_144,
+                context_window: 262_144
+              },
+              {
+                id:             'auto',
+                name:           'LegionIO (auto)',
+                context_size:   262_144,
+                context_window: 262_144
+              }
+            ]
+          }
+
+          File.write(catalog_path, ::JSON.pretty_generate(catalog))
+          written << catalog_path
+        rescue StandardError => e
+          raise Thor::Error, "Failed to write #{catalog_path}: #{e.message}"
+        end
+
+        def write_codex_main_config(codex_dir, _base_url, written, _skipped)
+          config_path = File.join(codex_dir, 'config.toml')
+          existing = File.exist?(config_path) ? File.read(config_path) : ''
+
+          if existing.match?(/^\s*profile\s*=\s*"legionio"/)
+            written << config_path
+            return
+          end
+
+          updated = existing.empty? ? "profile = \"legionio\"\n" : "profile = \"legionio\"\n\n#{existing.lstrip}"
+          File.write(config_path, updated)
+          written << config_path
+        rescue StandardError => e
+          raise Thor::Error, "Failed to write #{config_path}: #{e.message}"
+        end
+
+        def write_zsh_legionio(base_url, written, _skipped)
+          zshrc_path = File.expand_path('~/.zshrc')
+          return unless File.exist?(zshrc_path)
+
+          host_base = base_url.sub(%r{/v1$}, '')
+          zsh_file  = File.expand_path('~/.zsh_legionio')
+
+          content = <<~ZSH
+            # LegionIO shell helpers — generated by `legionio setup proxy-mode`
+            # Re-run to update; do not edit manually.
+
+            claude-legionio() {
+              export ANTHROPIC_BASE_URL=#{host_base}
+              export ANTHROPIC_API_KEY=legion
+              export ANTHROPIC_AUTH_TOKEN=
+              export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
+              export CLAUDE_CODE_USE_BEDROCK=
+              export AWS_PROFILE=
+              export AWS_REGION=
+              unset ANTHROPIC_DEFAULT_OPUS_MODEL
+              unset ANTHROPIC_DEFAULT_SONNET_MODEL
+              unset ANTHROPIC_DEFAULT_HAIKU_MODEL
+              claude --model legionio "$@"
+            }
+
+            codex-legionio() {
+              codex --provider legionio "$@"
+            }
+          ZSH
+
+          File.write(zsh_file, content)
+          written << zsh_file
+
+          source_line = '[ -f ~/.zsh_legionio ] && source ~/.zsh_legionio'
+          zshrc = File.read(zshrc_path)
+          unless zshrc.include?(source_line)
+            File.write(zshrc_path, "#{zshrc.rstrip}\n\n#{source_line}\n")
+            written << zshrc_path
+          end
         rescue StandardError => e
-          raise Thor::Error, "Failed to write #{codex_path}: #{e.message}"
+          raise Thor::Error, "Failed to write zsh config: #{e.message}"
         end
 
         def write_claude_code_proxy_config(base_url, written, skipped)

data/lib/legion/trace_search.rb

@@ -72,7 +72,7 @@ module Legion
         )
         Legion::Logging.error "[TraceSearch] LLM filter generation failed for query: #{query.inspect}" if !result[:valid] && defined?(Legion::Logging)
         result[:data] if result[:valid]
-      rescue Legion::LLM::LLMError => e
+      rescue StandardError => e
         handle_exception(e, level: :debug, handled: true, operation: 'trace_search.generate_filter') if respond_to?(:handle_exception)
         nil
       end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.9.39
+  version: 1.9.40
 platform: ruby
 authors:
 - Esity
@@ -431,6 +431,8 @@ 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