lex-llm 0.7.3 → 0.8.0

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

@@ -21,7 +21,6 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
       snapshot = described_class.snapshot
       expect(snapshot.generation).to eq(0)
       expect(snapshot.each_lane.to_a).to be_empty
-      expect(snapshot.each_offering.to_a).to be_empty
       expect(snapshot.instance(instance_key: key)).to be_nil
     end
   end
@@ -63,17 +62,69 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
         .to raise_error(errors::InvalidTransitionError)
     end
 
-    it 'atomically publishes callable, offerings, lanes, and available on activation' do
+    it 'atomically publishes callable, lanes, and available on activation' do
       claim_and_activate(key: key, callable: callable, coordinator: coordinator)
       snapshot = described_class.snapshot
       record = snapshot.instance(instance_key: key)
       expect(record).not_to be_nil
       expect(record.availability.state).to eq(:available)
       expect(snapshot.lanes_for(instance_key: key).size).to eq(1)
-      expect(snapshot.offerings_for(instance_key: key).size).to eq(1)
       expect(snapshot.publication_status(instance_key: key).state).to eq(:complete)
     end
 
+    it 'stores the lane keyed by the 5 tuple and exposes it through the record' do
+      claim_and_activate(key: key, callable: callable, coordinator: coordinator)
+      snapshot = described_class.snapshot
+      lane = snapshot.lanes_for(instance_key: key).first
+      expect(lane.lane_id).to eq('local:vllm:h200:inference:gemma4')
+      expect(snapshot.lane(lane_id: lane.lane_id)).to be(lane)
+      expect(snapshot.instance(instance_key: key).lanes_by_id.keys).to eq([lane.lane_id])
+    end
+
+    it 'derives one lane per supported operation of each draft' do
+      claim_and_activate(
+        key: key, callable: callable, coordinator: coordinator, supported: %i[chat embed]
+      )
+      snapshot = described_class.snapshot
+      expect(snapshot.lanes_for(instance_key: key).map(&:lane_id).sort).to eq(
+        %w[local:vllm:h200:embedding:gemma4 local:vllm:h200:inference:gemma4]
+      )
+    end
+
+    it 'raises on a duplicate (operation, model) published under a conflicting tier (D1)' do
+      key2 = instance_key(instance: 'tier-collision')
+      coordinator2 = probe_coordinator(key2)
+      token = described_class.claim_instance(instance_key: key2, callable: callable, probe_request_handle: coordinator2)
+      probe = described_class.readiness_probe_started(instance_key: key2, publisher_token: token)
+      expect do
+        described_class.activate_instance_snapshot(
+          publisher_token: token, instance_key: key2,
+          offerings: [
+            *drafts(model: 'm1', native: 'm1-a', supported: %i[chat], tier: :local),
+            *drafts(model: 'm1', native: 'm1-b', supported: %i[chat], tier: :frontier)
+          ],
+          sequence: 0, probe_token: probe
+        )
+      end.to raise_error(inventory::Errors::ValidationError, /conflicting tier/)
+    end
+
+    it 'raises on a duplicate 5 tuple from two native keys of the same model' do
+      key3 = instance_key(instance: 'dup-tuple')
+      coordinator3 = probe_coordinator(key3)
+      token = described_class.claim_instance(instance_key: key3, callable: callable, probe_request_handle: coordinator3)
+      probe = described_class.readiness_probe_started(instance_key: key3, publisher_token: token)
+      expect do
+        described_class.activate_instance_snapshot(
+          publisher_token: token, instance_key: key3,
+          offerings: [
+            *drafts(model: 'm1', native: 'm1-a', supported: %i[chat], tier: :local),
+            *drafts(model: 'm1', native: 'm1-b', supported: %i[chat], tier: :local)
+          ],
+          sequence: 0, probe_token: probe
+        )
+      end.to raise_error(inventory::Errors::ValidationError, /duplicate lane_id/)
+    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)
@@ -83,7 +134,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
       expect(result.applied).to be(true)
       snapshot = described_class.snapshot
       expect(snapshot.publication_status(instance_key: key).state).to eq(:complete)
-      expect(snapshot.instance(instance_key: key).offerings_by_id).to eq({})
+      expect(snapshot.instance(instance_key: key).lanes_by_id).to eq({})
     end
 
     it 'consumes the probe token so it cannot be reused' do

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

@@ -23,8 +23,9 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
     )
     expect(result.applied).to be(true)
     expect(result.reason).to eq(:snapshot_replaced)
-    offerings = described_class.snapshot.offerings_for(instance_key: key)
-    expect(offerings.map(&:provider_native_key)).to eq(['gemma5'])
+    lanes = described_class.snapshot.lanes_for(instance_key: key)
+    expect(lanes.map(&:model)).to eq(['gemma5'])
+    expect(lanes.map(&:lane_id)).to eq(%w[local:vllm:h200:inference:gemma5])
   end
 
   it 'preserves the exact availability fact across replacement' do
@@ -45,7 +46,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
   it 'treats an empty array as an authoritative complete empty snapshot' do
     token
     described_class.replace_instance_snapshot(publisher_token: token, instance_key: key, offerings: [], sequence: 1)
-    expect(described_class.snapshot.offerings_for(instance_key: key)).to be_empty
+    expect(described_class.snapshot.lanes_for(instance_key: key)).to be_empty
     expect(described_class.snapshot.instance(instance_key: key).availability.state).to eq(:available)
   end
 
@@ -56,7 +57,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
     expect { described_class.replace_instance_snapshot(publisher_token: token, instance_key: key, offerings: duplicate, sequence: 1) }
       .to raise_error(errors::ValidationError)
     expect(described_class.snapshot.generation).to eq(generation)
-    expect(described_class.snapshot.offerings_for(instance_key: key).size).to eq(1)
+    expect(described_class.snapshot.lanes_for(instance_key: key).size).to eq(1)
   end
 
   it 'returns a stale publisher result for a superseded token' do

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

@@ -26,8 +26,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Snapshot do
       record = snapshot.instance(instance_key: key_a)
       expect(record).to be_frozen
       expect(snapshot.instance(instance_key: instance_key(instance: 'absent'))).to be_nil
-      expect(snapshot.lane(lane_id: 'lane:v1:missing')).to be_nil
-      expect(snapshot.offering(offering_id: 'off:v1:missing')).to be_nil
+      expect(snapshot.lane(lane_id: 'local:absent:absent:inference:missing')).to be_nil
     end
 
     it 'only lists activated instances but keeps initializing claims in publication status' do
@@ -41,17 +40,24 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Snapshot do
   end
 
   describe 'ordering and iteration' do
-    it 'returns frozen lanes_for/offerings_for arrays ordered by id' do
+    it 'returns a frozen lanes_for array ordered by 5-tuple id' do
       snapshot = activate_both
       lanes = snapshot.lanes_for(instance_key: key_a)
       expect(lanes).to be_frozen
       expect(lanes.map(&:lane_id)).to eq(lanes.map(&:lane_id).sort)
+      expect(lanes.map(&:lane_id)).to all(match(/\A[a-z_]+:[a-z_0-9]+:[^:]+:[a-z_]+:.+\z/))
     end
 
-    it 'each_lane/each_offering yield in id order and return an Enumerator without a block' do
+    it 'exposes lanes only — no offering surface' do
+      snapshot = activate_both
+      expect(snapshot).not_to respond_to(:offering)
+      expect(snapshot).not_to respond_to(:offerings_for)
+      expect(snapshot).not_to respond_to(:each_offering)
+    end
+
+    it 'each_lane yields in id order and returns an Enumerator without a block' do
       snapshot = activate_both
       expect(snapshot.each_lane).to be_a(Enumerator)
-      expect(snapshot.each_offering).to be_a(Enumerator)
       expect(snapshot.each_lane.map(&:lane_id)).to eq(snapshot.each_lane.map(&:lane_id).sort)
     end
   end

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

@@ -0,0 +1,312 @@
+# 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
+    # The offering-scope key is the lane's 5 tuple — operator-readable.
+    offering_lane_id = inventory::Identity.compose_lane_id(
+      tier: :local, provider_family: 'vllm', instance_id: 'helios', type: :inference, model: 'gemma4'
+    )
+    expect(offering_lane_id).to eq('local:vllm:helios:inference:gemma4')
+    settings = settings_for(
+      provider: {
+        weight: false,
+        models: { gemma4: { weight: 101 } },
+        instances: { helios: { weight: 0, models: { gemma4: { weight: 102 } } } },
+        offerings: { offering_lane_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_lane_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,141 @@
+# 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 operation_evidence(supported: %i[chat], **)
+    Legion::Extensions::Llm::Taxonomies::OPERATIONS.to_h do |op|
+      status, source = supported.include?(op) ? %i[supported provider_implementation] : %i[unknown absent]
+      [op, Legion::Extensions::Llm::Inventory::OperationEvidence.new(operation: op, status: status, source: source)]
+    end
+  end
+
+  def settings_for(provider: {})
+    { extensions: { llm: { vllm: provider } }, llm: { routing: { tier_weights: { direct: 100 } } } }
+  end
+
+  # The offering-scope settings key is the lane's 5 tuple (operator-readable).
+  def lane_id(tier: :direct, model: 'model-y', type: :inference)
+    Legion::Extensions::Llm::Inventory::Identity.compose_lane_id(
+      tier: tier, provider_family: 'vllm', instance_id: 'helios', type: type, model: model
+    )
+  end
+
+  def inputs(settings, operation: :chat, model: 'model-y')
+    schema.weight_inputs(
+      settings: settings, instance_key: instance_key, model: model, tier: :direct,
+      operation_evidence: operation_evidence(supported: [operation])
+    )
+  end
+
+  it 'multiplies independent scopes without double-counting and lets offering override model' do
+    settings = settings_for(
+      provider: {
+        weight: 100,
+        models: { 'model-y' => { weight: 200 } },
+        instances: { helios: { weight: 115 } },
+        offerings: { lane_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 'treats the offering scope as the lane 5 tuple: a different model key does not apply' do
+    other_model_key = lane_id(model: 'other-model')
+    settings = settings_for(
+      provider: { offerings: { other_model_key => { weight: 999 }, lane_id => { weight: 321 } } }
+    )
+
+    expect(inputs(settings)[:model_or_offering]).to eq(321)
+  end
+
+  it 'derives the offering scope type from the operation: an embed key does not apply to a chat lane' do
+    embed_key = lane_id(type: :embedding)
+    settings = settings_for(provider: { offerings: { embed_key => { weight: 999 } } })
+
+    expect(inputs(settings, operation: :embed)[:model_or_offering]).to eq(999)
+    expect(inputs(settings)[:model_or_offering]).to eq(100) # chat draft: no inference key configured
+  end
+
+  it 'falls through to the model scope when no offering-scope key is configured' do
+    settings = settings_for(provider: { models: { 'model-y' => { weight: 200 } } })
+    expect(inputs(settings)[:model_or_offering]).to eq(200)
+  end
+
+  it 'raises when a multi-type draft has differing configured weights across its lanes' do
+    inference_key = lane_id(type: :inference)
+    embedding_key = lane_id(type: :embedding)
+    settings = settings_for(
+      provider: { offerings: { inference_key => { weight: 100 }, embedding_key => { weight: 200 } } }
+    )
+    expect do
+      schema.weight_inputs(
+        settings: settings, instance_key: instance_key, model: 'model-y', tier: :direct,
+        operation_evidence: operation_evidence(supported: %i[chat embed])
+      )
+    end.to raise_error(ArgumentError, /ambiguous/)
+
+    # Equal weights across the draft's lanes resolve to that weight.
+    settings = settings_for(
+      provider: { offerings: { inference_key => { weight: 100 }, embedding_key => { weight: 100 } } }
+    )
+    expect(
+      schema.weight_inputs(
+        settings: settings, instance_key: instance_key, model: 'model-y', tier: :direct,
+        operation_evidence: operation_evidence(supported: %i[chat embed])
+      )[:model_or_offering]
+    ).to eq(100)
+  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