lex-llm 0.7.3 → 0.8.0

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

@@ -6,131 +6,130 @@ require 'legion/extensions/llm/inventory/identity'
 RSpec.describe Legion::Extensions::Llm::Inventory::Identity do
   let(:errors) { Legion::Extensions::Llm::Inventory::Errors }
   let(:instance_key_class) { Legion::Extensions::Llm::Inventory::Identity::InstanceKey }
+  let(:taxonomies) { Legion::Extensions::Llm::Taxonomies }
 
-  fixture_path = File.expand_path('../conformance/fixtures/ssot_identity_vectors.json', __dir__)
-  fixture = Legion::JSON.load(File.read(fixture_path))
-
-  def hex(binary)
-    binary.b.unpack1('H*')
+  def compose(tier: :local, family: 'vllm', instance: 'h200', type: :inference, model: 'gemma4')
+    described_class.compose_lane_id(
+      tier: tier, provider_family: family, instance_id: instance, type: type, model: model
+    )
   end
 
-  describe 'binding identity vectors (recomputed field by field)' do
-    fixture[:vectors].each_with_index do |vector, index|
-      context "with vector #{index}: #{vector[:provider_family]}+#{vector[:instance_id]}" do
-        let(:instance_key) do
-          instance_key_class.new(
-            provider_family: vector[:provider_family],
-            instance_id: vector[:instance_id]
-          )
-        end
+  describe 'compose_lane_id (the ONE 5-tuple composer, G22)' do
+    it 'joins tier:provider_family:instance_id:type:model exactly' do
+      expect(compose).to eq('local:vllm:h200:inference:gemma4')
+    end
 
-        it 'reproduces every framed field as lowercase hex bytes' do
-          expect(hex(described_class.length_frame(value: instance_key.provider_family)))
-            .to eq(vector[:framed_hex][:provider_family])
-          expect(hex(described_class.length_frame(value: instance_key.instance_id)))
-            .to eq(vector[:framed_hex][:instance_id])
-          expect(hex(described_class.length_frame(value: vector[:provider_native_key])))
-            .to eq(vector[:framed_hex][:provider_native_key])
-          expect(hex(described_class.length_frame(value: vector[:operation])))
-            .to eq(vector[:framed_hex][:operation])
-          expect(hex(described_class.length_frame(value: vector[:model])))
-            .to eq(vector[:framed_hex][:model])
-        end
+    it 'is byte-identical to the v0.6.16 ScopedRefresher.compose_id shape' do
+      lane_fields = { tier: 'frontier', provider_family: 'openai', instance_id: 'prod', type: 'embedding', model: 'text-embed-3' }
+      expected = "#{lane_fields[:tier]}:#{lane_fields[:provider_family]}:#{lane_fields[:instance_id]}:#{lane_fields[:type]}:#{lane_fields[:model]}"
+      expect(
+        described_class.compose_lane_id(
+          tier: lane_fields[:tier], provider_family: lane_fields[:provider_family],
+          instance_id: lane_fields[:instance_id], type: lane_fields[:type], model: lane_fields[:model]
+        )
+      ).to eq(expected)
+    end
 
-        it 'reproduces the offering hash input and offering_id' do
-          input = described_class.length_frame(value: instance_key.provider_family) +
-                  described_class.length_frame(value: instance_key.instance_id) +
-                  described_class.length_frame(value: vector[:provider_native_key])
-          expect(hex(input)).to eq(vector[:offering_hash_input_hex])
+    it 'preserves colons inside the model part (Ollama model:tag, Bedrock ids)' do
+      id = compose(family: 'ollama', instance: 'apollo', model: 'llama3.2:8b-instruct')
+      expect(id).to eq('local:ollama:apollo:inference:llama3.2:8b-instruct')
 
-          offering_id = described_class.offering_id(
-            instance_key: instance_key, provider_native_key: vector[:provider_native_key]
-          )
-          expect(offering_id).to eq(vector[:expected_offering_id])
-        end
+      bedrock = compose(family: 'bedrock', instance: 'us-east-1', type: :inference, model: 'anthropic.claude-opus-4-7:0')
+      expect(bedrock).to eq('local:bedrock:us-east-1:inference:anthropic.claude-opus-4-7:0')
+    end
 
-        it 'reproduces the lane hash input and lane_id' do
-          offering_id = described_class.offering_id(
-            instance_key: instance_key, provider_native_key: vector[:provider_native_key]
-          )
-          input = "lane-v1\x00".b +
-                  described_class.length_frame(value: instance_key.provider_family) +
-                  described_class.length_frame(value: instance_key.instance_id) +
-                  described_class.length_frame(value: vector[:operation]) +
-                  described_class.length_frame(value: vector[:model]) +
-                  described_class.length_frame(value: offering_id)
-          expect(hex(input)).to eq(vector[:lane_hash_input_hex])
-
-          lane_id = described_class.lane_id(
-            instance_key: instance_key,
-            operation: vector[:operation].to_sym,
-            model: vector[:model],
-            offering_id: offering_id
+    it 'round-trips through parse_lane_id for every type and tier' do
+      taxonomies::TYPES.each do |type|
+        taxonomies::TIERS.each do |tier|
+          id = compose(tier: tier, type: type, model: 'model:tag:v1')
+          expect(described_class.parse_lane_id(id)).to eq(
+            [tier.to_s, 'vllm', 'h200', type.to_s, 'model:tag:v1']
           )
-          expect(lane_id).to eq(vector[:expected_lane_id])
-        end
-
-        it 'validates the reproduced offering_id and lane_id' do
-          offering_id = vector[:expected_offering_id]
-          expect(
-            described_class.validate_offering_id!(
-              value: offering_id, instance_key: instance_key, provider_native_key: vector[:provider_native_key]
-            )
-          ).to eq(offering_id)
-          expect(
-            described_class.validate_lane_id!(
-              value: vector[:expected_lane_id], instance_key: instance_key,
-              operation: vector[:operation].to_sym, model: vector[:model], offering_id: offering_id
-            )
-          ).to eq(vector[:expected_lane_id])
+          expect(described_class.validate_lane_id!(value: id)).to eq(id)
         end
       end
     end
   end
 
-  describe 'independence and delimiter safety' do
-    it 'produces distinct offering/lane IDs for the same model on two instance IDs' do
-      expect(fixture[:vectors][0][:expected_offering_id]).not_to eq(fixture[:vectors][1][:expected_offering_id])
-      expect(fixture[:vectors][0][:expected_lane_id]).not_to eq(fixture[:vectors][1][:expected_lane_id])
+  describe 'parse_lane_id (bounded split — the 5th part keeps its colons)' do
+    it 'returns exactly five parts with the model keeping its colons' do
+      expect(described_class.parse_lane_id('local:vllm:h200:inference:a:b:c')).to eq(
+        %w[local vllm h200 inference a:b:c]
+      )
     end
 
-    it 'is tier-independent: tier is never a framing input' do
-      vector = fixture[:vectors][0]
-      instance_key = instance_key_class.new(provider_family: vector[:provider_family], instance_id: vector[:instance_id])
-      %i[local frontier].each do |_tier|
-        offering_id = described_class.offering_id(
-          instance_key: instance_key, provider_native_key: vector[:provider_native_key]
-        )
-        expect(offering_id).to eq(vector[:expected_offering_id])
-        expect(
-          described_class.lane_id(
-            instance_key: instance_key, operation: vector[:operation].to_sym,
-            model: vector[:model], offering_id: offering_id
-          )
-        ).to eq(vector[:expected_lane_id])
-      end
+    it 'accepts a Symbol input' do
+      expect(described_class.parse_lane_id(:'local:vllm:h200:inference:gemma4')).to eq(
+        %w[local vllm h200 inference gemma4]
+      )
     end
 
-    it 'frames punctuation inside a component without delimiter ambiguity' do
-      vector = fixture[:vectors][2]
-      instance_key = instance_key_class.new(provider_family: vector[:provider_family], instance_id: vector[:instance_id])
-      expect(instance_key.instance_id).to eq('prod:eastus')
-      expect(
-        described_class.offering_id(instance_key: instance_key, provider_native_key: vector[:provider_native_key])
-      ).to eq(vector[:expected_offering_id])
+    it 'rejects fewer than five parts' do
+      expect { described_class.parse_lane_id('local:vllm:h200:inference') }
+        .to raise_error(errors::ValidationError, /exactly 5 parts, got 4/)
+    end
+
+    it 'never returns more than five parts (colons do not split further)' do
+      expect(described_class.parse_lane_id('local:vllm:h200:inference:x:y').length).to eq(5)
+    end
+
+    it 'rejects non-text input' do
+      expect { described_class.parse_lane_id(123) }.to raise_error(errors::ValidationError)
+    end
+  end
+
+  describe 'validate_lane_id!' do
+    it 'accepts a well-formed 5 tuple and returns it unchanged' do
+      expect(described_class.validate_lane_id!(value: 'cloud:gemini:default:audio:speech-2')).to eq('cloud:gemini:default:audio:speech-2')
+    end
+
+    it 'rejects any non-5-tuple value on the plain shape check alone' do
+      expect { described_class.validate_lane_id!(value: 'weird:identity') }
+        .to raise_error(errors::ValidationError, /exactly 5 parts, got 2/)
+      expect { described_class.validate_lane_id!(value: 'a:b:c:d') }
+        .to raise_error(errors::ValidationError, /exactly 5 parts, got 4/)
+    end
+
+    it 'rejects a tier outside Taxonomies::TIERS' do
+      expect { described_class.validate_lane_id!(value: 'bogus:vllm:h200:inference:gemma4') }
+        .to raise_error(errors::ValidationError, /tier/)
+    end
+
+    it 'rejects a type outside Taxonomies::TYPES' do
+      expect { described_class.validate_lane_id!(value: 'local:vllm:h200:moderation:gemma4') }
+        .to raise_error(errors::ValidationError, /type/)
+    end
+
+    it 'rejects an empty provider_family or instance_id' do
+      expect { described_class.validate_lane_id!(value: 'local::h200:inference:gemma4') }
+        .to raise_error(errors::ValidationError, /provider_family/)
+      expect { described_class.validate_lane_id!(value: 'local:vllm::inference:gemma4') }
+        .to raise_error(errors::ValidationError, /instance_id/)
+    end
+
+    it 'rejects an empty model' do
+      expect { described_class.validate_lane_id!(value: 'local:vllm:h200:inference:') }
+        .to raise_error(errors::ValidationError, /model/)
+    end
+
+    it 'rejects a non-NFC provider_family, instance_id, or model' do
+      decomposed = [0x0065, 0x0301].pack('U*') # e + combining acute; not NFC
+      expect { described_class.validate_lane_id!(value: "local:#{decomposed}vllm:h200:inference:gemma4") }
+        .to raise_error(errors::ValidationError, /provider_family/)
+      expect { described_class.validate_lane_id!(value: "local:vllm:#{decomposed}h200:inference:gemma4") }
+        .to raise_error(errors::ValidationError, /instance_id/)
+      expect { described_class.validate_lane_id!(value: "local:vllm:h200:inference:#{decomposed}emma4") }
+        .to raise_error(errors::ValidationError, /model/)
     end
   end
 
-  describe '.length_frame' do
-    it 'is decimal byte length + ASCII colon + exact UTF-8 bytes, in binary' do
-      frame = described_class.length_frame(value: 'gemma4')
-      expect(frame.encoding).to eq(Encoding::BINARY)
-      expect(frame).to eq('6:gemma4'.b)
+  describe 'independence' do
+    it 'produces distinct ids for the same model on two instance ids' do
+      expect(compose(instance: 'h200')).not_to eq(compose(instance: 'helios1'))
     end
 
-    it 'counts UTF-8 bytes, not characters' do
-      composed = [0x00e9].pack('U*') # single codepoint => two UTF-8 bytes
-      expect(described_class.length_frame(value: composed)).to eq('2:'.b + composed.b)
+    it 'is tier-SENSITIVE: the tier is the first id part (unlike the deleted digest)' do
+      expect(compose(tier: :local)).not_to eq(compose(tier: :frontier))
     end
   end
 
@@ -250,8 +249,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Identity do
           provider_family: :vllm, instance_id: 'apollo', physical_id: '10.0.0.9:9000'
         )
         expect(bare).to eq(with_physical)
-        expect(bare.hash).to eq(with_physical.hash)
-        expect(with_physical).to eq(other_physical)
+        expect(bare.hash).to eq(other_physical.hash)
         expect({ bare => :found }[with_physical]).to eq(:found)
       end
 
@@ -268,20 +266,39 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Identity do
       end
 
       it 'still distinguishes distinct config names on the same physical endpoint' do
-        apollo = instance_key_class.new(provider_family: :ollama, instance_id: 'apollo', physical_id: 'localhost:11434')
-        apollo_embed = instance_key_class.new(provider_family: :ollama, instance_id: 'apollo-embed', physical_id: 'localhost:11434')
+        apollo = instance_key_class.new(provider_family: 'ollama', instance_id: 'apollo', physical_id: 'localhost:11434')
+        apollo_embed = instance_key_class.new(provider_family: 'ollama', instance_id: 'apollo-embed', physical_id: 'localhost:11434')
         expect(apollo).not_to eq(apollo_embed)
       end
     end
   end
 
+  describe 'M6 — the single config→instance-id derivation (owner law)' do
+    it 'derives the operator config name from a provider config' do
+      config = Struct.new(:instance_id).new('h200')
+      expect(described_class.instance_id(config)).to eq('h200')
+    end
+
+    it 'uses the ordinary "default" label (not a reserved value) when no instance name is configured' do
+      expect(described_class.instance_id(Struct.new(:instance_id).new(nil))).to eq('default')
+      expect(described_class.instance_id({})).to eq('default')
+      expect(described_class.instance_id(nil)).to eq('default')
+    end
+  end
+
   describe 'public surface' do
-    it 'exposes exactly the seven documented module methods' do
+    it 'exposes exactly the documented module methods — no digest machinery' do
       expected = %i[
-        normalize_text normalize_enum length_frame offering_id lane_id
-        validate_offering_id! validate_lane_id!
+        normalize_text normalize_enum compose_lane_id parse_lane_id
+        validate_lane_id! instance_id
       ].sort
       expect(described_class.singleton_methods(false).sort).to eq(expected)
     end
+
+    it 'defines no digest encoder or legacy validator' do
+      %i[length_frame offering_id lane_id validate_offering_id!].each do |gone|
+        expect(described_class.singleton_methods(false)).not_to include(gone)
+      end
+    end
   end
 end

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

@@ -30,13 +30,13 @@ RSpec.describe Legion::Extensions::Llm::Inventory::ProbeToken do
     let(:token) { described_class.issue(instance_key: instance_key) }
 
     describe '.issue' do
-      it 'derives pub:v1: and ptok:v1: correlation IDs and is frozen' do
+      it 'mints pub:v1: and ptok:v1: correlation IDs and is frozen' do
         expect(token.publisher_id).to start_with('pub:v1:')
         expect(token.publisher_token_id).to start_with('ptok:v1:')
         expect(token).to be_frozen
       end
 
-      it 'derives publisher_token_id from the secret domain-separated SHA-256' do
+      it 'mints a distinct token id per issue' do
         other = described_class.issue(instance_key: instance_key)
         expect(token.publisher_token_id).not_to eq(other.publisher_token_id)
       end
@@ -70,9 +70,9 @@ RSpec.describe Legion::Extensions::Llm::Inventory::ProbeToken do
         expect(token.authenticates?(Object.new)).to be(false)
       end
 
-      it 'authenticates two tokens built from the same secret' do
+      it 'authenticates two tokens built from the same secret (fencing is the secret comparison)' do
         secret = 'deadbeef' * 8
-        token_id = described_class.derive_token_id(secret)
+        token_id = "ptok:v1:#{SecureRandom.uuid}"
         a = described_class.new(instance_key: instance_key, secret: secret, publisher_id: 'pub:v1:x', publisher_token_id: token_id)
         b = described_class.new(instance_key: instance_key, secret: secret, publisher_id: 'pub:v1:y', publisher_token_id: token_id)
         expect(a.authenticates?(b)).to be(true)

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

@@ -11,21 +11,6 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Publisher do
 
   before { inventory::Registry.reset! }
 
-  # Records adapter invocations; returns a configurable outcome.
-  let(:adapter_calls) { [] }
-  let(:adapter_outcome) { [:applied] }
-  let(:adapter) do
-    calls = adapter_calls
-    outcome = adapter_outcome
-    Object.new.tap do |obj|
-      obj.define_singleton_method(:sync_snapshot) do |snapshot:, instance_key:, mutation_reason:|
-        calls << { snapshot: snapshot, instance_key: instance_key, mutation_reason: mutation_reason }
-        outcome.first
-      end
-    end
-  end
-
-  let(:publisher) { described_class.new(provider_family: :vllm, compatibility_adapter: adapter) }
   let(:plain_publisher) { described_class.new(provider_family: :vllm) }
 
   def full_activate(pub)
@@ -49,56 +34,18 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Publisher do
       expect(result.applied).to be(true)
       expect(plain_publisher.snapshot.instance(instance_key: instance_key)).to be_nil
     end
-  end
 
-  describe 'post-commit compatibility projection' do
-    it 'invokes the adapter after a successful claim and applied mutation with the committed snapshot' do
-      full_activate(publisher)
-      expect(adapter_calls.map { |c| c[:mutation_reason] }).to eq(%i[claimed activated])
-      # The adapter sees the already-committed snapshot on activation.
-      activation_call = adapter_calls.last
-      expect(activation_call[:snapshot].instance(instance_key: instance_key).availability.state).to eq(:available)
-      expect(activation_call[:instance_key]).to eq(instance_key)
+    it 'M7: exposes no legacy dual-sink seam (the compatibility adapter is deleted)' do
+      expect { described_class.new(provider_family: :vllm, compatibility_adapter: Object.new) }
+        .to raise_error(ArgumentError, /compatibility_adapter/)
+      expect(described_class.instance_method(:initialize).parameters).not_to include(%i[key compatibility_adapter])
     end
 
-    it 'does not invoke the adapter for a non-applied (stale) mutation' do
-      token = full_activate(publisher)
-      adapter_calls.clear
-      # Supersede the publisher, then a stale replace returns applied: false.
-      publisher.claim_instance(instance_id: 'h200', callable: fake_callable, probe_request_handle: probe_coordinator(instance_key))
-      adapter_calls.clear
-      result = publisher.replace_instance_snapshot(instance_id: 'h200', publisher_token: token, offerings: drafts, sequence: 9)
+    it 'replaces the same scope when a new claim supersedes the publisher' do
+      token = full_activate(plain_publisher)
+      plain_publisher.claim_instance(instance_id: 'h200', callable: fake_callable, probe_request_handle: probe_coordinator(instance_key))
+      result = plain_publisher.replace_instance_snapshot(instance_id: 'h200', publisher_token: token, offerings: drafts, sequence: 9)
       expect(result.applied).to be(false)
-      expect(adapter_calls).to be_empty
-    end
-
-    it 'never changes the local result when the adapter returns :failed' do
-      adapter_outcome[0] = :failed
-      token = publisher.claim_instance(instance_id: 'h200', callable: fake_callable, probe_request_handle: probe_coordinator(instance_key))
-      expect(token).to be_a(inventory::PublisherToken)
-    end
-
-    it 'never changes the local result when the adapter raises' do
-      failing = Object.new.tap do |obj|
-        obj.define_singleton_method(:sync_snapshot) { |**| raise 'boom' }
-      end
-      pub = described_class.new(provider_family: :vllm, compatibility_adapter: failing)
-      expect { pub.claim_instance(instance_id: 'h200', callable: fake_callable, probe_request_handle: probe_coordinator(instance_key)) }
-        .not_to raise_error
-    end
-
-    it 'invokes the adapter again on the next applied cadence mutation' do
-      token = full_activate(publisher)
-      adapter_calls.clear
-      publisher.replace_instance_snapshot(instance_id: 'h200', publisher_token: token, offerings: drafts(native: 'gemma5', model: 'gemma5'), sequence: 1)
-      expect(adapter_calls.map { |c| c[:mutation_reason] }).to eq(%i[snapshot_replaced])
-    end
-  end
-
-  describe 'without a compatibility adapter' do
-    it 'performs no projection and returns the plain registry results' do
-      result = full_activate(plain_publisher)
-      expect(result).to be_a(inventory::PublisherToken)
     end
   end
 

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

@@ -16,9 +16,11 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
   end
   let(:callable_handle) { inventory::CallableHandle.new(handle_id: 'call:v1:test', callable: callable_class.new) }
   let(:instance_key) { identity::InstanceKey.new(provider_family: 'vllm', instance_id: 'h200') }
-  let(:offering_id) { identity.offering_id(instance_key: instance_key, provider_native_key: 'gemma4') }
   let(:lane_id) do
-    identity.lane_id(instance_key: instance_key, operation: :chat, model: 'gemma4', offering_id: offering_id)
+    identity.compose_lane_id(
+      tier: :local, provider_family: 'vllm', instance_id: 'h200',
+      type: taxonomies.lane_type_for(operation: :chat), model: 'gemma4'
+    )
   end
 
   def value_unknown
@@ -48,16 +50,57 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
     )
   end
 
-  def build_offering_record(**overrides)
-    Legion::Extensions::Llm::Inventory::OfferingRecord.new(
-      offering_id: offering_id, provider_native_key: 'gemma4', instance_key: instance_key, model: 'gemma4',
-      tier: :local, operation_evidence: full_operation_evidence(supported: %i[chat]), capability_evidence: {},
-      quota_domains: {}, metadata: {}, callable_handle: callable_handle, publication_source: :provider_catalog,
+  def build_lane(**overrides)
+    Legion::Extensions::Llm::Inventory::LaneRecord.new(
+      lane_id: lane_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
@@ -111,52 +154,77 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
     end
   end
 
-  describe inventory::OfferingRecord do
-    it 'validates offering_id reproduction and exposes operation views' do
-      record = build_offering_record
-      expect(record.supported_operations).to eq(%i[chat])
-      expect(record.operation_status(operation: :chat)).to eq(:supported)
-      expect(record.operation_status(operation: :embed)).to eq(:unknown)
-      expect(record.capability_status(capability: :vision)).to eq(:unknown)
-      expect(record.unknown_operations).to include(:embed)
+  describe 'OfferingRecord (deleted — D2: in the one bucket an offering IS a lane)' do
+    it 'is not defined' do
+      expect(inventory.const_defined?(:OfferingRecord, false)).to be(false)
     end
+  end
 
-    it 'rejects an offering_id that does not reproduce' do
-      expect { build_offering_record(offering_id: "off:v1:#{'0' * 64}") }.to raise_error(errors::ValidationError)
+  describe inventory::LaneRecord do
+    def build_record(**overrides)
+      build_lane(**overrides)
     end
 
-    it 'rejects a non-InstanceKey and a non-CallableHandle' do
-      expect { build_offering_record(instance_key: :vllm) }.to raise_error(errors::ValidationError)
-      expect { build_offering_record(callable_handle: Object.new) }.to raise_error(errors::ValidationError)
+    it_behaves_like 'an atomic immutable weight pair'
+
+    it 'builds a valid lane whose id reproduces from its fields' do
+      expect(build_lane.lane_id).to eq('local:vllm:h200:inference:gemma4')
+      expect(build_lane.lane_id).to be_frozen
     end
 
-    it 'returns the quota domain for an operation' do
-      record = build_offering_record(quota_domains: { chat: 'domain-a' })
-      expect(record.quota_domain(operation: :chat)).to eq('domain-a')
-      expect(record.quota_domain(operation: :embed)).to be_nil
+    it 'has no offering_id member — the 5 tuple is the single id' do
+      expect(build_lane.members).not_to include(:offering_id)
+      expect(build_lane.to_h.keys).to contain_exactly(
+        :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, :weight_inputs, :base_weight
+      )
     end
-  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
+    it 'derives the id type part from the operation (embed → embedding)' do
+      embed_id = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'h200',
+        type: taxonomies.lane_type_for(operation: :embed), model: 'gemma4'
       )
+      lane = build_lane(lane_id: embed_id, operation: :embed)
+      expect(lane.lane_id).to eq('local:vllm:h200:embedding:gemma4')
     end
 
-    it 'builds a valid lane whose id reproduces' do
-      expect(build_lane.lane_id).to eq(lane_id)
+    it 'keeps colons inside the model part of the id' do
+      colon_model = 'llama3.2:8b-instruct'
+      id = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'h200',
+        type: taxonomies.lane_type_for(operation: :chat), model: colon_model
+      )
+      lane = build_lane(lane_id: id, model: colon_model)
+      expect(lane.lane_id).to eq("local:vllm:h200:inference:#{colon_model}")
+      expect(identity.parse_lane_id(lane.lane_id).last).to eq(colon_model)
     end
 
     it 'rejects provider_family/instance_id not equal to instance_key' do
       expect { build_lane(instance_id: 'helios1') }.to raise_error(errors::ValidationError)
     end
 
-    it 'rejects a lane_id that does not reproduce' do
-      expect { build_lane(lane_id: "lane:v1:#{'0' * 64}") }.to raise_error(errors::ValidationError)
+    it 'rejects a lane_id that does not reproduce from the record fields' do
+      other = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'helios1',
+        type: :inference, model: 'gemma4'
+      )
+      expect { build_lane(lane_id: other) }.to raise_error(errors::ValidationError, /does not reproduce/)
+    end
+
+    it 'rejects a lane_id whose type part disagrees with the operation' do
+      wrong_type = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'h200',
+        type: :embedding, model: 'gemma4'
+      )
+      expect { build_lane(lane_id: wrong_type) }.to raise_error(errors::ValidationError, /does not reproduce/)
+    end
+
+    it 'rejects a lane_id that is not a 5-tuple' do
+      expect { build_lane(lane_id: 'not-a-five-tuple') }
+        .to raise_error(errors::ValidationError)
     end
   end
 
@@ -216,19 +284,39 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
 
   describe inventory::InstanceRecord do
     def build_instance(**overrides)
+      lane = build_lane
       Legion::Extensions::Llm::Inventory::InstanceRecord.new(
         instance_key: instance_key, callable_handle: callable_handle,
         availability: Legion::Extensions::Llm::Inventory::AvailabilityFact.new(
           state: :available, availability_revision: 1, source: :startup_readiness, reason: 'activated', observed_at: nil
         ),
-        offerings_by_id: { offering_id => build_offering_record },
+        lanes_by_id: { lane.lane_id => lane },
         publisher_id: 'pub:v1:x', publisher_token_id: 'ptok:v1:y', published_sequence: 1, published_at: Time.now,
         **overrides
       )
     end
 
-    it 'builds an available instance with a complete offerings map' do
-      expect(build_instance.offerings_by_id).to be_frozen
+    it 'builds an available instance with a complete 5-tuple-keyed lanes map' do
+      record = build_instance
+      expect(record.lanes_by_id).to be_frozen
+      expect(record.lanes_by_id.keys).to eq(%w[local:vllm:h200:inference:gemma4])
+    end
+
+    it 'rejects a lane whose key does not equal its own id' do
+      lane = build_lane
+      expect do
+        build_instance(lanes_by_id: { 'local:vllm:h200:inference:other' => lane })
+      end.to raise_error(errors::ValidationError, /key mismatch/)
+    end
+
+    it 'rejects a lane that does not share the instance callable/key' do
+      other_key = identity::InstanceKey.new(provider_family: 'vllm', instance_id: 'helios1')
+      other_id = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'helios1', type: :inference, model: 'gemma4'
+      )
+      other_lane = build_lane(lane_id: other_id, instance_key: other_key, instance_id: 'helios1')
+      expect { build_instance(lanes_by_id: { other_id => other_lane }) }
+        .to raise_error(errors::ValidationError, %r{callable/key})
     end
 
     it 'rejects an initializing availability' do
@@ -238,8 +326,8 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Records do
       expect { build_instance(availability: initializing) }.to raise_error(errors::ValidationError)
     end
 
-    it 'accepts an explicit empty offerings map' do
-      expect(build_instance(offerings_by_id: {}).offerings_by_id).to eq({})
+    it 'accepts an explicit empty lanes map' do
+      expect(build_instance(lanes_by_id: {}).lanes_by_id).to eq({})
     end
   end