lex-llm 0.7.3 → 0.8.0

data/lib/legion/extensions/llm/fleet/worker_execution.rb

@@ -5,6 +5,7 @@ require 'concurrent'
 require_relative 'protocol'
 require_relative 'settings'
 require_relative 'token_validator'
+require_relative 'fleet_envelope'
 require 'legion/extensions/llm/taxonomies'
 require 'legion/extensions/llm/inventory/errors'
 require 'legion/extensions/llm/inventory/identity'
@@ -14,7 +15,9 @@ module Legion
   module Extensions
     module Llm
       module Fleet
-        # Applies responder-side policy and dispatches a fleet request to a local lex-llm provider.
+        # Applies responder-side policy and executes a fleet request against
+        # the captured registry callable. Protocol v3: exact execution only —
+        # one dispatch path (06 W1/W3), no provider-object topology.
         module WorkerExecution
           include Legion::Logging::Helper
           extend Legion::Logging::Helper
@@ -26,14 +29,17 @@ module Legion
 
           module_function
 
-          def call(envelope:, registry: nil, provider: nil)
-            validate_dispatch_target!(registry, provider)
+          # The single dispatch entry (06 W1).
+          def call(envelope:, registry:)
+            raise PolicyError, 'WorkerExecution.call requires registry' if registry.nil?
+
+            envelope = FleetEnvelope.wrap(envelope)
             claims = nil
             idempotency_key = nil
             claims = validate_identity!(envelope)
             validate_policy!(envelope)
             idempotency_key = validate_idempotency!(envelope)
-            response = dispatch!(envelope: envelope, registry: registry, provider: provider)
+            response = dispatch!(envelope:, registry:)
             mark_idempotency_success!(idempotency_key) if idempotency_key
             TokenValidator.mark_replay!(claims[:jti]) if claims.is_a?(Hash)
             response
@@ -52,115 +58,51 @@ module Legion
           def validate_identity!(envelope)
             return true unless responder_setting(:require_auth, default: true)
 
-            TokenValidator.validate!(token: envelope_value(envelope, :signed_token), envelope: envelope)
+            TokenValidator.validate!(token: envelope.signed_token, envelope: envelope.to_h)
           end
 
-          def validate_policy!(_envelope) # rubocop:disable Naming/PredicateMethod
+          # W6 fail-closed: require_policy with no policy engine configured
+          # RAISES. The v2 warn-and-allow is deleted.
+          def validate_policy!(_envelope)
             return true unless responder_setting(:require_policy, default: false)
 
-            log.warn('[fleet] require_policy is enabled but no policy engine is configured — allowing request')
-            true
+            raise PolicyError, 'require_policy is enabled but no policy engine is configured'
           end
 
           def validate_idempotency!(envelope)
             return nil unless responder_setting(:require_idempotency, default: true)
 
-            key = envelope_value(envelope, :idempotency_key)
+            key = envelope.idempotency_key
             raise PolicyError, 'fleet idempotency_key is required' if key.to_s.empty?
 
             reserve_idempotency_key!(key.to_s)
             key.to_s
           end
 
-          def dispatch_local_provider!(envelope:, provider:)
-            provider = provider.call(envelope) if provider.respond_to?(:call) && !provider.respond_to?(:chat)
-            operation = envelope_value(envelope, :operation).to_sym
-            params = normalize_hash(envelope_value(envelope, :params) || {})
-            params = unpack_legacy_options(params)
-            model = envelope_value(envelope, :model)
-
-            case operation
-            when :chat
-              provider.chat(messages: params.fetch(:messages, []), model: model, **except(params, :messages))
-            when :stream
-              provider.stream_chat(messages: params.fetch(:messages, []), model: model, **except(params, :messages))
-            when :embed
-              provider.embed(text: params[:text], model: model, **except(params, :text))
-            when :count_tokens
-              provider.count_tokens(messages: params.fetch(:messages, []), model: model, **except(params, :messages))
-            else
-              raise PolicyError, "unsupported fleet operation: #{operation}"
-            end
-          end
-
           ERRORS = Legion::Extensions::Llm::Inventory::Errors
           IDENTITY = Legion::Extensions::Llm::Inventory::Identity
 
-          def validate_dispatch_target!(registry, provider)
-            return unless registry.nil? == provider.nil?
-
-            raise PolicyError, 'WorkerExecution.call requires exactly one of registry or provider'
-          end
-
-          def dispatch!(envelope:, registry:, provider:)
-            return dispatch_local_provider!(envelope: envelope, provider: provider) if provider
-
-            if envelope_value(envelope, :execution_contract) == Protocol::EXACT_EXECUTION_CONTRACT
-              exact_dispatch!(envelope: envelope, registry: registry)
-            else
-              legacy_registry_dispatch!(envelope: envelope, registry: registry)
-            end
-          end
-
-          # Exact path: resolve by signed offering_id; no model resolution, provider
-          # scan, :default, or first value.
-          def exact_dispatch!(envelope:, registry:)
+          # The one dispatcher (06 W3): the exact resolution chain (W2). The
+          # claim's offering_id value is the lane's 5 tuple (field name kept for
+          # protocol continuity, D4); the claim resolves a lane exactly. The
+          # REQUESTED operation (envelope) is what gets dispatched — the lane
+          # constrains type/model/instance, the operation is a request property.
+          def dispatch!(envelope:, registry:)
             snapshot = registry.snapshot
-            instance_key = exact_instance_key(envelope)
+            instance_key = IDENTITY::InstanceKey.new(
+              provider_family: envelope.provider, instance_id: envelope.provider_instance
+            )
             record = available_record!(snapshot, instance_key)
-            offering = record.offerings_by_id[envelope_value(envelope, :offering_id)]
-            raise ERRORS::ExactOfferingMismatchError, 'offering_id not on the activated instance' if offering.nil?
-
             operation = exact_operation(envelope)
-            model = require_matching_model!(offering, envelope)
-            require_supported!(offering, operation)
-            execute_via_lane(registry, snapshot,
-                             { record: record, offering: offering, operation: operation, model: model, envelope: envelope })
-          end
-
-          # Registry-backed v2 compatibility path for a migrated provider: execute
-          # only when (provider_family, instance, operation, model) resolves to
-          # exactly one supported local offering.
-          def legacy_registry_dispatch!(envelope:, registry:)
-            snapshot = registry.snapshot
-            instance_key = exact_instance_key(envelope)
-            record = available_record!(snapshot, instance_key)
-            operation = Legion::Extensions::Llm::Taxonomies.normalize_operation(value: envelope_value(envelope, :operation), allow_aliases: true)
-            model = IDENTITY.normalize_text(value: envelope_value(envelope, :model), field: :model)
-            matches = record.offerings_by_id.values.select { |o| o.model == model && o.operation_status(operation: operation) == :supported }
-            raise ERRORS::ExactOfferingMismatchError, 'no matching local offering' if matches.empty?
-            raise ERRORS::AmbiguousLegacyOfferingError, 'multiple matching local offerings' if matches.size > 1
-
-            execute_via_lane(registry, snapshot,
-                             { record: record, offering: matches.first, operation: operation, model: model, envelope: envelope })
-          end
-
-          def execute_via_lane(registry, snapshot, resolution)
-            lane = matching_lane!(snapshot, resolution[:record], resolution[:offering], resolution[:operation], resolution[:model])
+            lane = exact_lane!(snapshot, record, envelope, operation)
             lease = registry.acquire(callable_handle: lane.callable_handle)
             begin
-              dispatch_operation(lease.callable, resolution[:operation], resolution[:model], exact_params(resolution[:envelope]))
+              dispatch_operation(lease.callable, operation, lane.model, exact_params(envelope))
             ensure
               lease.release
             end
           end
 
-          def exact_instance_key(envelope)
-            IDENTITY::InstanceKey.new(
-              provider_family: envelope_value(envelope, :provider), instance_id: envelope_value(envelope, :provider_instance)
-            )
-          end
-
           def available_record!(snapshot, instance_key)
             record = snapshot.instance(instance_key: instance_key)
             raise ERRORS::ExactOfferingMismatchError, 'instance is absent, initializing, or unavailable' unless record && record.availability.state == :available
@@ -168,97 +110,134 @@ module Legion
             record
           end
 
-          def exact_operation(envelope)
-            Legion::Extensions::Llm::Taxonomies.normalize_operation(value: envelope_value(envelope, :operation), allow_aliases: false)
-          end
+          # The exact lane the claim names: the 5-tuple claim value must parse
+          # and validate, resolve in the snapshot, and agree with the activated
+          # instance, the envelope's operation type, and the envelope's model.
+          # The operation is a request property matched against the lane type —
+          # the lane's operation member is the representative of its type, not
+          # the identity.
+          def exact_lane!(snapshot, record, envelope, operation)
+            IDENTITY.validate_lane_id!(value: envelope.offering_id)
+            lane = snapshot.lane(lane_id: envelope.offering_id)
+            raise ERRORS::ExactOfferingMismatchError, 'lane_id not on the activated instance' if lane.nil?
+            unless lane.instance_key == record.instance_key && lane.callable_handle.equal?(record.callable_handle)
+              raise ERRORS::ExactOfferingMismatchError, 'lane does not belong to the activated instance'
+            end
 
-          def require_matching_model!(offering, envelope)
-            model = IDENTITY.normalize_text(value: envelope_value(envelope, :model), field: :model)
-            raise ERRORS::ExactOfferingMismatchError, 'model does not match the offering' unless offering.model == model
+            require_matching_operation!(lane, operation)
+            require_matching_model!(lane, envelope)
+            lane
+          end
 
-            model
+          # 06 §5: an unknown operation is a contract error at the worker.
+          def exact_operation(envelope)
+            Legion::Extensions::Llm::Taxonomies.normalize_operation(value: envelope.operation)
+          rescue Legion::Extensions::Llm::Inventory::Errors::ValidationError
+            raise ContractError, "unsupported exact operation: #{envelope.operation}"
           end
 
-          def require_supported!(offering, operation)
-            return if offering.operation_status(operation: operation) == :supported
+          def require_matching_operation!(lane, operation)
+            lane_type = Legion::Extensions::Llm::Taxonomies.lane_type_for(operation: lane.operation)
+            return if Legion::Extensions::Llm::Taxonomies.lane_type_for(operation: operation) == lane_type
 
-            raise ERRORS::ExactOfferingMismatchError, "operation #{operation} is not supported by the offering"
+            raise ERRORS::ExactOfferingMismatchError, "operation #{operation} does not match the claimed lane type"
           end
 
-          def matching_lane!(snapshot, record, offering, operation, model)
-            lane_id = IDENTITY.lane_id(instance_key: record.instance_key, operation: operation, model: model, offering_id: offering.offering_id)
-            lane = snapshot.lane(lane_id: lane_id)
-            valid = lane && lane.offering_id == offering.offering_id && lane.instance_key == record.instance_key &&
-                    lane.model == model && lane.operation == operation && lane.callable_handle.equal?(record.callable_handle)
-            raise ERRORS::ExactOfferingMismatchError, 'no matching lane for the offering' unless valid
+          def require_matching_model!(lane, envelope)
+            model = IDENTITY.normalize_text(value: envelope.model, field: :model)
+            raise ERRORS::ExactOfferingMismatchError, 'model does not match the lane' unless lane.model == model
 
-            lane
+            model
           end
 
+          # W5 params strictness: no :model key (the Selection-derived model is
+          # untouchable), no duplicate param spellings. Shape violations are
+          # contract errors (06 §5), not offering mismatches.
           def exact_params(envelope)
-            raw = envelope_value(envelope, :params) || {}
+            raw = envelope.params || {}
             params = {}
             raw.each do |key, value|
               sym = key.respond_to?(:to_sym) ? key.to_sym : key
-              raise ERRORS::ExactOfferingMismatchError, "duplicate param spelling for #{sym}" if params.key?(sym)
+              raise ContractError, "duplicate param spelling for #{sym}" if params.key?(sym)
 
               params[sym] = value
             end
-            raise ERRORS::ExactOfferingMismatchError, 'params must not contain model' if params.key?(:model)
+            raise ContractError, 'params must not contain model' if params.key?(:model)
 
             params
           end
 
+          # W4 — the named rehydration boundary: the ONLY place serialized wire
+          # messages become Canonical::Message. Non-Hash/non-Message elements
+          # are contract errors.
+          def rehydrate_wire_messages(value)
+            Array(value).map do |message|
+              next message if message.is_a?(Canonical::Message)
+
+              unless message.is_a?(Hash)
+                raise ContractError,
+                      "fleet wire message must be a serialized Canonical::Message, got #{message.class}"
+              end
+
+              Canonical::Message.from_hash(message)
+            end
+          end
+
           def dispatch_operation(callable, operation, model, params)
             case operation
-            when :chat then callable.chat(messages: require_param!(params, :messages, operation), model: model, **except(params, :messages))
-            when :stream_chat then callable.stream_chat(messages: require_param!(params, :messages, operation), model: model, **except(params, :messages))
-            when :count_tokens then callable.count_tokens(messages: require_param!(params, :messages, operation), model: model, **except(params, :messages))
-            when :embed then callable.embed(text: require_param!(params, :text, operation), model: model, **except(params, :text))
-            when :image then dispatch_image(callable, model, params)
-            when :transcribe then dispatch_audio(callable, :transcribe, model, params)
-            when :translate then dispatch_audio(callable, :translate, model, params)
-            when :speak then dispatch_speak(callable, model, params)
-            when :moderate then callable.moderate(require_param!(params, :input, operation), model: model, **except(params, :input))
-            else raise ERRORS::ExactOfferingMismatchError, "unsupported exact operation: #{operation}"
+            when :chat
+              callable.chat(rehydrate_wire_messages(require_param!(params, :messages, operation)), model: model,
+                                                                                                   **params.except(:messages))
+            when :stream_chat
+              callable.stream_chat(rehydrate_wire_messages(require_param!(params, :messages, operation)), model: model,
+                                                                                                          **params.except(:messages))
+            when :count_tokens
+              callable.count_tokens(messages: rehydrate_wire_messages(require_param!(params, :messages, operation)), model: model,
+                                    **params.except(:messages))
+            when :embed
+              callable.embed(text: require_param!(params, :text, operation), model: model, **params.except(:text))
+            when :image
+              dispatch_image(callable, model, params)
+            when :transcribe
+              dispatch_audio(callable, :transcribe, model, params)
+            when :translate
+              dispatch_audio(callable, :translate, model, params)
+            when :speak
+              dispatch_speak(callable, model, params)
+            when :moderate
+              callable.moderate(input: require_param!(params, :input, operation), model: model, **params.except(:input))
+            else
+              raise ContractError, "unsupported exact operation: #{operation}"
             end
           end
 
           def dispatch_image(callable, model, params)
             require_param!(params, :prompt, :image)
             require_param!(params, :size, :image)
-            callable.image(prompt: params[:prompt], model: model, **except(params, :prompt))
+            callable.image(prompt: params[:prompt], model: model, **params.except(:prompt))
           end
 
           def dispatch_audio(callable, operation, model, params)
             require_param!(params, :audio_file, operation)
-            raise ERRORS::ExactOfferingMismatchError, "#{operation} requires the language key" unless params.key?(:language)
+            raise ContractError, "#{operation} requires the language key" unless params.key?(:language)
 
             callable.public_send(
               operation, params[:audio_file], model: model, language: params[:language],
-                                              **except(params, :audio_file, :model, :language)
+                                              **params.except(:audio_file, :model, :language)
             )
           end
 
           def dispatch_speak(callable, model, params)
             require_param!(params, :text, :speak)
-            callable.speak(params[:text], model: model, voice: params[:voice], **except(params, :text, :model, :voice))
+            callable.speak(params[:text], model: model, voice: params[:voice], **params.except(:text, :model, :voice))
           end
 
           def require_param!(params, key, operation)
-            raise ERRORS::ExactOfferingMismatchError, "#{operation} requires the #{key} param" unless params.key?(key)
+            raise ContractError, "#{operation} requires the #{key} param" unless params.key?(key)
 
             params[key]
           end
 
-          def unpack_legacy_options(params)
-            options = params.delete(:options)
-            return params unless options.is_a?(Hash)
-
-            normalize_hash(options).each { |key, value| params[key] = value unless params.key?(key) }
-            params
-          end
-
           def reset_idempotency_cache!
             @idempotency_keys = Concurrent::Map.new
             @idempotency_mutex = Mutex.new
@@ -325,28 +304,6 @@ module Legion
           def auth_required?
             Settings.value(:fleet, :auth, :require_signed_token, default: true) != false
           end
-
-          def envelope_value(envelope, key)
-            return nil unless envelope.respond_to?(:key?)
-
-            envelope[key] || envelope[key.to_s]
-          end
-
-          def normalize_hash(hash)
-            return {} unless hash.respond_to?(:each)
-
-            hash.each_with_object({}) do |(key, value), result|
-              result[key.respond_to?(:to_sym) ? key.to_sym : key] = value
-            end
-          end
-
-          def except(hash, *keys)
-            exclusions = keys.map(&:to_sym)
-            hash.each_with_object({}) do |(key, value), result|
-              normalized_key = key.respond_to?(:to_sym) ? key.to_sym : key
-              result[normalized_key] = value unless exclusions.include?(normalized_key)
-            end
-          end
         end
       end
     end

data/lib/legion/extensions/llm/inventory/errors.rb

@@ -26,7 +26,6 @@ module Legion
           class StaleCallableError < Error; end
           class CallableDisposedError < Error; end
           class ExactOfferingMismatchError < Error; end
-          class AmbiguousLegacyOfferingError < Error; end
         end
       end
     end

data/lib/legion/extensions/llm/inventory/evidence.rb

@@ -51,7 +51,7 @@ module Legion
         # canonicalizes into capability `streaming`.
         OperationEvidence = ::Data.define(:operation, :status, :source, :observed_at, :metadata) do
           def initialize(operation:, status:, source:, observed_at: nil, metadata: {})
-            canonical_operation = Taxonomies.normalize_operation(value: operation, allow_aliases: false)
+            canonical_operation = Taxonomies.normalize_operation(value: operation)
             Evidence.validate_evidence_status(status: status, allowed: Taxonomies::OPERATION_EVIDENCE_STATES)
             Evidence.validate_evidence_source(source: source)
             Evidence.enforce_unknown_only_source!(status: status, source: source)

data/lib/legion/extensions/llm/inventory/identity.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'legion/extensions/llm/inventory/errors'
+require 'legion/extensions/llm/taxonomies'
 
 module Legion
   module Extensions
     module Llm
       module Inventory
-        # Canonical field normalization plus the `off:v1:` and `lane:v1:`
-        # length-framed SHA-256 encoders/validators. See
-        # phase-1-lex-llm-additive.md section 8.
-        #
-        # Framing is binary: decimal UTF-8 byte length, ASCII ':', then the exact
-        # UTF-8 bytes. It never uses a delimiter join, Ruby hash order, object ID,
-        # or Ruby Hash#hash. Tier is never an identity input.
+        # Canonical field normalization plus the ONE 5-tuple lane-id composer.
+        # The lane id is `tier:provider_family:instance_id:type:model`, composed
+        # here and ONLY here (G22). Every surface that needs an id calls
+        # compose_lane_id; validation is shape/parse checks against Taxonomies
+        # (R1 boundary contract — it enforces the shape the code produces).
+        # The code produces ONLY 5-tuples; nothing else is guarded against.
         module Identity
           module_function
 
@@ -42,46 +41,63 @@ module Legion
             candidate
           end
 
-          def length_frame(value:)
-            bytes = value.to_s.b
-            "#{bytes.bytesize}:".b + bytes
+          # The ONE 5-tuple composer (G22): byte-identical to the v0.6.16
+          # ScopedRefresher.compose_id. A pure join of the five identity fields —
+          # no normalization here; the fields are normalized by their owners
+          # (TIERS/TYPES symbols, InstanceKey, normalize_text) before composing.
+          def compose_lane_id(tier:, provider_family:, instance_id:, type:, model:)
+            "#{tier}:#{provider_family}:#{instance_id}:#{type}:#{model}"
           end
 
-          def offering_id(instance_key:, provider_native_key:)
-            digest = ::Digest::SHA256.hexdigest(
-              length_frame(value: instance_key.provider_family) +
-              length_frame(value: instance_key.instance_id) +
-              length_frame(value: provider_native_key)
-            )
-            "off:v1:#{digest}"
-          end
+          # Bounded parse: split(':', 5) — the 5th part keeps its colons, which
+          # is load-bearing: model names contain ':' (Ollama model:tag, Bedrock
+          # model ids). Structural only — field semantics are validate_lane_id!'s.
+          def parse_lane_id(id)
+            raise Errors::ValidationError, 'lane id must be a String or Symbol' unless text_input?(id)
+
+            parts = id.to_s.split(':', 5)
+            raise Errors::ValidationError, "lane id must have exactly 5 parts, got #{parts.length}" unless parts.length == 5
 
-          def lane_id(instance_key:, operation:, model:, offering_id:)
-            digest = ::Digest::SHA256.hexdigest(
-              "lane-v1\x00".b +
-              length_frame(value: instance_key.provider_family) +
-              length_frame(value: instance_key.instance_id) +
-              length_frame(value: operation) +
-              length_frame(value: model) +
-              length_frame(value: offering_id)
-            )
-            "lane:v1:#{digest}"
+            parts.freeze
           end
 
-          def validate_offering_id!(value:, instance_key:, provider_native_key:)
-            expected = offering_id(instance_key: instance_key, provider_native_key: provider_native_key)
-            raise Errors::ValidationError, 'offering_id does not reproduce from its identity fields' unless value == expected
+          # Shape validation (R1 boundary contract): exactly 5 parts (bounded
+          # split — the model keeps its colons), part 1 in TIERS, part 4 in
+          # TYPES, parts 2/3/5 nonempty NFC. Any value that is not a 5 tuple
+          # fails the part-count check on its own — there is no special case
+          # for anything else.
+          def validate_lane_id!(value:)
+            parts = parse_lane_id(value)
+            tier, provider_family, instance_id, type, model = parts
+            raise Errors::ValidationError, "lane id tier must be a Taxonomies::TIERS value, got #{tier}" \
+              unless Taxonomies::TIERS.include?(tier.to_sym)
+            raise Errors::ValidationError, "lane id type must be a Taxonomies::TYPES value, got #{type}" \
+              unless Taxonomies::TYPES.include?(type.to_sym)
+            raise Errors::ValidationError, 'lane id provider_family must be a nonempty NFC String' \
+              unless nonempty_nfc?(provider_family)
+            raise Errors::ValidationError, 'lane id instance_id must be a nonempty NFC String' \
+              unless nonempty_nfc?(instance_id)
+            raise Errors::ValidationError, 'lane id model must be a nonempty NFC String' \
+              unless nonempty_nfc?(model)
 
             value
           end
 
-          def validate_lane_id!(value:, instance_key:, operation:, model:, offering_id:)
-            expected = lane_id(
-              instance_key: instance_key, operation: operation, model: model, offering_id: offering_id
-            )
-            raise Errors::ValidationError, 'lane_id does not reproduce from its identity fields' unless value == expected
+          def nonempty_nfc?(string)
+            !string.empty? && string.unicode_normalized?(:nfc)
+          end
 
-            value
+          # M6: the ONE config→instance-id derivation (R6 owner law).
+          # Instance identity is the operator's CONFIG NAME from the provider
+          # config; when the operator configured no instance name, "default"
+          # is the ordinary label (no reserved values — see InstanceKey).
+          # Consumers CARRY this derivation; they never mint a local variant
+          # (node canonical names, family fallbacks, and read-time synthesis
+          # are deleted).
+          def instance_id(config)
+            return config.instance_id.to_s if config.respond_to?(:instance_id) && config.instance_id
+
+            'default'
           end
 
           def text_input?(value)
@@ -96,7 +112,7 @@ module Legion
             string.encoding == ::Encoding::UTF_8 ? string.dup : string.b.dup.force_encoding(::Encoding::UTF_8)
           end
 
-          private_class_method :text_input?, :valid_utf8?, :utf8
+          private_class_method :text_input?, :valid_utf8?, :utf8, :nonempty_nfc?
 
           # A mandatory, immutable provider_family + instance_id pair. Provider
           # family alone is never executable; two instances of the same provider

data/lib/legion/extensions/llm/inventory/probe_token.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'securerandom'
 require 'legion/extensions/llm/inventory/errors'
 require 'legion/extensions/llm/inventory/identity'
@@ -12,24 +11,22 @@ module Legion
         # An opaque fenced publisher claim token. The raw secret is never
         # serialized, logged, included in a record/snapshot/exception, returned
         # separately, or compared for order. `publisher_id` and
-        # `publisher_token_id` are safe correlation/fencing values derived from
-        # the secret. See phase-1-lex-llm-additive.md section 11.1.
+        # `publisher_token_id` are safe UUID correlation values — the id law
+        # forbids digest-encoded ids on any wire/DB/log surface, so the token
+        # id is a UUID like every other lifecycle handle, NOT a derivation of
+        # the secret. Fencing is the constant-time secret comparison; the
+        # public ids correlate, they do not authenticate.
+        # See phase-1-lex-llm-additive.md section 11.1.
         class PublisherToken
-          TOKEN_ID_DOMAIN = "publisher-token-id-v1\x00"
-
           attr_reader :instance_key, :publisher_id, :publisher_token_id
 
-          def self.derive_token_id(secret)
-            "ptok:v1:#{::Digest::SHA256.hexdigest(TOKEN_ID_DOMAIN.b + secret.b)}"
-          end
-
-          # Factory used by the registry: builds a fresh secret and derives the
-          # public correlation IDs from it.
+          # Factory used by the registry: builds a fresh secret and mints the
+          # public correlation IDs.
           def self.issue(instance_key:)
             secret = ::SecureRandom.hex(32)
             new(
               instance_key: instance_key, secret: secret,
-              publisher_id: "pub:v1:#{::SecureRandom.uuid}", publisher_token_id: derive_token_id(secret)
+              publisher_id: "pub:v1:#{::SecureRandom.uuid}", publisher_token_id: "ptok:v1:#{::SecureRandom.uuid}"
             )
           end