lex-llm 0.7.3 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3a6411175e21627e4ebe35751eff6e1f202cb9ed82ad8ffd9d37cae6311849d
-  data.tar.gz: b19ea34c0104010f2bd63db81729e123b79dfd3cb56b61ad5967cd03e54890d5
+  metadata.gz: b11032eff9bab4fc8c4ad457cd78fdce95f6ec245a5938dbd6ea987729db4238
+  data.tar.gz: f799901fe6f05201a25237aeafb7779538a995e63e5117e18550935b9e77e12e
 SHA512:
-  metadata.gz: 9c913c74bff87677f3d9dd0eaa6bad854a74c5d54794aebecf8371b9791166783fc35c4d33a459c1caf9314cf16674e05a7b11ef426b29df1b275465bd32c939
-  data.tar.gz: 7a7dd7e3b3414031bfd6807732c8bcf14e03075c0b020d61ba8621cf9caa32d08be5951b72a995c70ba6042778d1ef732b1b053b92aa0c3813a5636e7f265095
+  metadata.gz: d8f610a4c4bb9fdf202c633360c689082f974033e27bdb9bb5c15afa8b609fee313cb36e32109c829b2f6a3613ae64e6859fc962536c804ec3d30f9e47bbc959
+  data.tar.gz: 82b0d2428591452f708a4fbccd9be04c40752cd3b2a5989e0e0df220406a9e6cfe103da82ad9c5d7123d11875bec97f01ad8c81b83e7ca21deac37b4fde03c98

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.7.6 - 2026-08-19
+
+### Added
+- **Shared writer-cadence weight reconciliation.** `Inventory::WeightReconciler` atomically rebuilds write-time weights, publishes changed snapshots, protects unpublished activation state, and keeps cache/sequence mutation behind each writer's existing mutex. `DormantWeightTracker` reports configured weights with no published lane once per absence cycle. The shared machinery adds no Settings callback or lifecycle coupling.
+
+### Fixed
+- **`WeightReconciler` declares its direct `set` dependency.** Direct file loads no longer rely on another framework entrypoint having already initialized the process-global `Set` constant.
+- **Fleet execution-contract lookup preserves explicit `false`.** Symbol- and string-key envelope accessors now distinguish a present false marker from an absent marker, so malformed requests are rejected before provider or registry dispatch instead of silently downgrading to the legacy path.
+
+## 0.7.5 - 2026-08-19
+
+### Added
+- **Write-time lane weights on immutable Inventory records.** `Inventory::WeightSchema` computes the independent tier, provider, instance, and model-or-offering axes from current settings, preserving zero as an explicit disable and rejecting malformed values. `OfferingDraft`, `OfferingRecord`, and `LaneRecord` now carry an atomic validated weight pair; registry construction copies that frozen pair unchanged.
+
+## 0.7.4 - 2026-08-19
+
+### Added
+- **Authoritative Inventory lane-type mapping.** `Taxonomies::OPERATION_TO_LANE_TYPE` and `Taxonomies.lane_type_for` now own the complete canonical operation-to-lane-type mapping used by human-readable five-tuple lane identities. The deletion-scheduled coordinator adapter delegates to the same resolver instead of retaining a divergent compatibility copy.
+
 ## 0.7.3 - 2026-08-17
 
 ### Fixed

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

@@ -36,7 +36,10 @@ module Legion
 
           FleetEnvelope = Struct.new(:data, keyword_init: true) do
             def [](key)
-              data[key.to_sym] || data[key.to_s]
+              symbol_key = key.to_sym
+              return data[symbol_key] if data.key?(symbol_key)
+
+              data[key.to_s]
             end
 
             def key?(key)

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

@@ -328,8 +328,12 @@ module Legion
 
           def envelope_value(envelope, key)
             return nil unless envelope.respond_to?(:key?)
+            return envelope[key] if envelope.key?(key)
 
-            envelope[key] || envelope[key.to_s]
+            string_key = key.to_s
+            return envelope[string_key] if envelope.key?(string_key)
+
+            nil
           end
 
           def normalize_hash(hash)

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

@@ -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?
@@ -251,17 +280,21 @@ 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)
+            weight_inputs, base_weight = RecordSupport.validated_weight_pair(
+              weight_inputs: kwargs[:weight_inputs], base_weight: kwargs[:base_weight]
+            )
 
             super(
               provider_native_key: Identity.normalize_text(value: kwargs[:provider_native_key], field: :provider_native_key),
@@ -272,21 +305,27 @@ module Legion
               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]),
+              weight_inputs: weight_inputs,
+              base_weight: base_weight,
               **RecordSupport.scalar_value_evidences(kwargs)
             )
           end
         end
 
-        # A registry-owned offering with canonical identity and captured callable.
-        # Only Inventory::Publisher/Registry constructs it. See section 10.2.
+        # A registry-owned offering with canonical identity, captured callable, and
+        # the write-time weight pair copied unchanged from its draft. 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
+          :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)
@@ -307,6 +346,8 @@ module Legion
               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
@@ -342,15 +383,19 @@ module Legion
         end
 
         # An executable lane derived by the registry from one supported operation
-        # of an OfferingRecord. See section 10.3.
+        # of an OfferingRecord, with its write-time weight pair copied unchanged.
+        # See section 10.3.
         LaneRecord = ::Data.define(
           :lane_id, :offering_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)
@@ -383,6 +428,8 @@ module Legion
               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

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

@@ -491,7 +491,8 @@ module Legion
                 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
+                publication_source: draft.publication_source,
+                weight_inputs: draft.weight_inputs, base_weight: draft.base_weight
               )
             end
 
@@ -520,7 +521,8 @@ module Legion
                 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
+                callable_handle: handle, publication_source: offering.publication_source,
+                weight_inputs: offering.weight_inputs, base_weight: offering.base_weight
               )
             end
 

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

@@ -121,7 +121,6 @@ module Legion
             include Legion::Logging::Helper
 
             HEALTHY_COMPAT = { circuit_state: :closed, denied: false, available: true, adjustment: 0 }.freeze
-            LEGACY_TYPES = { embed: :embedding, image: :image, transcribe: :audio, translate: :audio, speak: :audio }.freeze
             LEGACY_CAPABILITIES = {
               chat: :completion, stream_chat: :streaming, embed: :embedding, image: :image,
               transcribe: :audio_transcription, translate: :audio_transcription, speak: :audio_speech, moderate: :moderation
@@ -174,7 +173,7 @@ module Legion
             def group_lanes(snapshot, instance_key)
               groups = {}
               snapshot.lanes_for(instance_key: instance_key).each do |lane|
-                type = LEGACY_TYPES.fetch(lane.operation, :inference)
+                type = Taxonomies.lane_type_for(operation: lane.operation)
                 key = [lane.tier, instance_key.provider_family, instance_key.instance_id, type, lane.model]
                 group = (groups[key] ||= new_group(instance_key, lane, type))
                 accumulate_group(group, lane)

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

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+# Direct dependency; the explicit receiver keeps Ruby 4's redundant-require cop from deleting it.
+Kernel.require 'set'
+require 'legion/extensions/llm/inventory/weight_schema'
+require 'legion/extensions/llm/settings_cascade'
+require 'legion/extensions/llm/inventory/identity'
+
+module Legion
+  module Extensions
+    module Llm
+      module Inventory
+        # Tracks configured weight keys that currently have no published lane.
+        class DormantWeightTracker
+          def initialize
+            @dormant = Set.new
+          end
+
+          def observe(configured_keys:, published_keys:)
+            current = Set.new(configured_keys).difference(published_keys)
+            newly_dormant = current.difference(@dormant).sort_by(&:inspect)
+            @dormant.replace(current)
+            newly_dormant
+          end
+
+          def clear!
+            @dormant.clear
+          end
+        end
+
+        # Shared atomic write-time weight publication for existing writer cadences.
+        module WeightReconciler
+          module_function
+
+          def rebuild_offerings(settings:, instance_key:, offerings:)
+            offerings.map do |draft|
+              inputs = WeightSchema.weight_inputs(
+                settings: settings,
+                instance_key: instance_key,
+                provider_native_key: draft.provider_native_key,
+                model: draft.model,
+                tier: draft.tier
+              )
+              draft.with(weight_inputs: inputs, base_weight: WeightSchema.base_weight(inputs))
+            end.freeze
+          end
+
+          # Periodic discovery calls this AFTER its existing network/discovery work. Read
+          # current Settings and perform weight rebuilding, comparison, sequence
+          # allocation, publish, and cache update under the same writer mutex. No Settings
+          # callback or separate reweight path exists.
+          def commit_if_changed!(settings:, instance_id:, state:, discovered_offerings:, **publication)
+            unknown = publication.keys - %i[mutex equivalent replace stable_signature]
+            raise ArgumentError, "unknown publication keyword(s): #{unknown.join(', ')}" unless unknown.empty?
+
+            mutex = publication.fetch(:mutex)
+            equivalent = publication.fetch(:equivalent)
+            replace = publication.fetch(:replace)
+            stable_signature = publication[:stable_signature]
+            mutex.synchronize do
+              offerings = rebuild_offerings(
+                settings: settings, instance_key: state.fetch(:instance_key),
+                offerings: discovered_offerings
+              )
+              return false if equivalent.call(state.fetch(:offerings), offerings)
+
+              if state.fetch(:published)
+                commit_locked!(
+                  instance_id: instance_id, state: state, offerings: offerings,
+                  replace: replace, stable_signature: stable_signature
+                )
+              else
+                cache_locked!(
+                  state: state, offerings: offerings, stable_signature: stable_signature
+                )
+              end
+              true
+            end
+          end
+
+          # Track a claimed but not-yet-activated instance before its readiness I/O. An
+          # ordinary writer pass may refresh its cached weights, but must never send a
+          # replacement for a publication that is still :initializing.
+          def track_initializing!(states:, state_key:, state:, mutex:)
+            mutex.synchronize do
+              state[:published] = false
+              states[state_key] = state
+            end
+            state
+          end
+
+          # Initial and recovery activation both use this helper after readiness succeeds.
+          # Rebuild from current settings and publish under the writer's publication
+          # mutex, then mark the state published only after the publisher call succeeds.
+          def activate_tracked!(settings:, instance_id:, state_key:, state:, **activation)
+            unknown = activation.keys - %i[states mutex probe_token activate activation_sequence stable_signature]
+            raise ArgumentError, "unknown activation keyword(s): #{unknown.join(', ')}" unless unknown.empty?
+
+            states = activation.fetch(:states)
+            mutex = activation.fetch(:mutex)
+            probe_token = activation.fetch(:probe_token)
+            activate = activation.fetch(:activate)
+            activation_sequence = activation.fetch(:activation_sequence)
+            stable_signature = activation[:stable_signature]
+            mutex.synchronize do
+              return false unless states[state_key].equal?(state)
+
+              offerings = rebuild_offerings(
+                settings: settings, instance_key: state.fetch(:instance_key),
+                offerings: state.fetch(:offerings)
+              )
+              sequence = activation_sequence.call(state)
+              activate.call(
+                instance_id: instance_id, state: state, offerings: offerings,
+                sequence: sequence, probe_token: probe_token
+              )
+              state[:sequence] = sequence
+              cache_locked!(
+                state: state, offerings: offerings, stable_signature: stable_signature
+              )
+              state[:published] = true
+              true
+            end
+          end
+
+          # Ordinary ticks call this after reconcile. Dormant observation has the same
+          # cadence as the existing writer; there is no reload callback path.
+          def observe_dormant!(settings:, provider_family:, states:, mutex:, **observation)
+            unknown = observation.keys - %i[tracker dormant_logger]
+            raise ArgumentError, "unknown observation keyword(s): #{unknown.join(', ')}" unless unknown.empty?
+
+            tracker = observation.fetch(:tracker)
+            dormant_logger = observation.fetch(:dormant_logger)
+            mutex.synchronize do
+              observe_dormant_locked!(
+                settings: settings, provider_family: provider_family, states: states,
+                tracker: tracker, dormant_logger: dormant_logger
+              )
+            end
+          end
+
+          def commit_locked!(instance_id:, state:, offerings:, replace:, stable_signature:)
+            sequence = state.fetch(:sequence) + 1
+            replace.call(instance_id: instance_id, state: state, offerings: offerings, sequence: sequence)
+            state[:sequence] = sequence
+            cache_locked!(
+              state: state, offerings: offerings, stable_signature: stable_signature
+            )
+          end
+          private_class_method :commit_locked!
+
+          def cache_locked!(state:, offerings:, stable_signature:)
+            state[:offerings] = offerings
+            state[:signature] = stable_signature.call(offerings) if stable_signature
+          end
+          private_class_method :cache_locked!
+
+          def observe_dormant_locked!(settings:, provider_family:, states:, tracker:,
+                                      dormant_logger:)
+            configured = configured_weight_keys(settings: settings, provider_family: provider_family)
+            published = published_weight_keys(provider_family: provider_family, states: states)
+            tracker.observe(configured_keys: configured, published_keys: published).each do |key|
+              dormant_logger.call(key)
+            end
+          end
+          private_class_method :observe_dormant_locked!
+
+          def configured_weight_keys(settings:, provider_family:)
+            llm = config_hash(settings.dig(:extensions, :llm))
+            provider = config_hash(SettingsCascade.lookup(llm, provider_family))
+            keys = Set.new
+            keys << canonical_key(provider_family, :provider) if weight_present?(provider)
+
+            config_hash(SettingsCascade.lookup(provider, :models)).each do |model, config|
+              keys << canonical_key(provider_family, :model, model.to_s) if weight_present?(config_hash(config))
+            end
+            config_hash(SettingsCascade.lookup(provider, :instances)).each do |instance, config|
+              instance_config = config_hash(config)
+              keys << canonical_key(provider_family, :instance, instance.to_s) if weight_present?(instance_config)
+              config_hash(SettingsCascade.lookup(instance_config, :models)).each do |model, model_config|
+                next unless weight_present?(config_hash(model_config))
+
+                keys << canonical_key(
+                  provider_family, :instance, instance.to_s, :model, model.to_s
+                )
+              end
+            end
+            config_hash(SettingsCascade.lookup(provider, :offerings)).each do |offering_id, config|
+              keys << canonical_key(provider_family, :offering, offering_id.to_s) \
+                if weight_present?(config_hash(config))
+            end
+            keys
+          end
+
+          def published_weight_keys(provider_family:, states:)
+            keys = Set.new
+            states.each_value do |state|
+              next unless state.fetch(:published)
+
+              offerings = Array(state[:offerings])
+              next if offerings.empty?
+
+              instance_key = state.fetch(:instance_key)
+              keys << canonical_key(provider_family, :provider)
+              keys << canonical_key(provider_family, :instance, instance_key.instance_id.to_s)
+              offerings.each do |draft|
+                keys << canonical_key(provider_family, :model, draft.model.to_s)
+                keys << canonical_key(
+                  provider_family, :instance, instance_key.instance_id.to_s,
+                  :model, draft.model.to_s
+                )
+                offering_id = Identity.offering_id(
+                  instance_key: instance_key, provider_native_key: draft.provider_native_key
+                )
+                keys << canonical_key(provider_family, :offering, offering_id.to_s)
+              end
+            end
+            keys
+          end
+
+          def canonical_key(provider_family, *parts)
+            [provider_family.to_sym, *parts].freeze
+          end
+          private_class_method :canonical_key
+
+          def config_hash(value)
+            return {} if value.nil?
+            return value if value.is_a?(::Hash)
+
+            raise ArgumentError, "weight configuration scope must be a Hash, got #{value.inspect}"
+          end
+          private_class_method :config_hash
+
+          def weight_present?(scope)
+            !SettingsCascade.lookup(scope, :weight).nil?
+          end
+          private_class_method :weight_present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/settings_cascade'
+require 'legion/extensions/llm/inventory/identity'
+
+module Legion
+  module Extensions
+    module Llm
+      module Inventory
+        # Write-time lane-weight computation (RANKING v2 law): the stateless router
+        # reads the stored scalar; it is computed ONLY here, at write events, from a
+        # live settings read. Each multiplicative axis reads ITS OWN scope — never a
+        # fall-through cascade (a fall-through would double-count the other axes).
+        module WeightSchema
+          module_function
+
+          IDENTITY = 100
+
+          # Exact 4-key hash. offering_id derives from instance_key + the REAL
+          # provider native key (NOT the model — azure's native key is
+          # deployment_name, which can differ from model_id).
+          def weight_inputs(settings:, instance_key:, provider_native_key:, model:, tier:)
+            llm_conf = scope_hash(settings.dig(:extensions, :llm), path: 'extensions.llm')
+            provider_conf = scope_hash(
+              SettingsCascade.lookup(llm_conf, instance_key.provider_family),
+              path: "extensions.llm.#{instance_key.provider_family}"
+            )
+            instances = scope_hash(
+              SettingsCascade.lookup(provider_conf, :instances), path: 'provider.instances'
+            )
+            instance_cfg = scope_hash(
+              SettingsCascade.lookup(instances, instance_key.instance_id),
+              path: "provider.instances.#{instance_key.instance_id}"
+            )
+            tier_weights = scope_hash(
+              settings.dig(:llm, :routing, :tier_weights), path: 'llm.routing.tier_weights'
+            )
+            offering_id = Identity.offering_id(instance_key: instance_key, provider_native_key: provider_native_key)
+            offerings = scope_hash(SettingsCascade.lookup(provider_conf, :offerings), path: 'provider.offerings')
+            offering_conf = scope_hash(
+              SettingsCascade.lookup(offerings, offering_id), path: "provider.offerings.#{offering_id}"
+            )
+            provider_models = scope_hash(
+              SettingsCascade.lookup(provider_conf, :models), path: 'provider.models'
+            )
+            instance_models = scope_hash(
+              SettingsCascade.lookup(instance_cfg, :models), path: 'instance.models'
+            )
+            scope_hash(
+              SettingsCascade.lookup(provider_models, model), path: "provider.models.#{model}"
+            )
+            scope_hash(
+              SettingsCascade.lookup(instance_models, model), path: "instance.models.#{model}"
+            )
+            model_scopes = scope_hash(
+              SettingsCascade.merge_model_scopes(
+                provider_conf: provider_conf, instance_cfg: instance_cfg, model: model
+              ),
+              path: "merged model scope #{model}"
+            )
+
+            offering_w = SettingsCascade.lookup(offering_conf, :weight)
+            model_w = SettingsCascade.lookup(model_scopes, :weight)
+            {
+              tier: component(SettingsCascade.lookup(tier_weights, tier), IDENTITY),
+              provider: component(SettingsCascade.lookup(provider_conf, :weight), IDENTITY),
+              instance: component(SettingsCascade.lookup(instance_cfg, :weight), IDENTITY),
+              # Explicit nil? precedence (NEVER `||`): offering overrides the model
+              # component only; nil offering → model; both nil → identity. A
+              # non-nil non-Integer (false, strings, negatives) RAISES in `component`.
+              model_or_offering: component(offering_w.nil? ? model_w : offering_w, IDENTITY)
+            }
+          end
+
+          # nil → default; an explicit 0 passes through (0 = operator disable —
+          # 0 is TRUTHY in Ruby and must not be defaulted); any other non-Integer
+          # RAISES instead of silently applying a different weight.
+          def component(value, default)
+            return default if value.nil?
+
+            raise ArgumentError, "weight component must be an Integer >= 0, got #{value.inspect}" \
+              unless value.is_a?(::Integer) && value >= 0
+
+            value
+          end
+
+          # Missing scope is the identity default. A present malformed scope is
+          # never treated as missing (`false || {}` would silently erase operator
+          # input and recreate a flat identity result).
+          def scope_hash(value, path:)
+            return {} if value.nil?
+            return value if value.is_a?(::Hash)
+
+            raise ArgumentError, "#{path} must be a Hash, got #{value.inspect}"
+          end
+
+          # Pinned return contract: TWO methods. The writer calls both:
+          #   wi = WeightSchema.weight_inputs(...)
+          #   base = WeightSchema.base_weight(wi)
+          def base_weight(weight_inputs)
+            weight_inputs.values.reduce(1, :*)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,25 @@ module Legion
       module Taxonomies
         TIERS           = %i[direct local fleet cloud frontier].freeze
         TYPES           = %i[inference embedding image audio].freeze
+
+        # The current authoritative operation → Inventory lane-type mapping (the 4th
+        # field of the 5-tuple lane id). NON-LEGACY home: the deletion-scheduled
+        # LegacyCoordinatorAdapter consumes `lane_type_for` below until deletion;
+        # it must not retain a second mapping. moderate/count_tokens
+        # are non-generative inference operations — no moderation/count type exists in
+        # TYPES, so they map to :inference.
+        OPERATION_TO_LANE_TYPE = {
+          chat: :inference,
+          stream_chat: :inference,
+          embed: :embedding,
+          image: :image,
+          transcribe: :audio,
+          translate: :audio,
+          speak: :audio,
+          moderate: :inference,
+          count_tokens: :inference
+        }.freeze
+
         CIRCUIT_STATES  = %i[closed half_open open].freeze
         HEALTH_KEYS     = %i[circuit_state denied available adjustment].freeze
 
@@ -79,6 +98,11 @@ module Legion
 
         module_function
 
+        def lane_type_for(operation:)
+          canonical = normalize_operation(value: operation, allow_aliases: false)
+          OPERATION_TO_LANE_TYPE.fetch(canonical)
+        end
+
         # Normalize an operation to one of OPERATIONS. Ingress and protocol-v2
         # compatibility adapters pass allow_aliases: true; registry records and
         # exact-execution envelopes pass false. Unknown, empty, or invalid UTF-8

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.7.3'
+      VERSION = '0.7.6'
     end
   end
 end

data/lib/legion/extensions/llm.rb

@@ -52,6 +52,8 @@ module Legion
       require_relative 'llm/inventory/errors'
       require_relative 'llm/inventory/immutable_value'
       require_relative 'llm/inventory/identity'
+      require_relative 'llm/inventory/weight_schema'
+      require_relative 'llm/inventory/weight_reconciler'
       require_relative 'llm/inventory/evidence'
       require_relative 'llm/inventory/callable_handle'
       require_relative 'llm/inventory/probe_token'