lex-llm 0.7.3 → 0.8.0

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'legion/logging'
 require 'legion/extensions/llm/inventory/errors'
 require 'legion/extensions/llm/inventory/identity'
 require 'legion/extensions/llm/inventory/registry'
@@ -12,16 +11,14 @@ module Legion
         # Provider-facing direct wrapper over the local Registry. It constructs
         # and validates the exact InstanceKey from its fixed provider family and
         # delegates to the registry with the exact kwargs. It does no retries,
-        # selection, scheduling, defaulting, provider discovery, or exception
-        # swallowing beyond the explicitly injected, best-effort post-commit
-        # old-coordinator projection. See phase-1-lex-llm-additive.md section 13.1.
+        # selection, scheduling, defaulting, or provider discovery. M7: the
+        # legacy dual-sink seam (compatibility_adapter / old-coordinator
+        # projection) is deleted — one representation, one routing authority;
+        # the SSOT registry is the only inventory sink.
         class Publisher
-          include Legion::Logging::Helper
-
-          def initialize(provider_family:, registry: Registry, compatibility_adapter: nil)
+          def initialize(provider_family:, registry: Registry)
             @provider_family = provider_family
             @registry = registry
-            @compatibility_adapter = compatibility_adapter
           end
 
           # Every instance operation takes `instance_id:` — the operator's
@@ -30,9 +27,7 @@ module Legion
           # dedup and diagnostics only. See Identity::InstanceKey.
           def claim_instance(instance_id:, callable:, probe_request_handle:, physical_id: nil)
             key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            token = @registry.claim_instance(instance_key: key, callable: callable, probe_request_handle: probe_request_handle)
-            sync_compatibility(key, :claimed)
-            token
+            @registry.claim_instance(instance_key: key, callable: callable, probe_request_handle: probe_request_handle)
           end
 
           def readiness_probe_started(instance_id:, publisher_token:, physical_id: nil)
@@ -42,35 +37,29 @@ module Legion
           end
 
           def activate_instance_snapshot(instance_id:, publisher_token:, offerings:, sequence:, probe_token:, physical_id: nil) # rubocop:disable Metrics/ParameterLists
-            key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            result = @registry.activate_instance_snapshot(
-              publisher_token: publisher_token, instance_key: key, offerings: offerings,
-              sequence: sequence, probe_token: probe_token
+            @registry.activate_instance_snapshot(
+              publisher_token: publisher_token, instance_key: instance_key(instance_id: instance_id, physical_id: physical_id),
+              offerings: offerings, sequence: sequence, probe_token: probe_token
             )
-            sync_applied(key, result)
           end
 
           def replace_instance_snapshot(instance_id:, publisher_token:, offerings:, sequence:, physical_id: nil)
-            key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            result = @registry.replace_instance_snapshot(
-              publisher_token: publisher_token, instance_key: key, offerings: offerings, sequence: sequence
+            @registry.replace_instance_snapshot(
+              publisher_token: publisher_token, instance_key: instance_key(instance_id: instance_id, physical_id: physical_id),
+              offerings: offerings, sequence: sequence
             )
-            sync_applied(key, result)
           end
 
           def readiness_succeeded(instance_id:, probe_token:, physical_id: nil)
-            key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            sync_applied(key, @registry.readiness_succeeded(instance_key: key, probe_token: probe_token))
+            @registry.readiness_succeeded(instance_key: instance_key(instance_id: instance_id, physical_id: physical_id), probe_token: probe_token)
           end
 
           def readiness_failed(instance_id:, probe_token:, reason:, physical_id: nil)
-            key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            sync_applied(key, @registry.readiness_failed(instance_key: key, probe_token: probe_token, reason: reason))
+            @registry.readiness_failed(instance_key: instance_key(instance_id: instance_id, physical_id: physical_id), probe_token: probe_token, reason: reason)
           end
 
           def remove_instance(instance_id:, publisher_token:, physical_id: nil)
-            key = instance_key(instance_id: instance_id, physical_id: physical_id)
-            sync_applied(key, @registry.remove_instance(instance_key: key, publisher_token: publisher_token))
+            @registry.remove_instance(instance_key: instance_key(instance_id: instance_id, physical_id: physical_id), publisher_token: publisher_token)
           end
 
           def snapshot
@@ -82,33 +71,6 @@ module Legion
           def instance_key(instance_id:, physical_id: nil)
             Identity::InstanceKey.new(provider_family: @provider_family, instance_id: instance_id, physical_id: physical_id)
           end
-
-          def sync_applied(instance_key, result)
-            sync_compatibility(instance_key, result.reason) if result.applied
-            result
-          end
-
-          # Best-effort, post-commit projection into the old coordinator. It never
-          # changes the local return and can never roll back or authorize the SSOT.
-          def sync_compatibility(instance_key, mutation_reason)
-            return if @compatibility_adapter.nil?
-
-            outcome = @compatibility_adapter.sync_snapshot(
-              snapshot: @registry.snapshot, instance_key: instance_key, mutation_reason: mutation_reason
-            )
-            return unless outcome == :failed
-
-            log.warn(
-              '[llm][inventory][publisher] action=compatibility_sync result=failed ' \
-              "provider_family=#{instance_key.provider_family} instance=#{instance_key.instance_id} reason=#{mutation_reason}"
-            )
-          rescue StandardError => e
-            handle_exception(
-              e, handled: true, level: :warn, operation: 'llm.inventory.publisher.compatibility_sync',
-                 provider_family: instance_key.provider_family, instance_id: instance_key.instance_id,
-                 mutation_reason: mutation_reason
-            )
-          end
         end
       end
     end

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

@@ -13,10 +13,10 @@ module Legion
     module Llm
       module Inventory
         # Documentation namespace anchor for the immutable inventory records
-        # defined in this file: OfferingDraft, OfferingRecord, LaneRecord,
-        # AvailabilityFact, ReadinessResult, InstanceRecord, PublicationStatus,
-        # and MutationResult. The records themselves live directly under
-        # Inventory so their canonical constant paths stay flat.
+        # defined in this file: OfferingDraft, LaneRecord, AvailabilityFact,
+        # ReadinessResult, InstanceRecord, PublicationStatus, and
+        # MutationResult. The records themselves live directly under Inventory
+        # so their canonical constant paths stay flat.
         module Records; end
 
         # Shared normalization/validation used by the immutable inventory and
@@ -31,6 +31,35 @@ module Legion
 
           PUBLICATION_SOURCES = %i[provider_catalog provider_static_catalog provider_control_plane].freeze
 
+          WEIGHT_INPUT_KEYS = %i[instance model_or_offering provider tier].freeze
+          IDENTITY_WEIGHT_INPUTS = {
+            tier: 100, provider: 100, instance: 100, model_or_offering: 100
+          }.freeze
+          IDENTITY_BASE_WEIGHT = 100_000_000
+
+          def validated_weight_pair(weight_inputs:, base_weight:)
+            raise Errors::ValidationError, 'weight_inputs and base_weight must be supplied together' \
+              if weight_inputs.nil? != base_weight.nil?
+
+            return [IDENTITY_WEIGHT_INPUTS, IDENTITY_BASE_WEIGHT] if weight_inputs.nil?
+
+            raise Errors::ValidationError, 'weight_inputs must be a Hash' \
+              unless weight_inputs.is_a?(::Hash)
+            unless weight_inputs.keys.length == WEIGHT_INPUT_KEYS.length &&
+                   WEIGHT_INPUT_KEYS.all? { |key| weight_inputs.key?(key) }
+              raise Errors::ValidationError,
+                    'weight_inputs must have keys tier/provider/instance/model_or_offering'
+            end
+            raise Errors::ValidationError, 'weight_inputs values must be Integers >= 0' \
+              unless weight_inputs.values.all? { |value| value.is_a?(::Integer) && value >= 0 }
+            raise Errors::ValidationError, 'base_weight must be an Integer >= 0' \
+              unless base_weight.is_a?(::Integer) && base_weight >= 0
+            raise Errors::ValidationError, 'base_weight must equal the product of weight_inputs' \
+              unless base_weight == weight_inputs.values.reduce(1, :*)
+
+            [weight_inputs.dup.freeze, base_weight]
+          end
+
           def check_unknown_kwargs!(kwargs:, members:)
             unknown = kwargs.keys - members
             raise Errors::ValidationError, "unknown keyword(s): #{unknown.join(', ')}" unless unknown.empty?
@@ -122,7 +151,7 @@ module Legion
 
             normalized = {}
             evidence.each do |key, value|
-              op = Taxonomies.normalize_operation(value: key, allow_aliases: false)
+              op = Taxonomies.normalize_operation(value: key)
               raise Errors::ValidationError, "operation_evidence[#{op}] must be an OperationEvidence" unless value.is_a?(OperationEvidence)
               raise Errors::ValidationError, "operation_evidence[#{op}] operation must match key" unless value.operation == op
               raise Errors::ValidationError, "duplicate operation_evidence key #{op}" if normalized.key?(op)
@@ -155,7 +184,7 @@ module Legion
 
             normalized = {}
             quota_domains.each do |key, value|
-              op = Taxonomies.normalize_operation(value: key, allow_aliases: false)
+              op = Taxonomies.normalize_operation(value: key)
               normalized[op] = validate_quota_domain_value!(value: value, field: "quota_domains[#{op}]")
             end
             normalized.freeze
@@ -168,7 +197,7 @@ module Legion
           end
 
           # Validates and returns the five scalar ValueEvidence fields shared by
-          # OfferingDraft, OfferingRecord, and LaneRecord as a member Hash.
+          # OfferingDraft and LaneRecord as a member Hash.
           def scalar_value_evidences(kwargs)
             {
               context_evidence: positive_int_value_evidence!(kwargs[:context_evidence], :context_evidence),
@@ -251,106 +280,56 @@ module Legion
           end
         end
 
-        # An off-registry provider draft of one offering. Carries no provider
-        # family, instance ID, offering ID, lane ID, callable, health, weight, or
-        # default model. See section 10.1.
+        # An off-registry provider draft of one offering. Carries the validated
+        # write-time weight pair, but no provider family, instance ID, offering ID,
+        # lane ID, callable, health, or default model. See section 10.1.
         OfferingDraft = ::Data.define(
           :provider_native_key, :model, :tier, :operation_evidence, :capability_evidence,
           :context_evidence, :max_output_evidence, :embedding_dimensions_evidence,
-          :model_revision_evidence, :tokenizer_evidence, :quota_domains, :metadata, :publication_source
+          :model_revision_evidence, :tokenizer_evidence, :quota_domains, :metadata, :publication_source,
+          :weight_inputs, :base_weight
         ) do
           def initialize(**kwargs)
             kwargs = { capability_evidence: {}, quota_domains: {}, metadata: {} }.merge(kwargs)
             RecordSupport.check_unknown_kwargs!(kwargs: kwargs, members: self.class.members)
-
-            super(
-              provider_native_key: Identity.normalize_text(value: kwargs[:provider_native_key], field: :provider_native_key),
-              model: Identity.normalize_text(value: kwargs[:model], field: :model),
-              tier: Identity.normalize_enum(value: kwargs[:tier], field: :tier, allowed: Taxonomies::TIERS),
-              operation_evidence: RecordSupport.validate_operation_evidence!(kwargs[:operation_evidence]),
-              capability_evidence: RecordSupport.validate_capability_evidence!(kwargs[:capability_evidence]),
-              quota_domains: RecordSupport.validate_quota_domains!(kwargs[:quota_domains]),
-              metadata: RecordSupport.frozen_metadata(value: kwargs[:metadata]),
-              publication_source: RecordSupport.publication_source!(value: kwargs[:publication_source]),
-              **RecordSupport.scalar_value_evidences(kwargs)
+            weight_inputs, base_weight = RecordSupport.validated_weight_pair(
+              weight_inputs: kwargs[:weight_inputs], base_weight: kwargs[:base_weight]
             )
-          end
-        end
-
-        # A registry-owned offering with canonical identity and captured callable.
-        # Only Inventory::Publisher/Registry constructs it. See section 10.2.
-        OfferingRecord = ::Data.define(
-          :offering_id, :provider_native_key, :instance_key, :model, :tier, :operation_evidence,
-          :capability_evidence, :context_evidence, :max_output_evidence, :embedding_dimensions_evidence,
-          :model_revision_evidence, :tokenizer_evidence, :quota_domains, :metadata, :callable_handle,
-          :publication_source
-        ) do
-          def initialize(**kwargs)
-            RecordSupport.check_unknown_kwargs!(kwargs: kwargs, members: self.class.members)
-            instance_key = kwargs[:instance_key]
-            callable_handle = kwargs[:callable_handle]
-            raise Errors::ValidationError, 'instance_key must be an InstanceKey' unless instance_key.is_a?(Identity::InstanceKey)
-            raise Errors::ValidationError, 'callable_handle must be a CallableHandle' unless callable_handle.is_a?(CallableHandle)
-
-            native_key = Identity.normalize_text(value: kwargs[:provider_native_key], field: :provider_native_key)
-            Identity.validate_offering_id!(value: kwargs[:offering_id], instance_key: instance_key, provider_native_key: native_key)
 
             super(
-              offering_id: kwargs[:offering_id].dup.freeze,
-              provider_native_key: native_key,
-              instance_key: instance_key,
+              provider_native_key: Identity.normalize_text(value: kwargs[:provider_native_key], field: :provider_native_key),
               model: Identity.normalize_text(value: kwargs[:model], field: :model),
               tier: Identity.normalize_enum(value: kwargs[:tier], field: :tier, allowed: Taxonomies::TIERS),
               operation_evidence: RecordSupport.validate_operation_evidence!(kwargs[:operation_evidence]),
               capability_evidence: RecordSupport.validate_capability_evidence!(kwargs[:capability_evidence]),
               quota_domains: RecordSupport.validate_quota_domains!(kwargs[:quota_domains]),
               metadata: RecordSupport.frozen_metadata(value: kwargs[:metadata]),
-              callable_handle: callable_handle,
               publication_source: RecordSupport.publication_source!(value: kwargs[:publication_source]),
+              weight_inputs: weight_inputs,
+              base_weight: base_weight,
               **RecordSupport.scalar_value_evidences(kwargs)
             )
           end
-
-          def supported_operations
-            operation_evidence.select { |_op, evidence| evidence.supported? }.keys.sort
-          end
-
-          def unsupported_operations
-            operation_evidence.select { |_op, evidence| evidence.unsupported? }.keys.sort
-          end
-
-          def unknown_operations
-            operation_evidence.select { |_op, evidence| evidence.unknown? }.keys.sort
-          end
-
-          def operation_status(operation:)
-            operation_evidence.fetch(Taxonomies.normalize_operation(value: operation, allow_aliases: false)).status
-          end
-
-          def capability_evidence_for(capability:)
-            capability_evidence[Legion::Extensions::Llm::Capabilities.canonical(capability)]
-          end
-
-          def capability_status(capability:)
-            evidence = capability_evidence_for(capability: capability)
-            evidence.nil? ? :unknown : evidence.status
-          end
-
-          def quota_domain(operation:)
-            quota_domains[Taxonomies.normalize_operation(value: operation, allow_aliases: false)]
-          end
         end
 
-        # An executable lane derived by the registry from one supported operation
-        # of an OfferingRecord. See section 10.3.
+        # An executable lane: the ONE stored inventory unit, keyed by the
+        # 5-tuple id `tier:provider_family:instance_id:type:model`. Derived by
+        # the registry from one supported operation of an OfferingDraft, with
+        # its write-time weight pair copied unchanged. The 5 tuple is composed
+        # at validation from the record's own fields; there is no separate
+        # offering id (D2 — in the one bucket an offering IS a lane).
+        # See section 10.3.
         LaneRecord = ::Data.define(
-          :lane_id, :offering_id, :instance_key, :provider_family, :instance_id, :model, :tier, :operation,
+          :lane_id, :instance_key, :provider_family, :instance_id, :model, :tier, :operation,
           :capability_evidence, :context_evidence, :max_output_evidence, :embedding_dimensions_evidence,
           :model_revision_evidence, :tokenizer_evidence, :quota_domain, :metadata, :callable_handle,
-          :publication_source
+          :publication_source, :weight_inputs, :base_weight
         ) do
           def initialize(**kwargs)
             RecordSupport.check_unknown_kwargs!(kwargs: kwargs, members: self.class.members)
+            weight_inputs, base_weight = RecordSupport.validated_weight_pair(
+              weight_inputs: kwargs[:weight_inputs], base_weight: kwargs[:base_weight]
+            )
             instance_key = kwargs[:instance_key]
             callable_handle = kwargs[:callable_handle]
             raise Errors::ValidationError, 'instance_key must be an InstanceKey' unless instance_key.is_a?(Identity::InstanceKey)
@@ -362,27 +341,32 @@ module Legion
               raise Errors::ValidationError, 'provider_family and instance_id must equal instance_key'
             end
 
+            canonical_tier = Identity.normalize_enum(value: kwargs[:tier], field: :tier, allowed: Taxonomies::TIERS)
             canonical_model = Identity.normalize_text(value: kwargs[:model], field: :model)
-            canonical_operation = Taxonomies.normalize_operation(value: kwargs[:operation], allow_aliases: false)
-            Identity.validate_lane_id!(
-              value: kwargs[:lane_id], instance_key: instance_key, operation: canonical_operation,
-              model: canonical_model, offering_id: kwargs[:offering_id]
+            canonical_operation = Taxonomies.normalize_operation(value: kwargs[:operation])
+            Identity.validate_lane_id!(value: kwargs[:lane_id])
+            expected_lane_id = Identity.compose_lane_id(
+              tier: canonical_tier, provider_family: family, instance_id: resolved_instance,
+              type: Taxonomies.lane_type_for(operation: canonical_operation), model: canonical_model
             )
+            raise Errors::ValidationError, 'lane_id does not reproduce from its identity fields' \
+              unless kwargs[:lane_id].to_s == expected_lane_id
 
             super(
-              lane_id: kwargs[:lane_id].dup.freeze,
-              offering_id: kwargs[:offering_id].dup.freeze,
+              lane_id: kwargs[:lane_id].to_s.dup.freeze,
               instance_key: instance_key,
               provider_family: family,
               instance_id: resolved_instance,
               model: canonical_model,
-              tier: Identity.normalize_enum(value: kwargs[:tier], field: :tier, allowed: Taxonomies::TIERS),
+              tier: canonical_tier,
               operation: canonical_operation,
               capability_evidence: RecordSupport.validate_capability_evidence!(kwargs[:capability_evidence]),
               quota_domain: kwargs[:quota_domain].nil? ? nil : RecordSupport.validate_quota_domain_value!(value: kwargs[:quota_domain], field: :quota_domain),
               metadata: RecordSupport.frozen_metadata(value: kwargs[:metadata]),
               callable_handle: callable_handle,
               publication_source: RecordSupport.publication_source!(value: kwargs[:publication_source]),
+              weight_inputs: weight_inputs,
+              base_weight: base_weight,
               **RecordSupport.scalar_value_evidences(kwargs)
             )
           end
@@ -460,10 +444,11 @@ module Legion
           end
         end
 
-        # An activated exact instance's complete published state. Its availability
-        # is available or unavailable, never initializing. See section 10.6.
+        # An activated exact instance's complete published state. Its lanes are
+        # keyed by the 5-tuple lane id; its availability is available or
+        # unavailable, never initializing. See section 10.6.
         InstanceRecord = ::Data.define(
-          :instance_key, :callable_handle, :availability, :offerings_by_id,
+          :instance_key, :callable_handle, :availability, :lanes_by_id,
           :publisher_id, :publisher_token_id, :published_sequence, :published_at
         ) do
           def initialize(**kwargs)
@@ -481,7 +466,7 @@ module Legion
               instance_key: instance_key,
               callable_handle: callable_handle,
               availability: availability,
-              offerings_by_id: validate_offerings!(kwargs[:offerings_by_id], instance_key, callable_handle),
+              lanes_by_id: validate_lanes!(kwargs[:lanes_by_id], instance_key, callable_handle),
               publisher_id: nonempty_id!(kwargs[:publisher_id], :publisher_id),
               publisher_token_id: nonempty_id!(kwargs[:publisher_token_id], :publisher_token_id),
               published_sequence: RecordSupport.nonnegative_integer(value: kwargs[:published_sequence], field: :published_sequence),
@@ -489,17 +474,15 @@ module Legion
             )
           end
 
-          def validate_offerings!(offerings_by_id, instance_key, callable_handle)
-            raise Errors::ValidationError, 'offerings_by_id must be a Hash' unless offerings_by_id.is_a?(::Hash)
+          def validate_lanes!(lanes_by_id, instance_key, callable_handle)
+            raise Errors::ValidationError, 'lanes_by_id must be a Hash' unless lanes_by_id.is_a?(::Hash)
 
-            offerings_by_id.each do |offering_id, offering|
-              raise Errors::ValidationError, "offering #{offering_id} must be an OfferingRecord" unless offering.is_a?(OfferingRecord)
-              raise Errors::ValidationError, "offering #{offering_id} key mismatch" unless offering.offering_id == offering_id
-              unless offering.instance_key == instance_key && offering.callable_handle.equal?(callable_handle)
-                raise Errors::ValidationError, "offering #{offering_id} must share the instance callable/key"
-              end
+            lanes_by_id.each do |lane_id, lane|
+              raise Errors::ValidationError, "lane #{lane_id} must be a LaneRecord" unless lane.is_a?(LaneRecord)
+              raise Errors::ValidationError, "lane #{lane_id} key mismatch" unless lane.lane_id == lane_id
+              raise Errors::ValidationError, "lane #{lane_id} must share the instance callable/key" unless lane.instance_key == instance_key && lane.callable_handle.equal?(callable_handle)
             end
-            offerings_by_id.dup.freeze
+            lanes_by_id.dup.freeze
           end
 
           def nonempty_id!(value, field)

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

@@ -9,6 +9,7 @@ require 'legion/extensions/llm/inventory/callable_handle'
 require 'legion/extensions/llm/inventory/probe_token'
 require 'legion/extensions/llm/inventory/records'
 require 'legion/extensions/llm/inventory/snapshot'
+require 'legion/extensions/llm/taxonomies'
 
 module Legion
   module Extensions
@@ -21,7 +22,7 @@ module Legion
           # Private per-instance state. Never leaves registry.rb.
           ScopeState = ::Data.define(
             :instance_key, :publisher_token, :callable, :callable_handle, :probe_request_handle,
-            :publication_status, :last_sequence, :availability, :offerings, :lanes,
+            :publication_status, :last_sequence, :availability, :lanes,
             :availability_revision, :unavailable_revision, :published_at
           )
 
@@ -196,7 +197,7 @@ module Legion
                 @scopes[instance_key] = ScopeState.new(
                   instance_key: instance_key, publisher_token: token, callable: callable, callable_handle: handle,
                   probe_request_handle: probe_request_handle, publication_status: status,
-                  last_sequence: -1, availability: nil, offerings: {}, lanes: {},
+                  last_sequence: -1, availability: nil, lanes: {},
                   availability_revision: prior&.availability_revision || 0,
                   unavailable_revision: prior&.unavailable_revision, published_at: nil
                 )
@@ -218,7 +219,7 @@ module Legion
               status = complete_status(scope, sequence, probe_token, now, :success)
               new_scope = scope.with(
                 publication_status: status, last_sequence: sequence, availability: availability,
-                offerings: prepared[1], lanes: prepared[2], availability_revision: new_rev,
+                lanes: prepared[1], availability_revision: new_rev,
                 unavailable_revision: nil, published_at: now
               )
               @scopes[instance_key] = new_scope
@@ -237,7 +238,7 @@ module Legion
 
             def apply_replacement(scope, instance_key, prepared, sequence)
               status = scope.publication_status.with(published_sequence: sequence)
-              new_scope = scope.with(offerings: prepared[1], lanes: prepared[2], last_sequence: sequence, publication_status: status)
+              new_scope = scope.with(lanes: prepared[1], last_sequence: sequence, publication_status: status)
               @scopes[instance_key] = new_scope
               bump_and_snapshot!
               applied(:snapshot_replaced, new_scope)
@@ -428,7 +429,6 @@ module Legion
 
             def build_snapshot_locked
               instances = {}
-              offerings = {}
               lanes = {}
               statuses = {}
               @scopes.each_pair do |key, scope|
@@ -436,11 +436,10 @@ module Legion
                 next if scope.availability.nil?
 
                 instances[key] = instance_record_for(scope)
-                offerings.merge!(scope.offerings)
                 lanes.merge!(scope.lanes)
               end
               Snapshot.new(
-                generation: @generation, instances_by_key: instances, offerings_by_id: offerings,
+                generation: @generation, instances_by_key: instances,
                 lanes_by_id: lanes, publication_status_by_key: statuses
               )
             end
@@ -448,7 +447,7 @@ module Legion
             def instance_record_for(scope)
               InstanceRecord.new(
                 instance_key: scope.instance_key, callable_handle: scope.callable_handle, availability: scope.availability,
-                offerings_by_id: scope.offerings, publisher_id: scope.publisher_token.publisher_id,
+                lanes_by_id: scope.lanes, publisher_id: scope.publisher_token.publisher_id,
                 publisher_token_id: scope.publisher_token.publisher_token_id, published_sequence: scope.last_sequence,
                 published_at: scope.published_at
               )
@@ -460,67 +459,76 @@ module Legion
               scope = @scopes[instance_key]
               return nil if scope.nil?
 
-              offerings_by_id, lanes_by_id = build_records(instance_key, scope.callable_handle, drafts)
-              [scope.callable_handle, offerings_by_id, lanes_by_id]
+              [scope.callable_handle, build_records(instance_key, scope.callable_handle, drafts)]
             end
 
             def prepared_matches?(prepared, scope)
               !prepared.nil? && prepared[0].equal?(scope.callable_handle)
             end
 
+            # The stored inventory is lanes ONLY, keyed by the 5 tuple
+            # tier:provider_family:instance_id:type:model. The 4th part is the
+            # COARSE type, not the fine operation: the operations a draft
+            # supports collapse to one lane per distinct type (chat +
+            # stream_chat + count_tokens are ONE inference lane — the v0.15.2
+            # model, where the operation is a request property matched against
+            # the lane type, not a lane identity part). The LaneRecord's
+            # operation member is the first supported operation of the lane's
+            # type in canonical order — the representative, not the identity.
+            # A duplicate (operation, model) published under a conflicting
+            # tier, or a second draft claiming an already-published 5 tuple,
+            # raises — never a silent merge (D1).
             def build_records(instance_key, handle, drafts)
-              offerings_by_id = {}
+              lanes = {}
               native_keys = {}
+              op_model_tiers = {}
               drafts.each do |draft|
-                offering_id = Identity.offering_id(instance_key: instance_key, provider_native_key: draft.provider_native_key)
                 raise Errors::ValidationError, 'duplicate provider_native_key' if native_keys.key?(draft.provider_native_key)
-                raise Errors::ValidationError, 'duplicate offering_id' if offerings_by_id.key?(offering_id)
 
                 native_keys[draft.provider_native_key] = true
-                offerings_by_id[offering_id] = build_offering_record(instance_key, handle, offering_id, draft)
-              end
-              [offerings_by_id.freeze, build_lanes(instance_key, handle, offerings_by_id).freeze]
-            end
+                draft.operation_evidence.each_value do |evidence|
+                  next unless evidence.supported?
 
-            def build_offering_record(instance_key, handle, offering_id, draft)
-              OfferingRecord.new(
-                offering_id: offering_id, provider_native_key: draft.provider_native_key, instance_key: instance_key,
-                model: draft.model, tier: draft.tier, operation_evidence: draft.operation_evidence,
-                capability_evidence: draft.capability_evidence, context_evidence: draft.context_evidence,
-                max_output_evidence: draft.max_output_evidence,
-                embedding_dimensions_evidence: draft.embedding_dimensions_evidence,
-                model_revision_evidence: draft.model_revision_evidence, tokenizer_evidence: draft.tokenizer_evidence,
-                quota_domains: draft.quota_domains, metadata: draft.metadata, callable_handle: handle,
-                publication_source: draft.publication_source
-              )
-            end
+                  op_model = [evidence.operation, draft.model]
+                  raise Errors::ValidationError, 'duplicate (operation, model) published under a conflicting tier' if op_model_tiers.key?(op_model) && op_model_tiers[op_model] != draft.tier
 
-            def build_lanes(instance_key, handle, offerings_by_id)
-              lanes = {}
-              offerings_by_id.each_value do |offering|
-                offering.supported_operations.each do |operation|
-                  lane_id = Identity.lane_id(
-                    instance_key: instance_key, operation: operation, model: offering.model, offering_id: offering.offering_id
+                  op_model_tiers[op_model] = draft.tier
+                end
+
+                # One lane per distinct type the draft supports.
+                draft.operation_evidence.each_value
+                     .select(&:supported?)
+                     .group_by { |evidence| Taxonomies.lane_type_for(operation: evidence.operation) }
+                     .each do |type, evidences|
+                  representative = evidences.min_by { |evidence| Taxonomies::OPERATIONS.index(evidence.operation) }
+                  lane_id = Identity.compose_lane_id(
+                    tier: draft.tier, provider_family: instance_key.provider_family,
+                    instance_id: instance_key.instance_id, type: type, model: draft.model
                   )
                   raise Errors::ValidationError, 'duplicate lane_id' if lanes.key?(lane_id)
 
-                  lanes[lane_id] = build_lane_record(instance_key, handle, offering, operation, lane_id)
+                  lanes[lane_id] = build_lane_record(instance_key, handle, draft, type, representative.operation)
                 end
               end
-              lanes
+              lanes.freeze
             end
 
-            def build_lane_record(instance_key, handle, offering, operation, lane_id)
+            def build_lane_record(instance_key, handle, draft, type, operation)
               LaneRecord.new(
-                lane_id: lane_id, offering_id: offering.offering_id, instance_key: instance_key,
+                lane_id: Identity.compose_lane_id(
+                  tier: draft.tier, provider_family: instance_key.provider_family,
+                  instance_id: instance_key.instance_id, type: type, model: draft.model
+                ),
+                instance_key: instance_key,
                 provider_family: instance_key.provider_family, instance_id: instance_key.instance_id,
-                model: offering.model, tier: offering.tier, operation: operation,
-                capability_evidence: offering.capability_evidence, context_evidence: offering.context_evidence,
-                max_output_evidence: offering.max_output_evidence,
-                embedding_dimensions_evidence: offering.embedding_dimensions_evidence,
-                model_revision_evidence: offering.model_revision_evidence, tokenizer_evidence: offering.tokenizer_evidence,
-                quota_domain: offering.quota_domain(operation: operation), metadata: offering.metadata,
-                callable_handle: handle, publication_source: offering.publication_source
+                model: draft.model, tier: draft.tier, operation: operation,
+                capability_evidence: draft.capability_evidence, context_evidence: draft.context_evidence,
+                max_output_evidence: draft.max_output_evidence,
+                embedding_dimensions_evidence: draft.embedding_dimensions_evidence,
+                model_revision_evidence: draft.model_revision_evidence, tokenizer_evidence: draft.tokenizer_evidence,
+                quota_domain: draft.quota_domains[operation], metadata: draft.metadata,
+                callable_handle: handle, publication_source: draft.publication_source,
+                weight_inputs: draft.weight_inputs, base_weight: draft.base_weight
               )
             end