lex-llm 0.7.6 → 0.8.4

data/spec/legion/extensions/llm/canonical/usage_spec.rb

@@ -1,178 +1,69 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require_relative '../conformance/conformance'
 
 RSpec.describe Legion::Extensions::Llm::Canonical::Usage do
-  describe '.from_hash' do
-    it 'returns a Usage instance with canonical fields' do
-      usage = described_class.from_hash(input_tokens: 100, output_tokens: 50)
-
-      expect(usage).to be_a(described_class)
-      expect(usage.input_tokens).to eq(100)
-      expect(usage.output_tokens).to eq(50)
-      expect(usage.cache_read_tokens).to be_nil
-      expect(usage.cache_write_tokens).to be_nil
-      expect(usage.thinking_tokens).to be_nil
-      expect(usage.units).to eq({})
-    end
-
-    it 'normalizes legacy key names' do
-      usage = described_class.from_hash(
-        input: 200, output: 100, cached: 50, cache_creation: 25, thinking: 10
-      )
-
-      expect(usage.input_tokens).to eq(200)
-      expect(usage.output_tokens).to eq(100)
-      expect(usage.cache_read_tokens).to eq(50)
-      expect(usage.cache_write_tokens).to eq(25)
-      expect(usage.thinking_tokens).to eq(10)
-    end
-
-    it 'normalizes prompt_tokens/completion_tokens aliases' do
-      usage = described_class.from_hash(prompt_tokens: 300, completion_tokens: 150)
-
-      expect(usage.input_tokens).to eq(300)
-      expect(usage.output_tokens).to eq(150)
-    end
-
-    it 'normalizes reasoning alias for thinking_tokens' do
-      usage = described_class.from_hash(reasoning: 75)
-
-      expect(usage.thinking_tokens).to eq(75)
-    end
-
-    it 'handles string keys' do
-      usage = described_class.from_hash('input_tokens' => '100', 'output_tokens' => '50')
-
-      expect(usage.input_tokens).to eq('100')
-      expect(usage.output_tokens).to eq('50')
-    end
-
-    it 'returns nil for nil source' do
-      expect(described_class.from_hash(nil)).to be_nil
-    end
-
-    it 'returns nil for empty hash' do
-      expect(described_class.from_hash({})).to be_nil
-    end
-
-    it 'preserves units extension point' do
-      units = { images: 3, characters: 1500 }
-      usage = described_class.from_hash(input_tokens: 10, units: units)
-
-      expect(usage.units).to eq(units)
-    end
+  let(:type_class) { described_class }
+  let(:auto_generated_members) { [] }
+  let(:type_source) do
+    {
+      input_tokens: 100,
+      output_tokens: 50,
+      cache_read_tokens: 10,
+      cache_write_tokens: 5,
+      thinking_tokens: 25,
+      units: { images: 1 },
+      metadata: { source: 'provider' }
+    }
   end
 
-  describe '#to_h' do
-    it 'serializes to compact hash' do
-      usage = described_class.new(
-        input_tokens: 100, output_tokens: 50,
-        cache_read_tokens: nil, cache_write_tokens: nil,
-        thinking_tokens: nil, units: {}
-      )
-      hash = usage.to_h
-
-      expect(hash).to eq(input_tokens: 100, output_tokens: 50, units: {})
-    end
-
-    it 'includes all non-nil fields' do
-      usage = described_class.new(
-        input_tokens: 200, output_tokens: 100,
-        cache_read_tokens: 50, cache_write_tokens: 25,
-        thinking_tokens: 10, units: { images: 2 }
-      )
-      hash = usage.to_h
+  it_behaves_like 'a canonical type'
 
-      expect(hash).to include(
-        input_tokens: 200, output_tokens: 100,
-        cache_read_tokens: 50, cache_write_tokens: 25,
-        thinking_tokens: 10, units: { images: 2 }
-      )
+  describe 'H1/M3 — Integer token validation in every constructor' do
+    it 'rejects a string token count in build, from_hash, and .new' do
+      expect { described_class.build(input_tokens: 'many') }
+        .to raise_error(ArgumentError, /input_tokens expected Integer, got String/)
+      expect { described_class.from_hash(output_tokens: 3.5) }
+        .to raise_error(ArgumentError, /output_tokens expected Integer, got Float/)
+      expect { described_class.new(thinking_tokens: 'x', units: 42) }
+        .to raise_error(ArgumentError)
     end
   end
 
-  describe '#total_tokens' do
-    it 'sums all token categories' do
-      usage = described_class.new(
-        input_tokens: 100, output_tokens: 50,
-        cache_read_tokens: 20, cache_write_tokens: 10,
-        thinking_tokens: 5, units: {}
-      )
-
-      expect(usage.total_tokens).to eq(185)
+  describe 'O03a — canonical keys only' do
+    it 'does not translate provider spellings (they fold into metadata)' do
+      usage = described_class.from_hash(prompt_tokens: 7, completion_tokens: 3)
+      expect(usage.input_tokens).to be_nil
+      expect(usage.output_tokens).to be_nil
+      expect(usage.metadata).to eq(prompt_tokens: 7, completion_tokens: 3)
     end
 
-    it 'ignores nil values' do
-      usage = described_class.new(
-        input_tokens: 100, output_tokens: 50,
-        cache_read_tokens: nil, cache_write_tokens: nil,
-        thinking_tokens: nil, units: {}
-      )
-
-      expect(usage.total_tokens).to eq(150)
+    it 'does not dig nested *_tokens_details (edge concern)' do
+      usage = described_class.from_hash(prompt_tokens_details: { cached_tokens: 9 })
+      expect(usage.cache_read_tokens).to be_nil
+      expect(usage.metadata).to eq(prompt_tokens_details: { cached_tokens: 9 })
     end
   end
 
-  describe 'OpenAI nested details extraction' do
-    it 'extracts cached_tokens from prompt_tokens_details (Chat API)' do
-      usage = described_class.from_hash(
-        prompt_tokens: 1000,
-        completion_tokens: 200,
-        prompt_tokens_details: { cached_tokens: 800 },
-        completion_tokens_details: { reasoning_tokens: 50 }
-      )
-
-      expect(usage.input_tokens).to eq(1000)
-      expect(usage.output_tokens).to eq(200)
-      expect(usage.cache_read_tokens).to eq(800)
-      expect(usage.thinking_tokens).to eq(50)
-    end
-
-    it 'extracts cached_tokens from input_tokens_details (Responses API)' do
-      usage = described_class.from_hash(
-        input_tokens: 500,
-        output_tokens: 100,
-        input_tokens_details: { cached_tokens: 400 },
-        output_tokens_details: { reasoning_tokens: 30 }
-      )
-
-      expect(usage.input_tokens).to eq(500)
-      expect(usage.output_tokens).to eq(100)
-      expect(usage.cache_read_tokens).to eq(400)
-      expect(usage.thinking_tokens).to eq(30)
-    end
-
-    it 'prefers top-level cache_read_tokens over nested details' do
-      usage = described_class.from_hash(
-        input_tokens: 500,
-        cache_read_tokens: 300,
-        prompt_tokens_details: { cached_tokens: 400 }
-      )
-
-      expect(usage.cache_read_tokens).to eq(300)
+  describe 'construction law' do
+    it 'from_hash({}) is a valid all-nil Usage with empty units (never nil)' do
+      usage = described_class.from_hash({})
+      expect(usage).to be_a(described_class)
+      expect(usage.input_tokens).to be_nil
+      expect(usage.units).to eq({})
     end
-  end
 
-  describe 'round-trip' do
-    it 'preserves values through from_hash/to_h' do
-      original = { input_tokens: 100, output_tokens: 50, cache_read_tokens: 10 }
-      usage = described_class.from_hash(original)
-      serialized = usage.to_h
-
-      expect(serialized[:input_tokens]).to eq(100)
-      expect(serialized[:output_tokens]).to eq(50)
-      expect(serialized[:cache_read_tokens]).to eq(10)
+    it 'builds from keyword args' do
+      usage = described_class.build(input_tokens: 1, output_tokens: 2)
+      expect(usage.total_tokens).to eq(3)
     end
 
-    it 'preserves legacy key normalization through round-trip' do
-      original = { input: 200, output: 100, cached: 50 }
-      usage = described_class.from_hash(original)
-      serialized = usage.to_h
-
-      expect(serialized[:input_tokens]).to eq(200)
-      expect(serialized[:output_tokens]).to eq(100)
-      expect(serialized[:cache_read_tokens]).to eq(50)
+    it 'survives build → to_h → JSON → from_hash (T4 units)' do
+      usage = described_class.build(input_tokens: 1, units: { images: 2 })
+      round_tripped = described_class.from_hash(Legion::JSON.load(Legion::JSON.dump(usage.to_h)))
+      expect(round_tripped.units).to eq(images: 2)
+      expect(round_tripped.input_tokens).to eq(1)
     end
   end
 end

data/spec/legion/extensions/llm/configuration_spec.rb

@@ -15,11 +15,13 @@ RSpec.describe Legion::Extensions::Llm::Configuration do
     end
 
     it 'exposes a discoverable options API' do
-      expect(described_class.options).to include(
-        :request_timeout,
-        :default_model,
-        :default_embedding_model,
-        :model_registry_file
+      expect(described_class.options).to include(:request_timeout)
+    end
+
+    it 'declares no model-defaulting options (H4: model choice belongs to the router)' do
+      expect(described_class.options).not_to include(
+        :default_model, :default_embedding_model, :default_moderation_model,
+        :default_image_model, :default_transcription_model
       )
     end
 
@@ -36,6 +38,30 @@ RSpec.describe Legion::Extensions::Llm::Configuration do
     end
   end
 
+  describe 'L5 — log defaults come from the settings system (no ENV reads)' do
+    around do |example|
+      original_extensions = Legion::Settings.loader.settings[:extensions]
+      example.run
+    ensure
+      Legion::Settings.loader.settings[:extensions] = original_extensions
+    end
+
+    it 'defaults log_level to INFO and log_stream_debug to false when settings are unset' do
+      Legion::Settings.loader.settings[:extensions] = {}
+      expect(described_class.log_settings_defaults).to eq(level: Logger::INFO, stream_debug: false)
+    end
+
+    it 'reads log_level / log_stream_debug from extensions.llm settings' do
+      Legion::Settings.loader.settings[:extensions] = { llm: { log_level: :debug, log_stream_debug: true } }
+      expect(described_class.log_settings_defaults).to eq(level: Logger::DEBUG, stream_debug: true)
+    end
+
+    it 'raises on an unknown log_level name (configuration error, no fallback)' do
+      Legion::Settings.loader.settings[:extensions] = { llm: { log_level: :bogus } }
+      expect { described_class.log_settings_defaults }.to raise_error(NameError)
+    end
+  end
+
   describe '.register_provider_options' do
     after do
       # Clean up test options to avoid polluting other specs

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# 09 §1 — canonical type conformance: the T-groups as shared examples.
+#
+# The including spec supplies:
+#   let(:type_class)  — the Canonical type
+#   let(:type_source) — a Hash exercising the members (from_hash input)
+#   optionally:
+#     let(:auto_generated_members) — member names filled by the factory when
+#     absent from the source (id, timestamp), excluded from member-equality
+#     checks.
+#
+# Type-specific laws (T4 member survival, T5 enum law, T7 member normalization
+# for the type's normalizable members) are asserted in each type spec.
+
+RSpec.shared_examples 'a canonical type' do
+  let(:type) { type_class }
+  let(:built) { type.from_hash(type_source) }
+
+  describe 'T1 — strict input' do
+    it 'raises a typed ArgumentError on nil (no nil factory)' do
+      expect { type.from_hash(nil) }
+        .to raise_error(ArgumentError, /expected Hash, got NilClass/)
+    end
+
+    it 'raises a typed ArgumentError naming the offending class on wrong-class input' do
+      expect { type.from_hash('not a hash') }
+        .to raise_error(ArgumentError, /expected Hash, got String/)
+      expect { type.from_hash(42) }
+        .to raise_error(ArgumentError, /expected Hash, got Integer/)
+    end
+
+    it 'never returns nil from from_hash (valid instances or typed raises only)' do
+      expect(type.from_hash(type_source)).not_to be_nil
+      result =
+        begin
+          type.from_hash({})
+        rescue ArgumentError
+          :typed_raise
+        end
+      expect(result).not_to be_nil
+    end
+  end
+
+  describe 'T2 — unknown-key policy (04 L5)' do
+    it 'folds unknown keys into metadata verbatim — no drops, no raises' do
+      source = type_source.merge(fleet_unknown_key: 'kept', other_unknown: [1, 2])
+      instance = type.from_hash(source)
+
+      expect(instance.metadata).to include(fleet_unknown_key: 'kept', other_unknown: [1, 2])
+    end
+
+    it 'round-trips the folded unknowns' do
+      source = type_source.merge(fleet_unknown_key: 'kept')
+      instance = type.from_hash(source)
+      expect(type.from_hash(instance.to_h).metadata).to include(fleet_unknown_key: 'kept')
+    end
+  end
+
+  describe 'T3 — round-trip identity (04 L7)' do
+    it 'build → to_h → from_hash → Data-equal' do
+      expect(type.from_hash(built.to_h)).to eq(built)
+    end
+
+    it 'to_h is a plain Hash with symbol keys (no member lost, no key invented)' do
+      hash = built.to_h
+      expect(hash).to be_a(Hash)
+      expect(hash.keys).to all(be_a(Symbol))
+      checkable = (type.members.map(&:to_sym) - auto_generated_members)
+      checkable.each do |member|
+        value = built.public_send(member)
+        next if value.nil?
+
+        expect(hash.key?(member)).to be(true)
+      end
+    end
+  end
+
+  describe 'T6 — serialization uniformity (04 L8)' do
+    it 'as_json == to_h and to_json == to_h.to_json' do
+      expect(built.as_json).to eq(built.to_h)
+      expect(built.to_json).to eq(built.to_h.to_json)
+    end
+  end
+
+  # H1: .new is the single strict constructor — it runs the same member
+  # contract as the factories. Poison that passes an is_a? check is not
+  # constructible through ANY public path.
+  describe 'T8 — strict .new (H1: one validated constructor)' do
+    let(:member_kwargs) { type_source.transform_keys(&:to_sym) }
+
+    it 'rejects unknown members with a typed ArgumentError (no silent drops)' do
+      expect { type_class.new(**member_kwargs, not_a_member: true) }
+        .to raise_error(ArgumentError, /not_a_member/)
+    end
+
+    it 'rejects a non-Hash metadata member' do
+      expect { type_class.new(**member_kwargs, metadata: 'not-a-hash') }
+        .to raise_error(ArgumentError, /metadata expected Hash, got String/)
+    end
+
+    it 'constructs valid data (the factories and .new share one contract)' do
+      expect { type_class.new(**member_kwargs) }.not_to raise_error
+    end
+  end
+end

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

@@ -10,7 +10,7 @@
 #
 # Usage:
 #   it_behaves_like 'a canonical client translator', MyClientTranslatorClass
-# rubocop:disable Lint/NonLocalExitFromIterator -- return guard is idiomatic in shared_example blocks
+# rubocop:disable-next Lint/NonLocalExitFromIterator -- return guard is idiomatic in shared_example blocks
 RSpec.shared_examples 'a canonical client translator' do |translator_class|
   let(:translator) { translator_class.new }
   let(:canonical) { Legion::Extensions::Llm::Canonical }
@@ -429,4 +429,3 @@ RSpec.shared_examples 'a canonical client translator' do |translator_class|
     end
   end
 end
-# rubocop:enable Lint/NonLocalExitFromIterator

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

@@ -5,10 +5,17 @@
 # Ship location: spec/legion/extensions/llm/conformance/
 # Module: Canonical::Conformance
 #
-# Consumer pattern (in provider gem spec_helper):
+# Consumer pattern (in provider gem spec_helper) — load the kit's example
+# modules BY EXPLICIT NAME. Do NOT glob the kit dir: it also ships lex-llm's
+# own self-test specs (echo_translator_spec, ssot_*_conformance_spec) plus
+# their support files, which LoadError outside this repo.
 #   kit = File.join(Gem.loaded_specs['lex-llm'].full_gem_path,
 #                   'spec/legion/extensions/llm/conformance')
-#   Dir[File.join(kit, '**', '*.rb')].sort.each { |f| require f }
+#   %w[conformance.rb canonical_type_examples.rb client_translator_examples.rb
+#       provider_translator_examples.rb provider_tool_rendering_examples.rb
+#       ssot_contract_examples.rb ssot_provider_examples.rb].each do |f|
+#     require File.join(kit, f)
+#   end
 #
 # Then in specs:
 #   it_behaves_like 'a canonical provider translator', described_class
@@ -47,5 +54,6 @@ module Canonical
   end
 end
 
+require_relative 'canonical_type_examples'
 require_relative 'provider_translator_examples'
 require_relative 'client_translator_examples'

data/spec/legion/extensions/llm/conformance/fixtures/canonical_fleet_round_trip.json

@@ -21,7 +21,7 @@
       }
     },
     "params": { "max_tokens": 1024, "temperature": 0.5 },
-    "thinking": { "effort": "low", "budget": 1024 },
+    "thinking": { "enabled": true, "effort": "low", "budget": 1024 },
     "stream": false,
     "conversation_id": "conv_fleet_rt_001",
     "caller": { "type": "anthropic_messages", "client_id": "test_client" },

data/spec/legion/extensions/llm/conformance/fixtures/canonical_thinking_request.json

@@ -8,12 +8,12 @@
     }
   ],
   "thinking": {
+    "enabled": true,
     "effort": "high",
     "budget": 4096
   },
   "params": {
-    "max_tokens": 2048,
-    "max_thinking_tokens": 4096
+    "max_tokens": 2048
   },
   "stream": false
 }

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

@@ -298,7 +298,7 @@ RSpec.shared_examples 'a canonical provider translator' do |translator_class|
       it 'preserves tool call identity across chunks' do
         tool_chunks = chunks.select { |c| c['type'] == 'tool_call_delta' }
         parsed_chunks = tool_chunks.map { |c| translator.parse_chunk(c) }
-        ids = parsed_chunks.map { |c| c.tool_call&.id }
+        ids = parsed_chunks.map { |c| c.tool_call.is_a?(Hash) ? c.tool_call[:id] : c.tool_call&.id }
         expect(ids.uniq.length).to eq(1)
       end
     end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/llm/inventory/registry'
+require 'support/ssot_registry_helpers'
+require_relative 'conformance'
+require_relative 'ssot_contract_examples'
+
+# Kit self-test: the B/F/R shared examples run against a real Provider-derived
+# callable, the real Registry, and the real fleet responder/worker — proving
+# the examples provider gems will load are executable and meaningful.
+# rubocop:disable-next RSpec/DescribeClass, RSpec/MultipleMemoizedHelpers -- kit host
+RSpec.describe 'SSOT v4 contract conformance kit' do
+  include SsotRegistryHelpers
+
+  let(:registry) { Legion::Extensions::Llm::Inventory::Registry }
+  let(:family) { :fake_llm }
+  let(:key) do
+    Legion::Extensions::Llm::Inventory::Identity::InstanceKey.new(provider_family: family, instance_id: 'primary')
+  end
+  let(:coordinator) { probe_coordinator(key) }
+  let(:activated) { true }
+
+  # A real 0.8.0 callable: Provider-derived, canonical in and out, no HTTP.
+  let(:callable) do
+    Class.new(Legion::Extensions::Llm::Provider) do
+      def self.slug = 'kit'
+      def self.configuration_requirements = []
+      def api_base = 'https://kit.invalid'
+
+      def chat(messages, model:, tools: nil, **_rest)
+        enforce_canonical_messages!(messages)
+        enforce_canonical_tools!(tools)
+        Legion::Extensions::Llm::Canonical::Response.build(text: 'ok', model: model, stop_reason: :end_turn)
+      end
+
+      # rubocop:disable-next Lint/UnusedMethodArgument -- model: mirrors the 0.8.0 callable contract
+      def stream_chat(messages, model: nil, tools: nil, **_contract, &block)
+        enforce_canonical_messages!(messages)
+        enforce_canonical_tools!(tools)
+        block&.call(Legion::Extensions::Llm::Canonical::Chunk.text_delta(delta: 'ok', request_id: nil))
+        block&.call(Legion::Extensions::Llm::Canonical::Chunk.done(request_id: nil, stop_reason: :end_turn,
+                                                                   usage: Legion::Extensions::Llm::Canonical::Usage.build(input_tokens: 1)))
+        nil
+      end
+
+      def count_tokens(messages:, **_contract)
+        enforce_canonical_messages!(messages)
+        1
+      end
+    end.new(Legion::Extensions::Llm.config)
+  end
+  let(:instance_key) { key }
+  let(:lane_id) { registry.snapshot.lanes_for(instance_key: key).first.lane_id }
+  # The fleet claim field keeps the name offering_id (D4 protocol continuity);
+  # its value is the lane's 5 tuple.
+  let(:offering_id) { lane_id }
+  let(:callable_handle) { registry.snapshot.instance(instance_key: key).callable_handle }
+  let(:operation_evidence_map) { operation_evidence }
+  let(:unknown_value) do
+    Legion::Extensions::Llm::Inventory::ValueEvidence.new(status: :unknown, source: :absent)
+  end
+  let(:exact_envelope_data) do
+    {
+      request_id: 'req-1', correlation_id: 'corr-1', idempotency_key: 'idem-1',
+      operation: 'chat', provider: family.to_s, provider_instance: 'primary', model: 'gemma4',
+      params: { messages: [{ role: 'user', content: 'hello' }] },
+      reply_to: 'reply.1', message_context: {}, caller: 'e2e', trace_context: {},
+      signed_token: 'unsigned', timeout_seconds: 30,
+      expires_at: (Time.now.utc + 120).iso8601,
+      protocol_version: Legion::Extensions::Llm::Fleet::Protocol::VERSION,
+      execution_contract: Legion::Extensions::Llm::Fleet::Protocol::EXACT_EXECUTION_CONTRACT,
+      offering_id: offering_id
+    }
+  end
+  let(:valid_request_options) do
+    {
+      routing_key: 'llm.fleet.inference.gemma4.ctx8192',
+      request_id: 'req-1', correlation_id: 'corr-1', idempotency_key: 'idem-1',
+      operation: :chat, provider: family.to_s, provider_instance: 'primary', model: 'gemma4',
+      params: { messages: [{ role: 'user', content: 'hello' }] },
+      reply_to: 'reply.1', message_context: {}, caller: 'e2e', trace_context: {},
+      signed_token: 'signed.jwt', timeout_seconds: 30, expires_at: '2026-08-20T12:00:00Z',
+      protocol_version: Legion::Extensions::Llm::Fleet::Protocol::VERSION,
+      execution_contract: Legion::Extensions::Llm::Fleet::Protocol::EXACT_EXECUTION_CONTRACT,
+      offering_id: offering_id
+    }
+  end
+
+  before do
+    registry.reset!
+    claim_and_activate(
+      key: key, callable: callable, coordinator: coordinator, model: 'gemma4',
+      weight_inputs: { tier: 100, provider: 50, instance: 2, model_or_offering: 1 },
+      base_weight: 10_000
+    )
+    allow(Legion::Extensions::Llm::Fleet::Settings).to receive(:value).and_call_original
+    allow(Legion::Extensions::Llm::Fleet::Settings).to receive(:value)
+      .with(:fleet, :auth, :require_signed_token, default: true).and_return(false)
+    allow(Legion::Extensions::Llm::Fleet::Settings).to receive(:value)
+      .with(:fleet, :responder, :require_idempotency, default: nil).and_return(false)
+    Legion::Extensions::Llm::Fleet::WorkerExecution.reset_idempotency_cache!
+    Legion::Extensions::Llm::Fleet::TokenValidator.reset_replay_cache!
+  end
+
+  it_behaves_like 'B1 — central canonical enforcement (08 F2)'
+  it_behaves_like 'B1b — central canonical tool enforcement (H3)'
+  it_behaves_like 'B2 — canonical outputs (05 O5, 08 R2)'
+  it_behaves_like 'B3 — operation preservation (PR #189 defect class)'
+  it_behaves_like 'B4 — no model re-derivation (PR #45 law)'
+  it_behaves_like 'B5 — no weight recomputation (PR #47 defect class)'
+  it_behaves_like 'B6 — zero-weight disable (U4)'
+  it_behaves_like 'B7 — health authority (RULES 9)'
+  it_behaves_like 'B8 — exact execution never downgrades (06 P2/W1)'
+  it_behaves_like 'B9 — no silent defaults (06 W5)'
+  it_behaves_like 'F1 — envelope round-trip (06 E2)'
+  it_behaves_like 'F2 — rehydration identity (06 W4, E01)'
+  it_behaves_like 'F3 — signing law (06 S3)'
+  it_behaves_like 'F4 — fencing (07 §3)'
+  it_behaves_like 'F5 — response envelope (06 E3/E4)'
+  it_behaves_like 'F6 — contract errors (06 §5)'
+  it_behaves_like 'F7 — retryability (06 F6)'
+  it_behaves_like 'R1 — state machine (07 §3)'
+  it_behaves_like 'R2 — identity (07 §1, 5-tuple law)'
+  it_behaves_like 'R3 — snapshot law (07 §5)'
+  it_behaves_like 'R4 — weight law (07 §4)'
+  it_behaves_like 'R5 — callable lifecycle (07 §6)'
+end