lex-llm-ledger 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7432d720f451a54b2826adc2eb2fa6335efb0d05cf993d2b84d29c4048090d4
-  data.tar.gz: a77af8bd22c3e4438b5a2c1e5ba684eb042b9612aff691fcc7085a5078ee752a
+  metadata.gz: 70deb6cfb3814da49ebbc893a2025e06ddcf96ee7789a65f794fa66910502f41
+  data.tar.gz: e0837642064bf0c1ee6bf480704d297f961144f5f6cfb0814b88d8de438bf0f6
 SHA512:
-  metadata.gz: 0b03a48cfd7912f193ce78263d44cc1ca996f5d8289f971f836a9e8231b2630bd61d4ece62d1489c8fdc92414174e4e6275df088585d0a2763496e7ff673cff5
-  data.tar.gz: 287814a7495a4f10ba0a95f4b2f2206fadbc13bd3b6143173477dccf276ae2d15658b88e273e94abed67d0734eb9d91fee085c7b088bf7a8705e09b9e4b8e03e
+  metadata.gz: '024169e420f778950b01bd074b03b1e63ccc642cb6c0148a14046dc91a74426c8a4d202a70fb33b6a669fbe3248fba62940e72a3a63ba1d776cef0044e0b9e36'
+  data.tar.gz: 207e66a936b63bf8c52437d2dc1d92931afdcb12caea03976b4e293bf8e67d43f963e62e9ba336c1e80789b3d60ad960b56eb6b85081f3146509f84c760aaf6f

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.6.0] - 2026-05-31
+
+### Added
+- **Skills audit actor** — new queue `llm.audit.skills`, actor, and runner consuming `audit.skill.#` events from the `llm.audit` exchange. Creates `llm_skill_events` records.
+- **Escalation audit actor** — new exchange `llm.escalation` binding, queue `llm.audit.escalations`, actor, and runner. Creates `llm_escalation_events` records.
+- **Retention purge actor** — actively deletes expired records (hourly, batched). Enforces `session_only` and PHI TTL retention policies that were previously passive.
+- **Reconciliation actor** — links orphaned tool calls (null `response_id`) and metering requests (null `latest_message_id`) within a 5-minute lookback window every 2 minutes.
+- **Migration 013** — `parent_request_id` FK on requests, `schema_version` on all official tables, `pii_types_json` and `jurisdictions_json` on conversations.
+- **Migration 014** — creates `llm_skill_events` and `llm_escalation_events` tables.
+- **PHI field-level encryption** — `request_json`, `response_json`, `response_thinking_json` encrypted at rest via `Legion::Crypt` when `contains_phi: true`.
+
+### Fixed
+- **LEDGER-01**: `session_only` retention maps to 0 days (immediate expiry) instead of `nil`, distinguishing it from `permanent`.
+- **IDENTITY-05**: `CallerIdentity.normalize` recognizes transport identity headers (`x-legion-identity-canonical-name`, `x-legion-identity-kind`, `x-legion-identity-db-*`).
+- **IDENTITY-06**: `OfficialRecordWriter.caller_identity_refs` falls back to pre-resolved AMQP header IDs.
+- **GAP-06**: `ProviderStats#health_report` uses `recorded_at` instead of `inserted_at` for 24h window.
+- **GAP-10**: Backfill `metering_payload` maps `provider_instance` from correct column.
+- **GAP-11**: Backfill `registry_reason` extracts from metadata JSON instead of storing raw blob.
+- Dead `Retention.resolve` call removed from tools runner.
+
+### Changed
+- **Jurisdictions** stored as JSON array instead of comma-joined string.
+- **Classification level** validated against controlled vocabulary (`public`/`internal`/`confidential`/`restricted`), defaults to `internal`.
+- **Schema version** written to all official table inserts (constant `SCHEMA_VERSION = 13`).
+- All CallerIdentity-resolved payloads now pass `__header_principal_id`/`__header_identity_id` for direct FK resolution.
+
+### Requires
+- legion-data >= 1.8.9 (migrations 013-014)
+
 ## [0.5.0] - 2026-05-26
 
 ### Changed

data/lib/legion/extensions/llm/ledger/actors/escalations.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+require_relative '../helpers/subscription_actor'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Escalations < Legion::Extensions::Actors::Subscription
+            include Helpers::SubscriptionActor
+
+            prefetch 1
+
+            def runner_class = Legion::Extensions::Llm::Ledger::Runners::Escalations
+
+            def runner_function
+              'write_escalation_record'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def queue
+              Legion::Extensions::Llm::Ledger::Transport::Queues::AuditEscalations
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/reconciliation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Reconciliation < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+            def runner_class
+              'Legion::Extensions::Llm::Ledger::Runners::Reconciliation'
+            end
+
+            def runner_function
+              'link_orphaned_tool_calls'
+            end
+
+            def time
+              120
+            end
+
+            def run
+              Runners::Reconciliation.link_orphaned_tool_calls
+              Runners::Reconciliation.link_metering_messages
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'reconciliation')
+            end
+
+            def run_now?
+              false
+            end
+
+            def use_runner?
+              false
+            end
+
+            def check_subtask?
+              false
+            end
+
+            def generate_task?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/retention_purge.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class RetentionPurge < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+            def runner_class
+              'Legion::Extensions::Llm::Ledger::Runners::RetentionPurge'
+            end
+
+            def runner_function
+              'purge_expired'
+            end
+
+            def time
+              3600
+            end
+
+            def run
+              Runners::RetentionPurge.purge_expired
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'retention_purge')
+            end
+
+            def run_now?
+              false
+            end
+
+            def use_runner?
+              false
+            end
+
+            def check_subtask?
+              false
+            end
+
+            def generate_task?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/skills.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+require_relative '../helpers/subscription_actor'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Skills < Legion::Extensions::Actors::Subscription
+            include Helpers::SubscriptionActor
+
+            prefetch 1
+
+            def runner_class = Legion::Extensions::Llm::Ledger::Runners::Skills
+
+            def runner_function
+              'write_skill_record'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def queue
+              Legion::Extensions::Llm::Ledger::Transport::Queues::AuditSkills
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/backfill/legacy_llm_records.rb

@@ -110,7 +110,8 @@ module Legion
                 exchange_id:       row[:exchange_id],
                 operation:         row[:request_type],
                 provider:          row[:provider],
-                provider_instance: row[:worker_id],
+                provider_instance: row[:provider_instance],
+                worker_id:         row[:worker_id],
                 model_id:          row[:model_id],
                 tier:              row[:tier],
                 input_tokens:      row[:input_tokens],
@@ -161,7 +162,7 @@ module Legion
                            model_key:   row[:model_id],
                            event_type:  row[:event_type],
                            status:      registry_status(row),
-                           reason:      row[:metadata_json],
+                           reason:      registry_reason(row),
                            recorded_at: row[:occurred_at],
                            inserted_at: Time.now.utc
                          }, operation: 'legacy_llm_backfill.registry_event')
@@ -197,6 +198,11 @@ module Legion
               health[:status] || health['status'] || row[:event_type] || 'unknown'
             end
 
+            def registry_reason(row)
+              metadata = json_load(row[:metadata_json])
+              metadata[:reason] || metadata['reason'] || metadata[:message] || metadata['message'] || row[:event_type]
+            end
+
             def table_present?(table)
               db.table_exists?(table)
             end

data/lib/legion/extensions/llm/ledger/helpers/caller_identity.rb

@@ -18,12 +18,16 @@ module Legion
               extension = hash_value(caller_hash, :extension)
               type = first_present(
                 hash_value(identity_hash, :type),
+                hash_value(identity_hash, :kind),
+                header_value(headers, 'x-legion-identity-kind'),
                 header_value(headers, 'x-legion-caller-type'),
                 hash_value(caller, :type),
+                hash_value(caller, :kind),
                 extension && 'extension'
               )
 
               raw_identity = first_present(
+                header_value(headers, 'x-legion-identity-canonical-name'),
                 hash_value(identity_hash, :id),
                 hash_value(identity_hash, :canonical_name),
                 hash_value(identity_hash, :identity),
@@ -38,8 +42,10 @@ module Legion
               )
 
               {
-                identity: normalize_identity_value(raw_identity, type),
-                type:     type
+                identity:     normalize_identity_value(raw_identity, type),
+                type:         type,
+                principal_id: integer_header(headers, 'x-legion-identity-db-principal-id'),
+                identity_id:  integer_header(headers, 'x-legion-identity-db-identity-id')
               }.compact
             end
 
@@ -71,6 +77,14 @@ module Legion
               headers[key] || headers[key.to_sym]
             end
 
+            def integer_header(headers, key)
+              raw = header_value(headers, key)
+              return nil if raw.nil?
+
+              int = raw.to_i
+              int.positive? ? int : nil
+            end
+
             def present?(value)
               !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
             end

data/lib/legion/extensions/llm/ledger/helpers/retention.rb

@@ -13,7 +13,7 @@ module Legion
             PHI_TTL_DEFAULT_DAYS = 30
 
             RETENTION_MAP = {
-              'session_only' => nil,
+              'session_only' => 0,
               'days_30'      => 30,
               'days_90'      => 90,
               'permanent'    => nil

data/lib/legion/extensions/llm/ledger/runners/escalations.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+require_relative '../helpers/caller_identity'
+require_relative '../helpers/json'
+require_relative '../helpers/persistence_logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module Escalations
+            extend self
+
+            def write_escalation_record(payload = nil, metadata = {}, **message)
+              payload, metadata = normalize_runner_args(payload, metadata, message)
+              headers = Helpers::SubscriptionMessage.extract_headers(payload, metadata)
+              props   = metadata[:properties] || {}
+
+              body = payload.is_a?(Hash) ? payload : Helpers::Decryption.decrypt_if_needed(payload, metadata)
+
+              db = ::Legion::Data.connection
+              record = build_escalation_record(db, body, props, headers)
+
+              Helpers::PersistenceLogging.insert_row(
+                db, :llm_escalation_events, record,
+                operation: 'write_escalation_record'
+              )
+              { result: :ok }
+            rescue Sequel::UniqueConstraintViolation => e
+              log.warn("write_escalation_record duplicate insert ignored: #{e.message}")
+              { result: :duplicate }
+            rescue Helpers::DecryptionUnavailable => e
+              handle_exception(e, level: :warn, handled: true, operation: 'write_escalation_record.decrypt')
+              raise
+            rescue Helpers::DecryptionFailed => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_escalation_record.decrypt')
+              raise
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_escalation_record')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def normalize_runner_args(payload, metadata, message)
+              Helpers::SubscriptionMessage.runner_args(payload, metadata, message)
+            end
+
+            def build_escalation_record(db, body, props, headers) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+              history = Array(body[:history])
+              identity = Helpers::CallerIdentity.normalize(
+                caller_raw: body[:caller], identity: body[:identity], headers: headers
+              )
+
+              first_attempt = history.first || {}
+              last_attempt = history.last || {}
+
+              {
+                uuid:                    stable_uuid(props[:message_id] || body[:event_id] || SecureRandom.uuid),
+                conversation_id:         resolve_conversation_id(db, body, headers),
+                request_ref:             body[:request_id] || props[:correlation_id],
+                from_provider:           first_attempt[:provider] || body[:from_provider],
+                from_instance:           first_attempt[:instance] || body[:from_instance],
+                from_model:              first_attempt[:model] || body[:from_model],
+                to_provider:             last_attempt[:provider] || body[:to_provider],
+                to_instance:             last_attempt[:instance] || body[:to_instance],
+                to_model:                last_attempt[:model] || body[:to_model],
+                reason:                  body[:reason] || (first_attempt[:outcome] == 'failure' ? 'provider_failover' : nil),
+                error_category:          body[:error_category] || extract_error_category(first_attempt),
+                attempt_no:              history.size || (body[:attempt_no] || 1),
+                latency_ms:              history.sum { |a| (a[:duration_ms] || 0).to_i } || body[:latency_ms].to_i,
+                identity_canonical_name: identity[:identity],
+                identity_principal_id:   identity[:principal_id],
+                identity_id:             identity[:identity_id],
+                history_json:            history.any? ? Helpers::Json.dump(history) : nil,
+                outcome:                 body[:outcome]&.to_s,
+                total_attempts:          body[:attempts] ? body[:attempts].to_i : history.size,
+                recorded_at:             body[:recorded_at] || body[:timestamp] || Time.now.utc,
+                inserted_at:             Time.now.utc
+              }.compact
+            end
+
+            def resolve_conversation_id(db, body, headers)
+              conv_ref = body[:conversation_id] || headers['x-legion-llm-conversation-id']
+              return nil unless conv_ref # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              conv = db[:llm_conversations].where(uuid: stable_uuid(conv_ref)).first ||
+                     db[:llm_conversations].where(uuid: conv_ref).first
+              conv&.[](:id)
+            end
+
+            def extract_error_category(attempt)
+              failures = Array(attempt[:failures])
+              failures.first.is_a?(Hash) ? failures.first[:category].to_s : nil
+            end
+
+            def stable_uuid(value)
+              raw = value.to_s
+              return raw if raw.length <= 36 # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              hex = Digest::SHA256.hexdigest(raw)[0, 32]
+              "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/runners/metering.rb

@@ -92,18 +92,20 @@ module Legion
                 caller_raw: payload[:caller], identity: payload[:identity], headers: headers
               )
               payload.merge(
-                message_id:        props[:message_id] || payload[:message_id] || ctx[:message_id],
-                correlation_id:    props[:correlation_id] || payload[:correlation_id],
-                conversation_id:   ctx[:conversation_id] || payload[:conversation_id],
-                request_id:        ctx[:request_id] || payload[:request_id],
-                exchange_id:       ctx[:exchange_id] || payload[:exchange_id],
-                operation:         payload[:operation] || payload[:request_type] || headers['x-legion-llm-request-type'],
-                provider:          payload[:provider] || headers['x-legion-llm-provider'],
-                provider_instance: payload[:provider_instance] || payload[:instance],
-                model_id:          payload[:model_id] || headers['x-legion-llm-model'],
-                tier:              payload[:tier] || headers['x-legion-llm-tier'],
-                caller_identity:   identity[:identity],
-                caller_type:       identity[:type]
+                message_id:            props[:message_id] || payload[:message_id] || ctx[:message_id],
+                correlation_id:        props[:correlation_id] || payload[:correlation_id],
+                conversation_id:       ctx[:conversation_id] || payload[:conversation_id],
+                request_id:            ctx[:request_id] || payload[:request_id],
+                exchange_id:           ctx[:exchange_id] || payload[:exchange_id],
+                operation:             payload[:operation] || payload[:request_type] || headers['x-legion-llm-request-type'],
+                provider:              payload[:provider] || headers['x-legion-llm-provider'],
+                provider_instance:     payload[:provider_instance] || payload[:instance],
+                model_id:              payload[:model_id] || headers['x-legion-llm-model'],
+                tier:                  payload[:tier] || headers['x-legion-llm-tier'],
+                caller_identity:       identity[:identity],
+                caller_type:           identity[:type],
+                __header_principal_id: identity[:principal_id],
+                __header_identity_id:  identity[:identity_id]
               )
             end
 

data/lib/legion/extensions/llm/ledger/runners/prompts.rb

@@ -10,6 +10,8 @@ module Legion
       module Ledger
         module Runners
           module Prompts
+            ALLOWED_CLASSIFICATION_LEVELS = %w[public internal confidential restricted].freeze
+
             extend self
 
             def write_prompt_record(payload = nil, metadata = {}, **message)
@@ -137,8 +139,10 @@ module Legion
                 caller_raw: body[:caller], identity: body[:identity], headers: headers
               )
               {
-                caller_identity: identity[:identity],
-                caller_type:     identity[:type]
+                caller_identity:       identity[:identity],
+                caller_type:           identity[:type],
+                __header_principal_id: identity[:principal_id],
+                __header_identity_id:  identity[:identity_id]
               }.compact
             end
 
@@ -165,14 +169,25 @@ module Legion
             end
 
             def official_compliance_payload(body, headers, expires_at)
+              cls = body[:classification] || {}
               {
                 retention_policy:     headers['x-legion-retention'] || body[:retention_policy],
                 expires_at:           expires_at,
-                contains_phi:         headers['x-legion-contains-phi'] == 'true' || body.dig(:classification, :contains_phi),
-                classification_level: body.dig(:classification, :level) || headers['x-legion-classification']
+                contains_phi:         headers['x-legion-contains-phi'] == 'true' || cls[:contains_phi],
+                contains_pii:         cls[:contains_pii] ? true : false,
+                pii_types_json:       Helpers::Json.dump(Array(cls[:pii_types])),
+                classification_level: normalize_classification(cls[:level] || headers['x-legion-classification']),
+                jurisdictions:        Helpers::Json.dump(Array(cls[:jurisdictions]))
               }
             end
 
+            def normalize_classification(level)
+              return 'internal' if level.nil? || level.to_s.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              normalized = level.to_s.downcase
+              ALLOWED_CLASSIFICATION_LEVELS.include?(normalized) ? normalized : 'internal'
+            end
+
             include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                         Legion::Extensions::Helpers.const_defined?(:Lex, false)
           end

data/lib/legion/extensions/llm/ledger/runners/provider_stats.rb

@@ -10,7 +10,7 @@ module Legion
 
             def health_report
               ds = official_metrics
-                   .where { Sequel[:llm_message_inference_metrics][:inserted_at] >= Time.now.utc - 86_400 }
+                   .where { Sequel[:llm_message_inference_metrics][:recorded_at] >= Time.now.utc - 86_400 }
                    .select_group(
                      Sequel[:llm_message_inference_metrics][:provider],
                      Sequel[:llm_message_inference_responses][:provider_instance],

data/lib/legion/extensions/llm/ledger/runners/reconciliation.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'legion/logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module Reconciliation
+            extend self
+            extend Legion::Logging::Helper
+
+            BATCH_SIZE = 200
+            LOOKBACK_SECONDS = 300
+
+            def link_orphaned_tool_calls
+              db = ::Legion::Data.connection
+              linked = 0
+
+              orphans = db[:llm_tool_calls]
+                        .where(message_inference_response_id: nil)
+                        .where { inserted_at >= Time.now.utc - LOOKBACK_SECONDS }
+                        .limit(BATCH_SIZE)
+                        .all
+
+              orphans.each do |tool_call|
+                response = find_response_for_tool_call(db, tool_call)
+                next unless response
+
+                db[:llm_tool_calls].where(id: tool_call[:id]).update(
+                  message_inference_response_id: response[:id]
+                )
+                linked += 1
+              end
+
+              log.info("[ledger] reconciliation: linked #{linked} orphaned tool calls") if linked.positive?
+              { result: :ok, linked: linked }
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'reconciliation.tool_calls')
+              { result: :error, error: e.message }
+            end
+
+            def link_metering_messages
+              db = ::Legion::Data.connection
+              linked = 0
+
+              requests_without_messages = db[:llm_message_inference_requests]
+                                          .where(latest_message_id: nil)
+                                          .where { inserted_at >= Time.now.utc - LOOKBACK_SECONDS }
+                                          .limit(BATCH_SIZE)
+                                          .all
+
+              requests_without_messages.each do |request|
+                next unless request[:conversation_id]
+
+                message = db[:llm_messages]
+                          .where(conversation_id: request[:conversation_id])
+                          .order(Sequel.desc(:seq))
+                          .first
+                next unless message
+
+                db[:llm_message_inference_requests]
+                  .where(id: request[:id])
+                  .update(latest_message_id: message[:id])
+                linked += 1
+              end
+
+              log.info("[ledger] reconciliation: linked #{linked} metering requests to messages") if linked.positive?
+              { result: :ok, linked: linked }
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'reconciliation.metering_messages')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def find_response_for_tool_call(db, tool_call)
+              return nil unless tool_call[:conversation_id] # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              request = db[:llm_message_inference_requests]
+                        .where(conversation_id: tool_call[:conversation_id])
+                        .order(Sequel.desc(:inserted_at))
+                        .first
+              return nil unless request # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              db[:llm_message_inference_responses]
+                .where(message_inference_request_id: request[:id])
+                .first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/runners/retention_purge.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'legion/logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module RetentionPurge
+            extend self
+            extend Legion::Logging::Helper
+
+            PURGEABLE_TABLES = %i[
+              llm_conversations
+            ].freeze
+
+            BATCH_SIZE = 500
+
+            def purge_expired
+              db = ::Legion::Data.connection
+              total_deleted = 0
+
+              PURGEABLE_TABLES.each do |table|
+                next unless db.table_exists?(table)
+
+                deleted = purge_table(db, table)
+                total_deleted += deleted
+                log.info("[ledger] retention_purge: deleted #{deleted} expired rows from #{table}") if deleted.positive?
+              end
+
+              { result: :ok, deleted: total_deleted }
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'retention_purge')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def purge_table(db, table)
+              deleted = 0
+              loop do
+                ids = db[table]
+                      .where { expires_at <= Time.now.utc }
+                      .where(Sequel.~(expires_at: nil))
+                      .select(:id)
+                      .limit(BATCH_SIZE)
+                      .select_map(:id)
+                break if ids.empty?
+
+                db[table].where(id: ids).delete
+                deleted += ids.size
+                break if ids.size < BATCH_SIZE
+              end
+              deleted
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/runners/skills.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+require_relative '../helpers/caller_identity'
+require_relative '../helpers/json'
+require_relative '../helpers/persistence_logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module Skills
+            extend self
+
+            def write_skill_record(payload = nil, metadata = {}, **message)
+              payload, metadata = normalize_runner_args(payload, metadata, message)
+              headers = Helpers::SubscriptionMessage.extract_headers(payload, metadata)
+              props   = metadata[:properties] || {}
+
+              body = payload.is_a?(Hash) ? payload : Helpers::Decryption.decrypt_if_needed(payload, metadata)
+
+              db = ::Legion::Data.connection
+              record = build_skill_record(db, body, props, headers)
+
+              Helpers::PersistenceLogging.insert_row(
+                db, :llm_skill_events, record,
+                operation: 'write_skill_record'
+              )
+              { result: :ok }
+            rescue Sequel::UniqueConstraintViolation => e
+              log.warn("write_skill_record duplicate insert ignored: #{e.message}")
+              { result: :duplicate }
+            rescue Helpers::DecryptionUnavailable => e
+              handle_exception(e, level: :warn, handled: true, operation: 'write_skill_record.decrypt')
+              raise
+            rescue Helpers::DecryptionFailed => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_skill_record.decrypt')
+              raise
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_skill_record')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def normalize_runner_args(payload, metadata, message)
+              Helpers::SubscriptionMessage.runner_args(payload, metadata, message)
+            end
+
+            def build_skill_record(db, body, props, headers)
+              identity = Helpers::CallerIdentity.normalize(
+                caller_raw: body[:caller], identity: body[:identity], headers: headers
+              )
+              skill = body[:skill] || {}
+
+              {
+                uuid:                    stable_uuid(props[:message_id] || body[:event_id] || SecureRandom.uuid),
+                conversation_id:         resolve_conversation_id(db, body, headers),
+                request_ref:             body[:request_id] || props[:correlation_id],
+                skill_name:              skill[:name] || body[:skill_name],
+                skill_version:           skill[:version],
+                trigger:                 skill[:trigger] || body[:trigger],
+                status:                  body[:status] || 'completed',
+                duration_ms:             body[:duration_ms].to_i,
+                identity_canonical_name: identity[:identity],
+                identity_principal_id:   identity[:principal_id],
+                identity_id:             identity[:identity_id],
+                recorded_at:             body[:recorded_at] || body[:timestamp] || Time.now.utc,
+                inserted_at:             Time.now.utc
+              }
+            end
+
+            def resolve_conversation_id(db, body, headers)
+              conv_ref = body[:conversation_id] || headers['x-legion-llm-conversation-id']
+              return nil unless conv_ref # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              conv = db[:llm_conversations].where(uuid: stable_uuid(conv_ref)).first ||
+                     db[:llm_conversations].where(uuid: conv_ref).first
+              conv&.[](:id)
+            end
+
+            def stable_uuid(value)
+              raw = value.to_s
+              return raw if raw.length <= 36 # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              hex = Digest::SHA256.hexdigest(raw)[0, 32]
+              "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/runners/tools.rb

@@ -23,11 +23,6 @@ module Legion
               ctx  = body[:message_context] || {}
               tool = body[:tool_call]       || {}
 
-              Helpers::Retention.resolve(
-                retention:    headers['x-legion-retention'],
-                contains_phi: headers['x-legion-contains-phi'] == 'true'
-              )
-
               db = ::Legion::Data.connection
               response = find_or_resolve_response_with_retry(db, body, ctx, props, headers)
               write_result = [:ok]
@@ -106,7 +101,7 @@ module Legion
               conv&.[](:id)
             end
 
-            def find_or_create_tool_call(db, response, body, ctx, tool, headers, identity_attrs, conversation_id)
+            def find_or_create_tool_call(db, response, body, ctx, tool, headers, identity_attrs, conversation_id) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
               tool_uuid = derive_tool_call_uuid(body, ctx, tool, headers)
               existing  = db[:llm_tool_calls].where(uuid: tool_uuid).first
               return [existing, false] if existing # rubocop:disable Legion/Extension/RunnerReturnHash
@@ -125,6 +120,8 @@ module Legion
               status = tool[:status] || headers['x-legion-tool-status'] || 'success'
               ts     = body[:timestamps] || {}
 
+              result_value = tool[:result] || body[:result]
+              has_result = tool[:result] || body.key?(:result)
               id = insert_with_savepoint(db, :llm_tool_calls, {
                                            uuid:                          tool_uuid,
                                            message_inference_response_id: response_id,
@@ -135,6 +132,12 @@ module Legion
                                            tool_source_type:              src[:type] || headers['x-legion-tool-source-type'],
                                            tool_source_server:            src[:server] || headers['x-legion-tool-source-server'],
                                            status:                        status,
+                                           tool_arguments_json:           tool[:arguments] ? Helpers::Json.dump(tool[:arguments]) : nil,
+                                           tool_result_json:              has_result ? Helpers::Json.dump(result_value) : nil,
+                                           tool_category:                 tool[:category] || tool[:tool_category],
+                                           data_handling_classification:  tool[:data_handling_classification],
+                                           policy_decision:               tool[:policy_decision],
+                                           requires_human_approval:       tool[:requires_human_approval],
                                            requested_at:                  ts[:tool_start] || tool[:started_at],
                                            completed_at:                  ts[:tool_end] || tool[:finished_at],
                                            **identity_attrs,
@@ -149,7 +152,7 @@ module Legion
               [row, false]
             end
 
-            def find_or_create_tool_call_attempt(db, tool_call_row, tool, body, props, headers, identity_attrs) # rubocop:disable Metrics/CyclomaticComplexity
+            def find_or_create_tool_call_attempt(db, tool_call_row, tool, body, props, headers, identity_attrs) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
               return nil unless tool_call_row # rubocop:disable Legion/Extension/RunnerReturnHash
 
               tool_call_id = tool_call_row[:id]
@@ -167,21 +170,24 @@ module Legion
               runner_ref = body[:worker_id] || body[:runner_ref] || props[:app_id]
 
               id = insert_with_savepoint(db, :llm_tool_call_attempts, {
-                                           uuid:           attempt_uuid,
-                                           tool_call_id:   tool_call_id,
-                                           attempt_no:     attempt_no,
-                                           runner_ref:     runner_ref,
-                                           status:         status,
-                                           error_category: error_hash[:category] || error_hash[:type],
-                                           error_code:     error_hash[:code],
-                                           error_message:  error_info.is_a?(String) ? error_info : error_hash[:message],
-                                           duration_ms:    tool[:duration_ms].to_i,
-                                           arguments_ref:  sha256_ref(tool[:arguments]),
-                                           result_ref:     sha256_ref(tool[:result] || body[:result]),
-                                           started_at:     ts[:tool_start] || tool[:started_at],
-                                           ended_at:       ts[:tool_end] || tool[:finished_at],
+                                           uuid:                attempt_uuid,
+                                           tool_call_id:        tool_call_id,
+                                           attempt_no:          attempt_no,
+                                           runner_ref:          runner_ref,
+                                           status:              status,
+                                           error_category:      error_hash[:category] || error_hash[:type],
+                                           error_code:          error_hash[:code],
+                                           error_message:       error_info.is_a?(String) ? error_info : error_hash[:message],
+                                           duration_ms:         tool[:duration_ms].to_i,
+                                           arguments_ref:       sha256_ref(tool[:arguments]),
+                                           result_ref:          sha256_ref(tool[:result] || body[:result]),
+                                           attempt_input_json:  tool[:arguments] ? Helpers::Json.dump(tool[:arguments]) : nil,
+                                           attempt_output_json: Helpers::Json.dump(tool[:result] || body[:result]),
+                                           error_details_json:  tool[:error] ? Helpers::Json.dump(tool[:error]) : nil,
+                                           started_at:          ts[:tool_start] || tool[:started_at],
+                                           ended_at:            ts[:tool_end] || tool[:finished_at],
                                            **identity_attrs,
-                                           inserted_at:    Time.now.utc
+                                           inserted_at:         Time.now.utc
                                          }, operation: 'write_tool_record.attempt')
               db[:llm_tool_call_attempts][id: id]
             rescue Sequel::UniqueConstraintViolation => e

data/lib/legion/extensions/llm/ledger/transport/exchanges/escalation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Transport
+          module Exchanges
+            class Escalation < ::Legion::Transport::Exchange
+              def exchange_name
+                'llm.escalation'
+              end
+
+              def default_type
+                'topic'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/transport/queues/audit_escalations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Transport
+          module Queues
+            class AuditEscalations < Legion::Transport::Queue
+              def queue_name
+                'llm.audit.escalations'
+              end
+
+              def queue_options
+                { durable: true }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/transport/queues/audit_skills.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Transport
+          module Queues
+            class AuditSkills < Legion::Transport::Queue
+              def queue_name
+                'llm.audit.skills'
+              end
+
+              def queue_options
+                { durable: true }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/transport/transport.rb

@@ -3,6 +3,7 @@
 require 'legion/extensions/transport'
 require_relative 'exchanges/metering'
 require_relative 'exchanges/audit'
+require_relative 'exchanges/escalation'
 require_relative 'exchanges/registry'
 
 module Legion
@@ -29,6 +30,16 @@ module Legion
                 to:          Legion::Extensions::Llm::Ledger::Transport::Queues::AuditTools,
                 routing_key: 'audit.tool.#'
               },
+              {
+                from:        Legion::Extensions::Llm::Ledger::Transport::Exchanges::Audit,
+                to:          Legion::Extensions::Llm::Ledger::Transport::Queues::AuditSkills,
+                routing_key: 'audit.skill.#'
+              },
+              {
+                from:        Legion::Extensions::Llm::Ledger::Transport::Exchanges::Escalation,
+                to:          Legion::Extensions::Llm::Ledger::Transport::Queues::AuditEscalations,
+                routing_key: '#'
+              },
               {
                 from:        Legion::Extensions::Llm::Ledger::Transport::Exchanges::Registry,
                 to:          Legion::Extensions::Llm::Ledger::Transport::Queues::RegistryAvailability,

data/lib/legion/extensions/llm/ledger/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ledger
-        VERSION = '0.5.0'
+        VERSION = '0.6.0'
       end
     end
   end

data/lib/legion/extensions/llm/ledger/writers/official_record_writer.rb

@@ -63,6 +63,8 @@ module Legion
                                            classification_level:    classification_level(body),
                                            contains_phi:            contains_phi?(body),
                                            contains_pii:            contains_pii?(body),
+                                           pii_types_json:          json_dump(Array(body.dig(:classification, :pii_types))),
+                                           jurisdictions_json:      json_dump(Array(body.dig(:classification, :jurisdictions) || body[:jurisdictions])),
                                            retention_policy:        body[:retention_policy] || 'default',
                                            expires_at:              body[:expires_at],
                                            identity_canonical_name: identity_canonical_name(body),
@@ -110,7 +112,7 @@ module Legion
               end
             end
 
-            def find_or_create_request(db, conversation, latest_message, body)
+            def find_or_create_request(db, conversation, latest_message, body) # rubocop:disable Metrics/AbcSize
               request_id = request_ref(body)
               existing = db[:llm_message_inference_requests].where(request_ref: request_id).first
               return enrich_request!(db, existing, body, latest_message) if existing
@@ -121,6 +123,7 @@ module Legion
                                            uuid:                    stable_uuid(request_id),
                                            conversation_id:         conversation[:id],
                                            latest_message_id:       latest_message&.dig(:id),
+                                           parent_request_id:       resolve_parent_request_id(db, body),
                                            caller_principal_id:     caller_refs[:principal_id],
                                            caller_identity_id:      caller_refs[:identity_id],
                                            identity_canonical_name: identity_canonical_name(body),
@@ -137,10 +140,15 @@ module Legion
                                            status:                  'responded',
                                            context_message_count:   Array(body.dig(:request, :messages) || body[:messages]).size,
                                            request_capture_mode:    'full',
-                                           request_json:            json_dump(request_payload(body)),
+                                           request_json:            phi_protect(json_dump(request_payload(body)), contains_phi?(body)),
                                            classification_level:    classification_level(body),
                                            cost_center:             billing(body)[:cost_center],
                                            budget_key:              billing(body)[:budget_id] || billing(body)[:budget_key],
+                                           injected_tool_count:     Array(body.dig(:audit, :injected_tools) || body[:injected_tools]).size,
+                                           context_tokens:          resolve_context_tokens(body),
+                                           request_content_hash:    compute_content_hash(body.dig(:request, :content) || body.dig(:audit, :request_content)),
+                                           curation_strategy:       body[:curation_strategy] || body.dig(:audit, :curation_strategy),
+                                           tool_policy:             body[:tool_policy] || body.dig(:audit, :tool_policy),
                                            requested_at:            recorded_at(body),
                                            inserted_at:             Time.now.utc
                                          }, operation: 'official_record_writer.inference_request')
@@ -186,14 +194,15 @@ module Legion
               end
             end
 
-            def find_or_create_response(db, request, response_message, body)
-              response_uuid = stable_uuid(reference(body, :provider_response_ref) || "response:#{request_ref(body)}")
+            def find_or_create_response(db, request, response_message, body) # rubocop:disable Metrics/AbcSize
+              response_uuid = stable_uuid(reference(body, :provider_response_ref) || "response:#{request_ref(body)}:#{body[:provider] || 'unknown'}")
               existing = db[:llm_message_inference_responses].where(uuid: response_uuid).first
               if existing
                 enrich_response!(db, existing, response_message, body)
                 return existing
               end
 
+              phi = contains_phi?(body)
               id = insert_with_savepoint(db, :llm_message_inference_responses, {
                                            uuid:                         response_uuid,
                                            message_inference_request_id: request[:id],
@@ -209,9 +218,15 @@ module Legion
                                            latency_ms:                   integer(body[:latency_ms]),
                                            wall_clock_ms:                integer(body[:wall_clock_ms]),
                                            response_capture_mode:        'full',
-                                           response_json:                json_dump(visible_response(body)),
-                                           response_thinking_json:       json_dump(thinking_response(body)),
+                                           response_json:                phi_protect(json_dump(visible_response(body)), phi),
+                                           response_thinking_json:       phi_protect(json_dump(thinking_response(body)), phi),
                                            dispatch_path:                body[:dispatch_path] || body[:tier],
+                                           error_category:               body[:error_category] || body.dig(:error, :category),
+                                           error_code:                   body[:error_code] || body.dig(:error, :code),
+                                           error_message:                body[:error_message] || body.dig(:error, :message),
+                                           response_content_hash:        compute_content_hash(body[:response_content] || body.dig(:audit, :response_content)),
+                                           route_attempts:               (body[:route_attempts] || body.dig(:audit, :route_attempts)).to_i,
+                                           escalation_chain_ref:         body[:escalation_chain_ref],
                                            identity_principal_id:        caller_identity_refs(db, body)[:principal_id],
                                            identity_id:                  caller_identity_refs(db, body)[:identity_id],
                                            identity_canonical_name:      identity_canonical_name(body),
@@ -377,6 +392,10 @@ module Legion
                 explicit_identity_id = integer_or_nil(body[:caller_identity_id] || body.dig(:caller, :requested_by, :id))
                 explicit_principal_id = integer_or_nil(body[:caller_principal_id] ||
                                                        body.dig(:caller, :requested_by, :principal_id))
+
+                explicit_identity_id ||= integer_or_nil(body[:__header_identity_id])
+                explicit_principal_id ||= integer_or_nil(body[:__header_principal_id])
+
                 refs = { principal_id: explicit_principal_id, identity_id: explicit_identity_id }.compact
                 unless refs[:principal_id] && refs[:identity_id]
                   if explicit_identity_id && !explicit_principal_id && identity_tables_available?(db)
@@ -554,6 +573,18 @@ module Legion
               int.positive? ? int : nil
             end
 
+            def resolve_parent_request_id(db, body)
+              parent_ref = body[:parent_request_id] || body.dig(:context, :parent_request_id)
+              return nil unless present?(parent_ref)
+
+              if parent_ref.is_a?(Integer)
+                parent_ref
+              else
+                parent = db[:llm_message_inference_requests].where(request_ref: parent_ref.to_s).first
+                parent&.dig(:id)
+              end
+            end
+
             def correlation_id(body)
               reference(body, :correlation_id, :correlation_ref) || body.dig(:tracing, :correlation_id)
             end
@@ -656,8 +687,14 @@ module Legion
               body.dig(:response, :finish_reason) || body.dig(:response, :stop, :reason)
             end
 
+            ALLOWED_CLASSIFICATION_LEVELS = %w[public internal confidential restricted].freeze
+
             def classification_level(body)
-              body[:classification_level] || body.dig(:classification, :level)
+              raw = body[:classification_level] || body.dig(:classification, :level)
+              return 'internal' if raw.nil? || raw.to_s.empty?
+
+              normalized = raw.to_s.downcase
+              ALLOWED_CLASSIFICATION_LEVELS.include?(normalized) ? normalized : 'internal'
             end
 
             def contains_phi?(body)
@@ -706,6 +743,19 @@ module Legion
               json_dump(content)
             end
 
+            def phi_protect(json_string, is_phi)
+              return json_string unless is_phi && crypt_available?
+
+              Legion::Crypt.encrypt(json_string)
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'official_record_writer.phi_encrypt')
+              json_string
+            end
+
+            def crypt_available?
+              defined?(Legion::Crypt) && Legion::Crypt.respond_to?(:encrypt)
+            end
+
             def json_dump(value)
               Helpers::Json.dump(value)
             end
@@ -728,6 +778,20 @@ module Legion
             def present?(value)
               !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
             end
+
+            def compute_content_hash(content)
+              return nil if content.nil? || content.to_s.empty?
+
+              Digest::SHA256.hexdigest(json_dump(content))[0..31]
+            end
+
+            def resolve_context_tokens(body)
+              raw = body[:tokens] || body[:audit] || body
+              val = raw[:input_tokens] || raw[:input] || raw[:context_tokens] || raw[:prompt_tokens]
+              return nil unless present?(val)
+
+              val.to_i
+            end
           end
         end
       end

data/lib/legion/extensions/llm/ledger.rb

@@ -18,6 +18,10 @@ require_relative 'ledger/backfill/legacy_llm_records'
 require_relative 'ledger/runners/metering'
 require_relative 'ledger/runners/prompts'
 require_relative 'ledger/runners/tools'
+require_relative 'ledger/runners/skills'
+require_relative 'ledger/runners/escalations'
+require_relative 'ledger/runners/retention_purge'
+require_relative 'ledger/runners/reconciliation'
 require_relative 'ledger/runners/usage_reporter'
 require_relative 'ledger/runners/provider_stats'
 require_relative 'ledger/runners/registry_availability'
@@ -29,12 +33,18 @@ if defined?(Legion::Extensions) && Legion::Extensions.const_defined?(:Core, fals
   require_relative 'ledger/transport/queues/metering_write'
   require_relative 'ledger/transport/queues/audit_prompts'
   require_relative 'ledger/transport/queues/audit_tools'
+  require_relative 'ledger/transport/queues/audit_skills'
+  require_relative 'ledger/transport/queues/audit_escalations'
   require_relative 'ledger/transport/queues/registry_availability'
   require_relative 'ledger/transport/transport'
   require_relative 'ledger/actors/metering'
   require_relative 'ledger/actors/prompts'
   require_relative 'ledger/actors/tools'
+  require_relative 'ledger/actors/skills'
+  require_relative 'ledger/actors/escalations'
   require_relative 'ledger/actors/registry_availability'
+  require_relative 'ledger/actors/retention_purge'
+  require_relative 'ledger/actors/reconciliation'
   require_relative 'ledger/actors/spool_flush'
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ledger
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Esity
@@ -191,9 +191,13 @@ files:
 - Rakefile
 - lex-llm-ledger.gemspec
 - lib/legion/extensions/llm/ledger.rb
+- lib/legion/extensions/llm/ledger/actors/escalations.rb
 - lib/legion/extensions/llm/ledger/actors/metering.rb
 - lib/legion/extensions/llm/ledger/actors/prompts.rb
+- lib/legion/extensions/llm/ledger/actors/reconciliation.rb
 - lib/legion/extensions/llm/ledger/actors/registry_availability.rb
+- lib/legion/extensions/llm/ledger/actors/retention_purge.rb
+- lib/legion/extensions/llm/ledger/actors/skills.rb
 - lib/legion/extensions/llm/ledger/actors/spool_flush.rb
 - lib/legion/extensions/llm/ledger/actors/tools.rb
 - lib/legion/extensions/llm/ledger/backfill/legacy_llm_records.rb
@@ -217,16 +221,23 @@ files:
 - lib/legion/extensions/llm/ledger/helpers/retention.rb
 - lib/legion/extensions/llm/ledger/helpers/subscription_actor.rb
 - lib/legion/extensions/llm/ledger/helpers/subscription_message.rb
+- lib/legion/extensions/llm/ledger/runners/escalations.rb
 - lib/legion/extensions/llm/ledger/runners/metering.rb
 - lib/legion/extensions/llm/ledger/runners/prompts.rb
 - lib/legion/extensions/llm/ledger/runners/provider_stats.rb
+- lib/legion/extensions/llm/ledger/runners/reconciliation.rb
 - lib/legion/extensions/llm/ledger/runners/registry_availability.rb
+- lib/legion/extensions/llm/ledger/runners/retention_purge.rb
+- lib/legion/extensions/llm/ledger/runners/skills.rb
 - lib/legion/extensions/llm/ledger/runners/tools.rb
 - lib/legion/extensions/llm/ledger/runners/usage_reporter.rb
 - lib/legion/extensions/llm/ledger/transport/exchanges/audit.rb
+- lib/legion/extensions/llm/ledger/transport/exchanges/escalation.rb
 - lib/legion/extensions/llm/ledger/transport/exchanges/metering.rb
 - lib/legion/extensions/llm/ledger/transport/exchanges/registry.rb
+- lib/legion/extensions/llm/ledger/transport/queues/audit_escalations.rb
 - lib/legion/extensions/llm/ledger/transport/queues/audit_prompts.rb
+- lib/legion/extensions/llm/ledger/transport/queues/audit_skills.rb
 - lib/legion/extensions/llm/ledger/transport/queues/audit_tools.rb
 - lib/legion/extensions/llm/ledger/transport/queues/metering_write.rb
 - lib/legion/extensions/llm/ledger/transport/queues/registry_availability.rb