lex-llm 0.7.2 → 0.7.6

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'

data/spec/legion/extensions/llm/conformance/ssot_provider_examples.rb

@@ -164,10 +164,10 @@ RSpec.shared_examples 'an SSOT v3 provider adapter' do
     expect(ssot_harness.inference_call_count(callable: context[:callable])).to eq(1)
   end
 
-  it 'rejects provider/model defaults and a nil instance' do
+  it 'accepts "default" as a plain instance_id label and rejects a nil instance' do
     identity = Legion::Extensions::Llm::Inventory::Identity
-    expect { identity::InstanceKey.new(provider_family: ssot_harness.provider_family, instance_id: 'default') }
-      .to raise_error(Legion::Extensions::Llm::Inventory::Errors::ValidationError)
+    key = identity::InstanceKey.new(provider_family: ssot_harness.provider_family, instance_id: 'default')
+    expect(key.instance_id).to eq('default')
     expect { identity::InstanceKey.new(provider_family: ssot_harness.provider_family, instance_id: nil) }
       .to raise_error(Legion::Extensions::Llm::Inventory::Errors::ValidationError)
   end

data/spec/legion/extensions/llm/fleet/provider_responder_spec.rb

@@ -119,11 +119,44 @@ RSpec.describe Legion::Extensions::Llm::Fleet::ProviderResponder do
   end
 
   describe 'execution_contract marker validation' do
+    it 'preserves false values for both envelope key spellings' do
+      symbol_envelope = described_class::FleetEnvelope.new(data: { execution_contract: false })
+      string_envelope = described_class::FleetEnvelope.new(data: { 'execution_contract' => false })
+
+      expect(symbol_envelope[:execution_contract]).to be(false)
+      expect(string_envelope[:execution_contract]).to be(false)
+    end
+
     it 'accepts a legacy v2 envelope with no marker' do
       envelope = described_class.parse_payload(payload)
       expect { described_class.check_envelope!(envelope, provider_family: :ollama) }.not_to raise_error
     end
 
+    it 'accepts an explicitly nil marker as legacy v2' do
+      envelope = described_class.parse_payload(payload.merge(execution_contract: nil))
+      expect { described_class.check_envelope!(envelope, provider_family: :ollama) }.not_to raise_error
+    end
+
+    { symbol: { execution_contract: false }, string: { 'execution_contract' => false } }.each do |spelling, marker|
+      it "rejects a false #{spelling}-key marker before provider or registry dispatch" do
+        registry = class_spy(Legion::Extensions::Llm::Inventory::Registry)
+        allow(provider_class).to receive(:new).and_call_original
+
+        expect do
+          described_class.call(
+            payload: payload.merge(marker),
+            provider_family: :ollama,
+            provider_class: provider_class,
+            provider_instances: provider_instances,
+            registry: registry
+          )
+        end.to raise_error(ArgumentError, /unknown execution_contract: false/)
+
+        expect(provider_class).not_to have_received(:new)
+        expect(registry).not_to have_received(:snapshot)
+      end
+    end
+
     it 'rejects an unknown nonempty marker' do
       envelope = described_class.parse_payload(payload.merge(execution_contract: 'made_up'))
       expect { described_class.check_envelope!(envelope, provider_family: :ollama) }

data/spec/legion/extensions/llm/fleet/worker_execution_spec.rb

@@ -125,4 +125,24 @@ RSpec.describe Legion::Extensions::Llm::Fleet::WorkerExecution do
 
     expect(Legion::Extensions::Llm::Fleet::TokenValidator).to have_received(:release_replay!).with('jti-2')
   end
+
+  describe '.envelope_value' do
+    it 'preserves false values for both key spellings' do
+      expect(described_class.envelope_value({ execution_contract: false }, :execution_contract)).to be(false)
+      expect(described_class.envelope_value({ 'execution_contract' => false }, :execution_contract)).to be(false)
+    end
+
+    it 'prefers a present symbol key even when its value is false' do
+      mixed = { execution_contract: false, 'execution_contract' => 'exact_offering_v1' }
+
+      expect(described_class.envelope_value(mixed, :execution_contract)).to be(false)
+    end
+
+    it 'preserves legacy absence and nil while returning the exact marker unchanged' do
+      expect(described_class.envelope_value({}, :execution_contract)).to be_nil
+      expect(described_class.envelope_value({ execution_contract: nil }, :execution_contract)).to be_nil
+      expect(described_class.envelope_value({ execution_contract: 'exact_offering_v1' }, :execution_contract))
+        .to eq('exact_offering_v1')
+    end
+  end
 end

data/spec/legion/extensions/llm/inventory/identity_spec.rb

@@ -202,9 +202,16 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Identity do
         .to raise_error(errors::ValidationError)
     end
 
-    it 'rejects the reserved instance_id "default"' do
-      expect { instance_key_class.new(provider_family: 'vllm', instance_id: 'default') }
-        .to raise_error(errors::ValidationError)
+    it 'accepts "default" as a plain instance_id label (no reserved values — v2 parity)' do
+      key = instance_key_class.new(provider_family: 'vllm', instance_id: 'default')
+      expect(key.instance_id).to eq('default')
+
+      other = instance_key_class.new(provider_family: 'vllm', instance_id: '  default ')
+      expect(key).to eq(other)
+      expect(key.hash).to eq(other.hash)
+
+      expect(key.to_h).to eq(provider_family: :vllm, instance_id: 'default', physical_id: nil)
+      expect(key.inspect).to include('instance_id="default"')
     end
 
     it 'rejects nil fields' do
@@ -248,7 +255,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Identity do
         expect({ bare => :found }[with_physical]).to eq(:found)
       end
 
-      it 'does not reserve "default" for physical_id (only instance_id is reserved)' do
+      it 'accepts "default" for physical_id (no field is reserved)' do
         key = instance_key_class.new(provider_family: :vllm, instance_id: 'apollo', physical_id: 'default')
         expect(key.physical_id).to eq('default')
       end

data/spec/legion/extensions/llm/inventory/records_spec.rb

@@ -57,7 +57,57 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
     )
   end
 
+  def build_lane(**overrides)
+    Legion::Extensions::Llm::Inventory::LaneRecord.new(
+      lane_id: lane_id, offering_id: offering_id, instance_key: instance_key, provider_family: :vllm,
+      instance_id: 'h200', model: 'gemma4', tier: :local, operation: :chat, capability_evidence: {},
+      quota_domain: nil, metadata: {}, callable_handle: callable_handle, publication_source: :provider_catalog,
+      **scalar_evidence_kwargs, **overrides
+    )
+  end
+
+  shared_examples 'an atomic immutable weight pair' do
+    it 'defaults both omitted fields to the frozen identity pair' do
+      record = build_record
+      expect(record.weight_inputs).to eq(tier: 100, provider: 100, instance: 100, model_or_offering: 100)
+      expect(record.weight_inputs).to be_frozen
+      expect(record.base_weight).to eq(100_000_000)
+    end
+
+    it 'requires the pair atomically and rejects every invalid shape' do
+      valid = { tier: 150, provider: 100, instance: 115, model_or_offering: 100 }
+      expect { build_record(weight_inputs: valid) }.to raise_error(errors::ValidationError)
+      expect { build_record(base_weight: 172_500_000) }.to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: [], base_weight: 1) }.to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: valid.merge('tier' => 150).except(:tier), base_weight: 172_500_000) }
+        .to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: valid.merge(provider: -1), base_weight: -172_500) }
+        .to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: valid.merge(provider: 100.0), base_weight: 172_500_000) }
+        .to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: valid, base_weight: 172_500_000.0) }
+        .to raise_error(errors::ValidationError)
+      expect { build_record(weight_inputs: valid, base_weight: 1) }.to raise_error(errors::ValidationError)
+    end
+
+    it 'defensively freezes a supplied valid pair' do
+      source = { tier: 150, provider: 100, instance: 115, model_or_offering: 100 }
+      record = build_record(weight_inputs: source, base_weight: 172_500_000)
+      source[:tier] = 1
+
+      expect(record.weight_inputs).to eq(tier: 150, provider: 100, instance: 115, model_or_offering: 100)
+      expect(record.weight_inputs).to be_frozen
+      expect(record.base_weight).to eq(172_500_000)
+    end
+  end
+
   describe inventory::OfferingDraft do
+    def build_record(**overrides)
+      build_draft(**overrides)
+    end
+
+    it_behaves_like 'an atomic immutable weight pair'
+
     it 'builds a valid frozen draft' do
       draft = build_draft
       expect(draft).to be_frozen
@@ -112,6 +162,12 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
   end
 
   describe inventory::OfferingRecord do
+    def build_record(**overrides)
+      build_offering_record(**overrides)
+    end
+
+    it_behaves_like 'an atomic immutable weight pair'
+
     it 'validates offering_id reproduction and exposes operation views' do
       record = build_offering_record
       expect(record.supported_operations).to eq(%i[chat])
@@ -138,15 +194,12 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
   end
 
   describe inventory::LaneRecord do
-    def build_lane(**overrides)
-      Legion::Extensions::Llm::Inventory::LaneRecord.new(
-        lane_id: lane_id, offering_id: offering_id, instance_key: instance_key, provider_family: :vllm,
-        instance_id: 'h200', model: 'gemma4', tier: :local, operation: :chat, capability_evidence: {},
-        quota_domain: nil, metadata: {}, callable_handle: callable_handle, publication_source: :provider_catalog,
-        **scalar_evidence_kwargs, **overrides
-      )
+    def build_record(**overrides)
+      build_lane(**overrides)
     end
 
+    it_behaves_like 'an atomic immutable weight pair'
+
     it 'builds a valid lane whose id reproduces' do
       expect(build_lane.lane_id).to eq(lane_id)
     end

data/spec/legion/extensions/llm/inventory/registry_activation_spec.rb

@@ -74,6 +74,24 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
       expect(snapshot.publication_status(instance_key: key).state).to eq(:complete)
     end
 
+    it 'copies the draft weight pair unchanged onto offering and lane records' do
+      weights = { tier: 150, provider: 100, instance: 115, model_or_offering: 100 }
+      claim_and_activate(
+        key: key, callable: callable, coordinator: coordinator,
+        weight_inputs: weights, base_weight: 172_500_000
+      )
+      snapshot = described_class.snapshot
+      offering = snapshot.offerings_for(instance_key: key).first
+      lane = snapshot.lanes_for(instance_key: key).first
+
+      expect(offering.weight_inputs).to eq(weights)
+      expect(offering.base_weight).to eq(172_500_000)
+      expect(lane.weight_inputs).to eq(weights)
+      expect(lane.base_weight).to eq(172_500_000)
+      expect(offering.weight_inputs).to be_frozen
+      expect(lane.weight_inputs).to be_frozen
+    end
+
     it 'accepts an explicit complete empty activation as complete, not initializing' do
       token = described_class.claim_instance(instance_key: key, callable: callable, probe_request_handle: coordinator)
       probe = described_class.readiness_probe_started(instance_key: key, publisher_token: token)

data/spec/legion/extensions/llm/inventory/scoped_refresher_spec.rb

@@ -253,8 +253,11 @@ RSpec.describe Legion::Extensions::Llm::Inventory::ScopedRefresher do
     end
 
     it 'projects an available instance into an exact five-field legacy lane and round-trips' do
+      allow(Legion::Extensions::Llm::Taxonomies).to receive(:lane_type_for).and_call_original
+
       result = adapter.sync_snapshot(snapshot: activate_chat, instance_key: key, mutation_reason: :activated)
       expect(result).to eq(:applied)
+      expect(Legion::Extensions::Llm::Taxonomies).to have_received(:lane_type_for).with(operation: :chat)
 
       legacy_id = 'local:vllm:h200:inference:gemma4'
       expect(fake_inventory.lanes).to have_key(legacy_id)

data/spec/legion/extensions/llm/inventory/weight_reconciler_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'legion/extensions/llm/inventory/records'
+require_relative '../../../../support/ssot_registry_helpers'
+
+RSpec.describe 'Inventory::WeightReconciler' do
+  include SsotRegistryHelpers
+
+  inventory = Legion::Extensions::Llm::Inventory
+
+  let(:reconciler) { inventory.const_get(:WeightReconciler) }
+  let(:tracker_class) { inventory.const_get(:DormantWeightTracker) }
+  let(:key) { instance_key(family: 'vllm', instance: 'helios') }
+  let(:mutex) { Mutex.new }
+  let(:identity_draft) { drafts.first }
+
+  it 'loads its Set dependency when directly required without the ambient constant' do
+    script = <<~RUBY
+      require 'tmpdir'
+
+      Object.send(:remove_const, :Set)
+      $LOADED_FEATURES.delete_if { |path| File.basename(path) == 'set.rb' }
+      Dir.mktmpdir do |directory|
+        File.write(File.join(directory, 'set.rb'), <<~'SET')
+          class Set
+            def initialize(values = []) = @values = values.to_a.uniq
+            def difference(other) = self.class.new(@values.reject { |value| other.include?(value) })
+            def sort_by(&block) = @values.sort_by(&block)
+            def replace(other) = (@values = other.to_a; self)
+            def include?(value) = @values.include?(value)
+            def to_a = @values.dup
+          end
+        SET
+        $LOAD_PATH.unshift(directory)
+        require 'legion/extensions/llm/inventory/weight_reconciler'
+        tracker = Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
+        abort 'wrong result' unless tracker.observe(configured_keys: [[:vllm]], published_keys: []).size == 1
+      end
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, '-Ilib', '-e', script,
+      chdir: File.expand_path('../../../../..', __dir__)
+    )
+
+    expect(status.success?).to be(true), stderr
+  end
+
+  def settings_for(provider: {}, tier: 100)
+    {
+      extensions: { llm: { vllm: provider } },
+      llm: { routing: { tier_weights: { local: tier } } }
+    }
+  end
+
+  def state_for(draft: identity_draft, published: true, sequence: 0)
+    {
+      instance_key: key, offerings: [draft].freeze, published: published,
+      sequence: sequence, publisher_token: 'ptok:v1:test'
+    }
+  end
+
+  it 'rebuilds every offering with the current weight pair in a frozen array' do
+    rebuilt = reconciler.rebuild_offerings(
+      settings: settings_for(provider: { weight: 110 }), instance_key: key,
+      offerings: [identity_draft]
+    )
+
+    expect(rebuilt).to be_frozen
+    expect(rebuilt.first.weight_inputs)
+      .to eq(tier: 100, provider: 110, instance: 100, model_or_offering: 100)
+    expect(rebuilt.first.base_weight).to eq(110_000_000)
+    expect(rebuilt.first).to eq(
+      identity_draft.with(
+        weight_inputs: { tier: 100, provider: 110, instance: 100, model_or_offering: 100 },
+        base_weight: 110_000_000
+      )
+    )
+  end
+
+  it 'returns false and publishes nothing when the rebuilt offerings are equivalent' do
+    state = state_for
+    replace = instance_spy(Proc)
+
+    result = reconciler.commit_if_changed!(
+      settings: settings_for, instance_id: 'helios', state: state,
+      discovered_offerings: [identity_draft], mutex: mutex,
+      equivalent: ->(previous, current) { previous == current }, replace: replace
+    )
+
+    expect(result).to be(false)
+    expect(replace).not_to have_received(:call)
+    expect(state).to include(sequence: 0, offerings: [identity_draft])
+  end
+
+  it 'publishes a changed frozen array then atomically updates sequence, cache, and signature' do
+    state = state_for
+    published = []
+    signature = ->(offerings) { offerings.map { |draft| [draft.base_weight, draft.model] } }
+    replace = lambda do |instance_id:, state:, offerings:, sequence:|
+      published << { instance_id: instance_id, state: state, offerings: offerings, sequence: sequence }
+    end
+
+    result = reconciler.commit_if_changed!(
+      settings: settings_for(provider: { weight: 110 }), instance_id: 'helios', state: state,
+      discovered_offerings: [identity_draft], mutex: mutex,
+      equivalent: ->(previous, current) { previous == current }, replace: replace,
+      stable_signature: signature
+    )
+
+    expect(result).to be(true)
+    expect(published.one?).to be(true)
+    expect(published.first).to include(instance_id: 'helios', state: state, sequence: 1)
+    expect(published.first[:offerings]).to be_frozen
+    expect(published.first[:offerings]).to be_a(Array)
+    expect(state[:sequence]).to eq(1)
+    expect(state[:offerings]).to equal(published.first[:offerings])
+    expect(state[:signature]).to eq([[110_000_000, 'gemma4']])
+  end
+
+  it 'updates an unpublished cache without replacing or advancing its sequence' do
+    state = state_for(published: false)
+    replace = instance_spy(Proc)
+
+    result = reconciler.commit_if_changed!(
+      settings: settings_for(provider: { weight: 110 }), instance_id: 'helios', state: state,
+      discovered_offerings: [identity_draft], mutex: mutex,
+      equivalent: ->(previous, current) { previous == current }, replace: replace
+    )
+
+    expect(result).to be(true)
+    expect(replace).not_to have_received(:call)
+    expect(state[:sequence]).to eq(0)
+    expect(state[:offerings].first.base_weight).to eq(110_000_000)
+  end
+
+  it 'leaves published state unchanged when replacement raises so the next pass can retry' do
+    state = state_for
+    before = state.dup
+    replace = ->(**) { raise 'publisher down' }
+
+    expect do
+      reconciler.commit_if_changed!(
+        settings: settings_for(provider: { weight: 110 }), instance_id: 'helios', state: state,
+        discovered_offerings: [identity_draft], mutex: mutex,
+        equivalent: ->(previous, current) { previous == current }, replace: replace
+      )
+    end.to raise_error(RuntimeError, 'publisher down')
+    expect(state).to eq(before)
+  end
+
+  it 'tracks initializing state and activates it only while the same object remains tracked' do
+    states = {}
+    state = state_for(published: true)
+    reconciler.track_initializing!(states: states, state_key: 'helios', state: state, mutex: mutex)
+    expect(state[:published]).to be(false)
+    expect(states['helios']).to equal(state)
+
+    activations = []
+    activated = reconciler.activate_tracked!(
+      settings: settings_for(provider: { weight: 120 }), instance_id: 'helios',
+      state_key: 'helios', state: state, states: states, mutex: mutex,
+      probe_token: :probe, activation_sequence: ->(tracked) { tracked.fetch(:sequence) },
+      activate: ->(**kwargs) { activations << kwargs }
+    )
+    expect(activated).to be(true)
+    expect(activations.first[:offerings].first.base_weight).to eq(120_000_000)
+    expect(state[:offerings]).to equal(activations.first[:offerings])
+    expect(state[:published]).to be(true)
+
+    states.delete('helios')
+    expect(
+      reconciler.activate_tracked!(
+        settings: settings_for, instance_id: 'helios', state_key: 'helios', state: state,
+        states: states, mutex: mutex, probe_token: :probe,
+        activation_sequence: ->(tracked) { tracked.fetch(:sequence) }, activate: ->(**) { raise 'not called' }
+      )
+    ).to be(false)
+  end
+
+  it 'leaves initializing state unchanged when activation publication raises' do
+    state = state_for(published: false)
+    states = { 'helios' => state }
+    before = state.dup
+
+    expect do
+      reconciler.activate_tracked!(
+        settings: settings_for(provider: { weight: 120 }), instance_id: 'helios',
+        state_key: 'helios', state: state, states: states, mutex: mutex,
+        probe_token: :probe, activation_sequence: ->(tracked) { tracked.fetch(:sequence) + 1 },
+        activate: ->(**) { raise 'activation down' }
+      )
+    end.to raise_error(RuntimeError, 'activation down')
+    expect(state).to eq(before)
+  end
+
+  it 'logs each dormant key once, clears it on appearance, and logs re-disappearance' do
+    tracker = tracker_class.new
+    model_settings = settings_for(provider: { models: { ghost: { weight: 125 } } })
+    states = { 'helios' => state_for }
+    logged = []
+    observe = lambda do
+      reconciler.observe_dormant!(
+        settings: model_settings, provider_family: :vllm, states: states,
+        mutex: mutex, tracker: tracker, dormant_logger: ->(key_value) { logged << key_value }
+      )
+    end
+
+    observe.call
+    observe.call
+    expect(logged).to eq([[:vllm, :model, 'ghost']])
+
+    states['helios'] = state_for(draft: drafts(model: 'ghost', native: 'ghost').first)
+    observe.call
+    states['helios'] = state_for
+    observe.call
+    expect(logged).to eq([[:vllm, :model, 'ghost'], [:vllm, :model, 'ghost']])
+
+    tracker.clear!
+    observe.call
+    expect(logged.size).to eq(3)
+  end
+
+  it 'does not let an unpublished state satisfy a configured key and rejects malformed scopes' do
+    tracker = tracker_class.new
+    logged = []
+    states = { 'helios' => state_for(published: false) }
+    settings = settings_for(provider: { models: { gemma4: { weight: 125 } } })
+    reconciler.observe_dormant!(
+      settings: settings, provider_family: :vllm, states: states, mutex: mutex,
+      tracker: tracker, dormant_logger: ->(value) { logged << value }
+    )
+    expect(logged).to include([:vllm, :model, 'gemma4'])
+
+    expect do
+      reconciler.observe_dormant!(
+        settings: settings_for(provider: { models: false }), provider_family: :vllm,
+        states: {}, mutex: mutex, tracker: tracker, dormant_logger: ->(_value) {}
+      )
+    end.to raise_error(ArgumentError, /weight configuration scope must be a Hash/)
+  end
+
+  it 'uses the exact provider, instance, model, instance-model, and offering dormant keys' do
+    offering_id = inventory::Identity.offering_id(instance_key: key, provider_native_key: 'gemma4')
+    settings = settings_for(
+      provider: {
+        weight: false,
+        models: { gemma4: { weight: 101 } },
+        instances: { helios: { weight: 0, models: { gemma4: { weight: 102 } } } },
+        offerings: { offering_id => { weight: 103 } }
+      },
+      tier: 777
+    )
+    tracker = tracker_class.new
+    logged = []
+
+    reconciler.observe_dormant!(
+      settings: settings, provider_family: :vllm, states: {}, mutex: mutex,
+      tracker: tracker, dormant_logger: ->(value) { logged << value }
+    )
+    expect(logged).to contain_exactly(
+      %i[vllm provider],
+      [:vllm, :instance, 'helios'],
+      [:vllm, :model, 'gemma4'],
+      [:vllm, :instance, 'helios', :model, 'gemma4'],
+      [:vllm, :offering, offering_id]
+    )
+    expect(logged.flatten).not_to include(:tier)
+
+    reconciler.observe_dormant!(
+      settings: settings, provider_family: :vllm,
+      states: { 'helios' => state_for }, mutex: mutex,
+      tracker: tracker, dormant_logger: ->(value) { logged << value }
+    )
+    expect(logged.size).to eq(5)
+  end
+
+  it 'serializes concurrent ordinary commits and leaves cache equal to the final publication' do
+    state = state_for
+    publications = []
+    ready = Queue.new
+    start = Queue.new
+    replace = lambda do |offerings:, sequence:, **|
+      publications << [sequence, offerings]
+    end
+    run = lambda do |weight|
+      ready << true
+      start.pop
+      reconciler.commit_if_changed!(
+        settings: settings_for(provider: { weight: weight }), instance_id: 'helios', state: state,
+        discovered_offerings: [identity_draft], mutex: mutex,
+        equivalent: ->(previous, current) { previous == current }, replace: replace
+      )
+    end
+    threads = [Thread.new { run.call(110) }, Thread.new { run.call(120) }]
+    2.times { ready.pop }
+    2.times { start << true }
+    threads.each(&:join)
+
+    expect(publications.map(&:first)).to eq([1, 2])
+    expect(state[:sequence]).to eq(2)
+    expect(state[:offerings]).to equal(publications.last.last)
+    expect(state[:offerings].first.weight_inputs).to eq(publications.last.last.first.weight_inputs)
+  end
+end

data/spec/legion/extensions/llm/inventory/weight_schema_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/llm/inventory/identity'
+require 'legion/extensions/llm/inventory/weight_schema'
+
+RSpec.describe 'Inventory::WeightSchema' do
+  inventory = Legion::Extensions::Llm::Inventory
+
+  let(:schema) { inventory.const_get(:WeightSchema) }
+  let(:instance_key) do
+    inventory::Identity::InstanceKey.new(provider_family: :vllm, instance_id: 'helios')
+  end
+
+  def settings_for(provider: {})
+    { extensions: { llm: { vllm: provider } }, llm: { routing: { tier_weights: { direct: 100 } } } }
+  end
+
+  def inputs(settings, native: 'deployment-x', model: 'model-y')
+    schema.weight_inputs(
+      settings: settings, instance_key: instance_key,
+      provider_native_key: native, model: model, tier: :direct
+    )
+  end
+
+  it 'multiplies independent scopes without double-counting and lets offering override model' do
+    offering_id = inventory::Identity.offering_id(instance_key: instance_key, provider_native_key: 'deployment-x')
+    settings = settings_for(
+      provider: {
+        weight: 100,
+        models: { 'model-y' => { weight: 200 } },
+        instances: { helios: { weight: 115 } },
+        offerings: { offering_id => { weight: 300 } }
+      }
+    )
+
+    result = inputs(settings)
+    expect(result).to eq(tier: 100, provider: 100, instance: 115, model_or_offering: 300)
+    expect(schema.base_weight(result)).to eq(345_000_000)
+  end
+
+  it 'uses provider model weight and lets instance model weight override it' do
+    provider = { models: { 'model-y' => { weight: 200 } }, instances: { helios: {} } }
+    expect(inputs(settings_for(provider: provider))[:model_or_offering]).to eq(200)
+
+    provider[:instances][:helios][:models] = { 'model-y' => { weight: 250 } }
+    expect(inputs(settings_for(provider: provider))[:model_or_offering]).to eq(250)
+  end
+
+  it 'preserves zero, rejects false, and defaults all missing axes to identity' do
+    zero = inputs(settings_for(provider: { weight: 0, instances: { helios: {} } }))
+    expect(zero[:provider]).to eq(0)
+    expect(schema.base_weight(zero)).to eq(0)
+
+    expect { inputs(settings_for(provider: { weight: false })) }
+      .to raise_error(ArgumentError, /weight component/)
+
+    identity = inputs(settings_for)
+    expect(identity).to eq(tier: 100, provider: 100, instance: 100, model_or_offering: 100)
+    expect(schema.base_weight(identity)).to eq(100_000_000)
+  end
+
+  it 'derives offering identity from the provider-native key rather than the model' do
+    deployment_id = inventory::Identity.offering_id(
+      instance_key: instance_key, provider_native_key: 'deployment-x'
+    )
+    model_id = inventory::Identity.offering_id(instance_key: instance_key, provider_native_key: 'model-y')
+    settings = settings_for(provider: { offerings: { deployment_id => { weight: 321 }, model_id => { weight: 999 } } })
+
+    expect(inputs(settings)[:model_or_offering]).to eq(321)
+  end
+
+  it 'rejects every present malformed configuration scope instead of defaulting it' do
+    cases = {
+      'extensions.llm' => { extensions: { llm: false } },
+      'extensions.llm.vllm' => { extensions: { llm: { vllm: false } } },
+      'provider.instances' => settings_for(provider: { instances: false }),
+      'provider.instances.helios' => settings_for(provider: { instances: { helios: false } }),
+      'llm.routing.tier_weights' => { extensions: { llm: {} }, llm: { routing: { tier_weights: false } } },
+      'provider.offerings' => settings_for(provider: { offerings: false }),
+      'provider.models.model-y' => settings_for(provider: { models: { 'model-y' => false } }),
+      'instance.models.model-y' => settings_for(
+        provider: { instances: { helios: { models: { 'model-y' => false } } } }
+      )
+    }
+
+    cases.each do |path, settings|
+      expect { inputs(settings) }.to raise_error(ArgumentError, /#{Regexp.escape(path)}/)
+    end
+  end
+end